update problem zoo and tests post domain refactory

GiovanniCanali · GiovanniCanali · commit 9be5a27873d9 · 2025-12-15T16:34:26.000+01:00
diff --git a/pina/problem/abstract_problem.py b/pina/problem/abstract_problem.py
@@ -328,7 +328,9 @@ def collect_data(self):
                 # Only store the discretisation points if the domain is
                 # in the dictionary
                 if condition.domain in self.discretised_domains:
-                    samples = self.discretised_domains[condition.domain]
+                    samples = self.discretised_domains[condition.domain][
+                        self.input_variables
+                    ]
                     data[condition_name] = {
                         "input": samples,
                         "equation": condition.equation,
diff --git a/pina/problem/zoo/acoustic_wave.py b/pina/problem/zoo/acoustic_wave.py
@@ -50,19 +50,17 @@ class AcousticWaveProblem(TimeDependentProblem, SpatialProblem):
     temporal_domain = CartesianDomain({"t": [0, 1]})
 
     domains = {
-        "D": CartesianDomain({"x": [0, 1], "t": [0, 1]}),
-        "t0": CartesianDomain({"x": [0, 1], "t": 0.0}),
-        "g1": CartesianDomain({"x": 0.0, "t": [0, 1]}),
-        "g2": CartesianDomain({"x": 1.0, "t": [0, 1]}),
+        "D": spatial_domain.update(temporal_domain),
+        "t0": spatial_domain.update(CartesianDomain({"t": 0})),
+        "boundary": spatial_domain.partial().update(temporal_domain),
     }
 
     conditions = {
-        "g1": Condition(domain="g1", equation=FixedValue(value=0.0)),
-        "g2": Condition(domain="g2", equation=FixedValue(value=0.0)),
+        "boundary": Condition(domain="boundary", equation=FixedValue(0.0)),
         "t0": Condition(
             domain="t0",
             equation=SystemEquation(
-                [Equation(initial_condition), FixedGradient(value=0.0, d="t")]
+                [Equation(initial_condition), FixedGradient(0.0, d="t")]
             ),
         ),
     }
diff --git a/pina/problem/zoo/advection.py b/pina/problem/zoo/advection.py
@@ -42,8 +42,8 @@ class AdvectionProblem(SpatialProblem, TimeDependentProblem):
     temporal_domain = CartesianDomain({"t": [0, 1]})
 
     domains = {
-        "D": CartesianDomain({"x": [0, 2 * torch.pi], "t": [0, 1]}),
-        "t0": CartesianDomain({"x": [0, 2 * torch.pi], "t": 0.0}),
+        "D": spatial_domain.update(temporal_domain),
+        "t0": spatial_domain.update(CartesianDomain({"t": 0})),
     }
 
     conditions = {
diff --git a/pina/problem/zoo/allen_cahn.py b/pina/problem/zoo/allen_cahn.py
@@ -47,8 +47,8 @@ class AllenCahnProblem(TimeDependentProblem, SpatialProblem):
     temporal_domain = CartesianDomain({"t": [0, 1]})
 
     domains = {
-        "D": CartesianDomain({"x": [-1, 1], "t": [0, 1]}),
-        "t0": CartesianDomain({"x": [-1, 1], "t": 0.0}),
+        "D": spatial_domain.update(temporal_domain),
+        "t0": spatial_domain.update(CartesianDomain({"t": 0})),
     }
 
     conditions = {
diff --git a/pina/problem/zoo/diffusion_reaction.py b/pina/problem/zoo/diffusion_reaction.py
@@ -49,15 +49,13 @@ class DiffusionReactionProblem(TimeDependentProblem, SpatialProblem):
     temporal_domain = CartesianDomain({"t": [0, 1]})
 
     domains = {
-        "D": CartesianDomain({"x": [-torch.pi, torch.pi], "t": [0, 1]}),
-        "g1": CartesianDomain({"x": -torch.pi, "t": [0, 1]}),
-        "g2": CartesianDomain({"x": torch.pi, "t": [0, 1]}),
-        "t0": CartesianDomain({"x": [-torch.pi, torch.pi], "t": 0.0}),
+        "D": spatial_domain.update(temporal_domain),
+        "boundary": spatial_domain.partial().update(temporal_domain),
+        "t0": spatial_domain.update(CartesianDomain({"t": 0})),
     }
 
     conditions = {
-        "g1": Condition(domain="g1", equation=FixedValue(0.0)),
-        "g2": Condition(domain="g2", equation=FixedValue(0.0)),
+        "boundary": Condition(domain="boundary", equation=FixedValue(0.0)),
         "t0": Condition(domain="t0", equation=Equation(initial_condition)),
     }
 
diff --git a/pina/problem/zoo/helmholtz.py b/pina/problem/zoo/helmholtz.py
@@ -28,18 +28,12 @@ class HelmholtzProblem(SpatialProblem):
     spatial_domain = CartesianDomain({"x": [-1, 1], "y": [-1, 1]})
 
     domains = {
-        "D": CartesianDomain({"x": [-1, 1], "y": [-1, 1]}),
-        "g1": CartesianDomain({"x": [-1, 1], "y": 1.0}),
-        "g2": CartesianDomain({"x": [-1, 1], "y": -1.0}),
-        "g3": CartesianDomain({"x": 1.0, "y": [-1, 1]}),
-        "g4": CartesianDomain({"x": -1.0, "y": [-1, 1]}),
+        "D": spatial_domain,
+        "boundary": spatial_domain.partial(),
     }
 
     conditions = {
-        "g1": Condition(domain="g1", equation=FixedValue(0.0)),
-        "g2": Condition(domain="g2", equation=FixedValue(0.0)),
-        "g3": Condition(domain="g3", equation=FixedValue(0.0)),
-        "g4": Condition(domain="g4", equation=FixedValue(0.0)),
+        "boundary": Condition(domain="boundary", equation=FixedValue(0.0)),
     }
 
     def __init__(self, alpha=3.0):
diff --git a/pina/problem/zoo/inverse_poisson_2d_square.py b/pina/problem/zoo/inverse_poisson_2d_square.py
@@ -90,19 +90,13 @@ class InversePoisson2DSquareProblem(SpatialProblem, InverseProblem):
     unknown_parameter_domain = CartesianDomain({"mu1": [-1, 1], "mu2": [-1, 1]})
 
     domains = {
-        "g1": CartesianDomain({"x": [x_min, x_max], "y": y_max}),
-        "g2": CartesianDomain({"x": [x_min, x_max], "y": y_min}),
-        "g3": CartesianDomain({"x": x_max, "y": [y_min, y_max]}),
-        "g4": CartesianDomain({"x": x_min, "y": [y_min, y_max]}),
-        "D": CartesianDomain({"x": [x_min, x_max], "y": [y_min, y_max]}),
+        "D": spatial_domain,
+        "boundary": spatial_domain.partial(),
     }
 
     conditions = {
-        "g1": Condition(domain="g1", equation=FixedValue(0.0)),
-        "g2": Condition(domain="g2", equation=FixedValue(0.0)),
-        "g3": Condition(domain="g3", equation=FixedValue(0.0)),
-        "g4": Condition(domain="g4", equation=FixedValue(0.0)),
         "D": Condition(domain="D", equation=Equation(laplace_equation)),
+        "boundary": Condition(domain="boundary", equation=FixedValue(0.0)),
     }
 
     def __init__(self, load=True, data_size=1.0):
diff --git a/pina/problem/zoo/poisson_2d_square.py b/pina/problem/zoo/poisson_2d_square.py
@@ -36,18 +36,12 @@ class Poisson2DSquareProblem(SpatialProblem):
     spatial_domain = CartesianDomain({"x": [0, 1], "y": [0, 1]})
 
     domains = {
-        "D": CartesianDomain({"x": [0, 1], "y": [0, 1]}),
-        "g1": CartesianDomain({"x": [0, 1], "y": 1.0}),
-        "g2": CartesianDomain({"x": [0, 1], "y": 0.0}),
-        "g3": CartesianDomain({"x": 1.0, "y": [0, 1]}),
-        "g4": CartesianDomain({"x": 0.0, "y": [0, 1]}),
+        "D": spatial_domain,
+        "boundary": spatial_domain.partial(),
     }
 
     conditions = {
-        "g1": Condition(domain="g1", equation=FixedValue(0.0)),
-        "g2": Condition(domain="g2", equation=FixedValue(0.0)),
-        "g3": Condition(domain="g3", equation=FixedValue(0.0)),
-        "g4": Condition(domain="g4", equation=FixedValue(0.0)),
+        "boundary": Condition(domain="boundary", equation=FixedValue(0.0)),
         "D": Condition(domain="D", equation=Poisson(forcing_term=forcing_term)),
     }
 
diff --git a/tests/test_callback/test_metric_tracker.py b/tests/test_callback/test_metric_tracker.py
@@ -7,9 +7,8 @@
 
 # make the problem
 poisson_problem = Poisson()
-boundaries = ["g1", "g2", "g3", "g4"]
 n = 10
-poisson_problem.discretise_domain(n, "grid", domains=boundaries)
+poisson_problem.discretise_domain(n, "grid", domains="boundary")
 poisson_problem.discretise_domain(n, "grid", domains="D")
 model = FeedForward(
     len(poisson_problem.input_variables), len(poisson_problem.output_variables)
diff --git a/tests/test_callback/test_pina_progress_bar.py b/tests/test_callback/test_pina_progress_bar.py
@@ -7,10 +7,9 @@
 
 # make the problem
 poisson_problem = Poisson()
-boundaries = ["g1", "g2", "g3", "g4"]
 n = 10
 condition_names = list(poisson_problem.conditions.keys())
-poisson_problem.discretise_domain(n, "grid", domains=boundaries)
+poisson_problem.discretise_domain(n, "grid", domains="boundary")
 poisson_problem.discretise_domain(n, "grid", domains="D")
 model = FeedForward(
     len(poisson_problem.input_variables), len(poisson_problem.output_variables)
diff --git a/tests/test_callback/test_r3_refinement.py b/tests/test_callback/test_r3_refinement.py
@@ -9,7 +9,7 @@
 
 # make the problem
 poisson_problem = Poisson()
-poisson_problem.discretise_domain(10, "grid", domains=["g1", "g2", "g3", "g4"])
+poisson_problem.discretise_domain(10, "grid", domains="boundary")
 poisson_problem.discretise_domain(10, "grid", domains="D")
 model = FeedForward(
     len(poisson_problem.input_variables), len(poisson_problem.output_variables)
@@ -29,9 +29,7 @@ def test_constructor():
         R3Refinement(sample_every=10, condition_to_update=3)
 
 
-@pytest.mark.parametrize(
-    "condition_to_update", [["D", "g1"], ["D", "g1", "g2", "g3", "g4"]]
-)
+@pytest.mark.parametrize("condition_to_update", [["D"], ["boundary", "D"]])
 def test_sample(condition_to_update):
     trainer = Trainer(
         solver=solver,
diff --git a/tests/test_problem.py b/tests/test_problem.py
@@ -13,16 +13,16 @@
 def test_discretise_domain():
     n = 10
     poisson_problem = Poisson()
-    boundaries = ["g1", "g2", "g3", "g4"]
-    poisson_problem.discretise_domain(n, "grid", domains=boundaries)
-    for b in boundaries:
-        assert poisson_problem.discretised_domains[b].shape[0] == n
-    poisson_problem.discretise_domain(n, "random", domains=boundaries)
-    for b in boundaries:
-        assert poisson_problem.discretised_domains[b].shape[0] == n
+
+    poisson_problem.discretise_domain(n, "grid", domains="boundary")
+    assert poisson_problem.discretised_domains["boundary"].shape[0] == n
+
+    poisson_problem.discretise_domain(n, "random", domains="boundary")
+    assert poisson_problem.discretised_domains["boundary"].shape[0] == n
 
     poisson_problem.discretise_domain(n, "grid", domains=["D"])
     assert poisson_problem.discretised_domains["D"].shape[0] == n**2
+
     poisson_problem.discretise_domain(n, "random", domains=["D"])
     assert poisson_problem.discretised_domains["D"].shape[0] == n
 
@@ -89,10 +89,9 @@ def test_custom_sampling_logic(mode):
         "x": {"n": 100, "mode": mode},
         "y": {"n": 50, "mode": mode},
     }
-    poisson_problem.discretise_domain(sample_rules=sampling_rules)
-    for domain in ["g1", "g2", "g3", "g4"]:
-        assert poisson_problem.discretised_domains[domain].shape[0] == 100 * 50
-        assert poisson_problem.discretised_domains[domain].labels == ["x", "y"]
+    poisson_problem.discretise_domain(sample_rules=sampling_rules, domains="D")
+    assert poisson_problem.discretised_domains["D"].shape[0] == 100 * 50
+    assert poisson_problem.discretised_domains["D"].labels == ["x", "y"]
 
 
 @pytest.mark.parametrize("mode", ["random", "grid"])
diff --git a/tutorials/README.md b/tutorials/README.md
@@ -14,7 +14,7 @@ How to build a `Problem` in PINA|[[.ipynb](tutorial16/tutorial.ipynb),[.py](tuto
 Introduction to Solver classes|[[.ipynb](tutorial18/tutorial.ipynb),[.py](tutorial18/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial18/tutorial.html)]|
 Introduction to `Trainer` class|[[.ipynb](tutorial11/tutorial.ipynb),[.py](tutorial11/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial11/tutorial.html)]|
 Data structure for SciML: `Tensor`, `LabelTensor`, `Data` and `Graph` |[[.ipynb](tutorial19/tutorial.ipynb),[.py](tutorial19/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial19/tutorial.html)]|
-Building geometries with `DomainInterface` class|[[.ipynb](tutorial6/tutorial.ipynb),[.py](tutorial6/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial6/tutorial.html)]|
+Building domains with PINA's BaseDomain class|[[.ipynb](tutorial6/tutorial.ipynb),[.py](tutorial6/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial6/tutorial.html)]|
 Introduction to PINA `Equation` class|[[.ipynb](tutorial12/tutorial.ipynb),[.py](tutorial12/tutorial.py),[.html](http://mathlab.github.io/PINA/tutorial12/tutorial.html)]|
 
 

Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,8 @@ class AdvectionProblem(SpatialProblem, TimeDependentProblem):`
`42`	`42`	`temporal_domain = CartesianDomain({"t": [0, 1]})`
`43`	`43`
`44`	`44`	`domains = {`
`45`		`- "D": CartesianDomain({"x": [0, 2 * torch.pi], "t": [0, 1]}),`
`46`		`- "t0": CartesianDomain({"x": [0, 2 * torch.pi], "t": 0.0}),`
	`45`	`+ "D": spatial_domain.update(temporal_domain),`
	`46`	`+ "t0": spatial_domain.update(CartesianDomain({"t": 0})),`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`conditions = {`
Original file line number	Diff line number	Diff line change
`@@ -47,8 +47,8 @@ class AllenCahnProblem(TimeDependentProblem, SpatialProblem):`
`47`	`47`	`temporal_domain = CartesianDomain({"t": [0, 1]})`
`48`	`48`
`49`	`49`	`domains = {`
`50`		`- "D": CartesianDomain({"x": [-1, 1], "t": [0, 1]}),`
`51`		`- "t0": CartesianDomain({"x": [-1, 1], "t": 0.0}),`
	`50`	`+ "D": spatial_domain.update(temporal_domain),`
	`51`	`+ "t0": spatial_domain.update(CartesianDomain({"t": 0})),`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`conditions = {`