fix some tests

pina/problem/zoo/__init__.py

@@ -0,0 +1,5 @@
+__all__ = [
+    'Poisson2DSquareProblem'
+]
+
+from .poisson_2d_square import Poisson2DSquareProblem

pina/problem/zoo/poisson_2d_square.py

@@ -0,0 +1,44 @@
+""" Definition of the Poisson problem on a square domain."""
+
+from pina.problem import SpatialProblem
+from pina.operators import laplacian
+from pina import LabelTensor, Condition
+from pina.domain import CartesianDomain
+from pina.equation.equation import Equation
+from pina.equation.equation_factory import FixedValue
+import torch
+
+def laplace_equation(input_, output_):
+    force_term = (torch.sin(input_.extract(['x']) * torch.pi) *
+                  torch.sin(input_.extract(['y']) * torch.pi))
+    delta_u = laplacian(output_.extract(['u']), input_)
+    return delta_u - force_term
+
+
+my_laplace = Equation(laplace_equation)
+
+
+class Poisson2DSquareProblem(SpatialProblem):
+    output_variables = ['u']
+    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}),
+        'g2': CartesianDomain({'x': [0, 1], 'y': 0}),
+        'g3': CartesianDomain({'x': 1, 'y': [0, 1]}),
+        'g4': CartesianDomain({'x': 0, 'y': [0, 1]}),
+    }
+
+    conditions = {
+        'nil_g1': Condition(domain='D', equation=FixedValue(0.0)),
+        'nil_g2': Condition(domain='D', equation=FixedValue(0.0)),
+        'nil_g3': Condition(domain='D', equation=FixedValue(0.0)),
+        'nil_g4': Condition(domain='D', equation=FixedValue(0.0)),
+        'laplace_D': Condition(domain='D', equation=my_laplace),
+    }
+
+    def poisson_sol(self, pts):
+        return -(torch.sin(pts.extract(['x']) * torch.pi) *
+                 torch.sin(pts.extract(['y']) * torch.pi))
+    

tests/test_callbacks/test_adaptive_refinment_callbacks.py

@@ -1,59 +1,13 @@
-from pina.callbacks import R3Refinement
-import torch
-import pytest
-
-from pina.problem import SpatialProblem
-from pina.operators import laplacian
-from pina.domain import CartesianDomain
-from pina import Condition, LabelTensor
 from pina.solvers import PINN
 from pina.trainer import Trainer
 from pina.model import FeedForward
-from pina.equation.equation import Equation
+from pina.problem.zoo import Poisson2DSquareProblem as Poisson
-from pina.equation.equation_factory import FixedValue
+from pina.callbacks import R3Refinement
-
-
-def laplace_equation(input_, output_):
-    force_term = (torch.sin(input_.extract(['x']) * torch.pi) *
-                  torch.sin(input_.extract(['y']) * torch.pi))
-    delta_u = laplacian(output_.extract(['u']), input_)
-    return delta_u - force_term
-
-
-my_laplace = Equation(laplace_equation)
-in_ = LabelTensor(torch.tensor([[0., 1.]]), ['x', 'y'])
-out_ = LabelTensor(torch.tensor([[0.]]), ['u'])
-
-
-class Poisson(SpatialProblem):
-    output_variables = ['u']
-    spatial_domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]})
-
-    conditions = {
-        'gamma1': Condition(
-            location=CartesianDomain({'x': [0, 1], 'y':  1}),
-            equation=FixedValue(0.0)),
-        'gamma2': Condition(
-            location=CartesianDomain({'x': [0, 1], 'y': 0}),
-            equation=FixedValue(0.0)),
-        'gamma3': Condition(
-            location=CartesianDomain({'x':  1, 'y': [0, 1]}),
-            equation=FixedValue(0.0)),
-        'gamma4': Condition(
-            location=CartesianDomain({'x': 0, 'y': [0, 1]}),
-            equation=FixedValue(0.0)),
-        'D': Condition(
-            input_points=LabelTensor(torch.rand(size=(100, 2)), ['x', 'y']),
-            equation=my_laplace),
-        # 'data': Condition(
-        #     input_points=in_,
-        #     output_points=out_)
-    }
 
 
 # make the problem
 poisson_problem = Poisson()
-boundaries = ['gamma1', 'gamma2', 'gamma3', 'gamma4']
+boundaries = ['nil_g1', 'nil_g2', 'nil_g3', 'nil_g4']
 n = 10
 poisson_problem.discretise_domain(n, 'grid', locations=boundaries)
 model = FeedForward(len(poisson_problem.input_variables),

tests/test_callbacks/test_metric_tracker.py

@@ -1,59 +1,13 @@
-import torch
-import pytest
-
-from pina.problem import SpatialProblem
-from pina.operators import laplacian
-from pina.geometry import CartesianDomain
-from pina import Condition, LabelTensor
 from pina.solvers import PINN
 from pina.trainer import Trainer
 from pina.model import FeedForward
-from pina.equation.equation import Equation
-from pina.equation.equation_factory import FixedValue
 from pina.callbacks import MetricTracker
-
+from pina.problem.zoo import Poisson2DSquareProblem as Poisson
-
-def laplace_equation(input_, output_):
-    force_term = (torch.sin(input_.extract(['x']) * torch.pi) *
-                  torch.sin(input_.extract(['y']) * torch.pi))
-    delta_u = laplacian(output_.extract(['u']), input_)
-    return delta_u - force_term
-
-
-my_laplace = Equation(laplace_equation)
-in_ = LabelTensor(torch.tensor([[0., 1.]]), ['x', 'y'])
-out_ = LabelTensor(torch.tensor([[0.]]), ['u'])
-
-
-class Poisson(SpatialProblem):
-    output_variables = ['u']
-    spatial_domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]})
-
-    conditions = {
-        'gamma1': Condition(
-            location=CartesianDomain({'x': [0, 1], 'y':  1}),
-            equation=FixedValue(0.0)),
-        'gamma2': Condition(
-            location=CartesianDomain({'x': [0, 1], 'y': 0}),
-            equation=FixedValue(0.0)),
-        'gamma3': Condition(
-            location=CartesianDomain({'x':  1, 'y': [0, 1]}),
-            equation=FixedValue(0.0)),
-        'gamma4': Condition(
-            location=CartesianDomain({'x': 0, 'y': [0, 1]}),
-            equation=FixedValue(0.0)),
-        'D': Condition(
-            input_points=LabelTensor(torch.rand(size=(100, 2)), ['x', 'y']),
-            equation=my_laplace),
-        'data': Condition(
-            input_points=in_,
-            output_points=out_)
-    }
 
 
 # make the problem
 poisson_problem = Poisson()
-boundaries = ['gamma1', 'gamma2', 'gamma3', 'gamma4']
+boundaries = ['nil_g1', 'nil_g2', 'nil_g3', 'nil_g4']
 n = 10
 poisson_problem.discretise_domain(n, 'grid', locations=boundaries)
 model = FeedForward(len(poisson_problem.input_variables),

tests/test_callbacks/test_optimizer_callbacks.py

@@ -2,58 +2,14 @@ from pina.callbacks import SwitchOptimizer
 import torch
 import pytest
 
-from pina.problem import SpatialProblem
-from pina.operators import laplacian
-from pina.domain import CartesianDomain
-from pina import Condition, LabelTensor
 from pina.solvers import PINN
 from pina.trainer import Trainer
 from pina.model import FeedForward
-from pina.equation.equation import Equation
+from pina.problem.zoo import Poisson2DSquareProblem as Poisson
-from pina.equation.equation_factory import FixedValue
-
-
-def laplace_equation(input_, output_):
-    force_term = (torch.sin(input_.extract(['x']) * torch.pi) *
-                  torch.sin(input_.extract(['y']) * torch.pi))
-    delta_u = laplacian(output_.extract(['u']), input_)
-    return delta_u - force_term
-
-
-my_laplace = Equation(laplace_equation)
-in_ = LabelTensor(torch.tensor([[0., 1.]]), ['x', 'y'])
-out_ = LabelTensor(torch.tensor([[0.]]), ['u'])
-
-
-class Poisson(SpatialProblem):
-    output_variables = ['u']
-    spatial_domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]})
-
-    conditions = {
-        'gamma1': Condition(
-            location=CartesianDomain({'x': [0, 1], 'y':  1}),
-            equation=FixedValue(0.0)),
-        'gamma2': Condition(
-            location=CartesianDomain({'x': [0, 1], 'y': 0}),
-            equation=FixedValue(0.0)),
-        'gamma3': Condition(
-            location=CartesianDomain({'x':  1, 'y': [0, 1]}),
-            equation=FixedValue(0.0)),
-        'gamma4': Condition(
-            location=CartesianDomain({'x': 0, 'y': [0, 1]}),
-            equation=FixedValue(0.0)),
-        'D': Condition(
-            input_points=LabelTensor(torch.rand(size=(100, 2)), ['x', 'y']),
-            equation=my_laplace),
-        # 'data': Condition(
-        #     input_points=in_,
-        #     output_points=out_)
-    }
-
 
 # make the problem
 poisson_problem = Poisson()
-boundaries = ['gamma1', 'gamma2', 'gamma3', 'gamma4']
+boundaries = ['nil_g1', 'nil_g2', 'nil_g3', 'nil_g4']
 n = 10
 poisson_problem.discretise_domain(n, 'grid', locations=boundaries)
 model = FeedForward(len(poisson_problem.input_variables),

tests/test_callbacks/test_progress_bar.py

@@ -1,59 +1,13 @@
-import torch
-import pytest
-
-from pina.problem import SpatialProblem
-from pina.operators import laplacian
-from pina.geometry import CartesianDomain
-from pina import Condition, LabelTensor
 from pina.solvers import PINN
 from pina.trainer import Trainer
 from pina.model import FeedForward
-from pina.equation.equation import Equation
-from pina.equation.equation_factory import FixedValue
 from pina.callbacks.processing_callbacks import PINAProgressBar
-
+from pina.problem.zoo import Poisson2DSquareProblem as Poisson
-
-def laplace_equation(input_, output_):
-    force_term = (torch.sin(input_.extract(['x']) * torch.pi) *
-                  torch.sin(input_.extract(['y']) * torch.pi))
-    delta_u = laplacian(output_.extract(['u']), input_)
-    return delta_u - force_term
-
-
-my_laplace = Equation(laplace_equation)
-in_ = LabelTensor(torch.tensor([[0., 1.]]), ['x', 'y'])
-out_ = LabelTensor(torch.tensor([[0.]]), ['u'])
-
-
-class Poisson(SpatialProblem):
-    output_variables = ['u']
-    spatial_domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]})
-
-    conditions = {
-        'gamma1': Condition(
-            location=CartesianDomain({'x': [0, 1], 'y':  1}),
-            equation=FixedValue(0.0)),
-        'gamma2': Condition(
-            location=CartesianDomain({'x': [0, 1], 'y': 0}),
-            equation=FixedValue(0.0)),
-        'gamma3': Condition(
-            location=CartesianDomain({'x':  1, 'y': [0, 1]}),
-            equation=FixedValue(0.0)),
-        'gamma4': Condition(
-            location=CartesianDomain({'x': 0, 'y': [0, 1]}),
-            equation=FixedValue(0.0)),
-        'D': Condition(
-            input_points=LabelTensor(torch.rand(size=(100, 2)), ['x', 'y']),
-            equation=my_laplace),
-        'data': Condition(
-            input_points=in_,
-            output_points=out_)
-    }
 
 
 # make the problem
 poisson_problem = Poisson()
-boundaries = ['gamma1', 'gamma2', 'gamma3', 'gamma4']
+boundaries = ['nil_g1', 'nil_g2', 'nil_g3', 'nil_g4']
 n = 10
 poisson_problem.discretise_domain(n, 'grid', locations=boundaries)
 model = FeedForward(len(poisson_problem.input_variables),

tests/test_problem_zoo/test_poisson_2d_square.py

@@ -0,0 +1,7 @@
+import torch
+import pytest
+
+from pina.problem.zoo import Poisson2DSquareProblem
+
+def test_constructor():
+    Poisson2DSquareProblem()