Update solvers (#434)

* Enable DDP training with batch_size=None and add validity check for split sizes
* Refactoring SolverInterfaces (#435)
* Solver update + weighting
* Updating PINN for 0.2
* Modify GAROM + tests
* Adding more versatile loggers
* Disable compilation when running on Windows
* Fix tests

---------

Co-authored-by: giovanni <giovanni.canali98@yahoo.it>
Co-authored-by: FilippoOlivo <filippo@filippoolivo.com>

pina/problem/abstract_problem.py

@@ -36,8 +36,7 @@ class AbstractProblem(metaclass=ABCMeta):
         if not hasattr(self, "domains"):
             self.domains = {}
         for cond_name, cond in self.conditions.items():
-            if isinstance(cond, (DomainEquationCondition,
-                                 InputPointsEquationCondition)):
+            if isinstance(cond, DomainEquationCondition):
                 if isinstance(cond.domain, DomainInterface):
                     self.domains[cond_name] = cond.domain
                     cond.domain = cond_name

pina/problem/zoo/__init__.py

@@ -1,8 +1,13 @@
 __all__ = [
     'Poisson2DSquareProblem',
-    'SupervisedProblem'
-    
+    'SupervisedProblem',
+    'InversePoisson2DSquareProblem',
+    'DiffusionReactionProblem',
+    'InverseDiffusionReactionProblem'
 ]
 
 from .poisson_2d_square import Poisson2DSquareProblem
-from .supervised_problem import SupervisedProblem
+from .supervised_problem import SupervisedProblem
+from .inverse_poisson_2d_square import InversePoisson2DSquareProblem
+from .diffusion_reaction import DiffusionReactionProblem
+from .inverse_diffusion_reaction import InverseDiffusionReactionProblem

pina/problem/zoo/diffusion_reaction.py

@@ -0,0 +1,45 @@
+""" Definition of the diffusion-reaction problem."""
+
+import torch
+from pina import Condition
+from pina.problem import SpatialProblem, TimeDependentProblem
+from pina.equation.equation import Equation
+from pina.domain import CartesianDomain
+from pina.operators import grad
+
+def diffusion_reaction(input_, output_):
+    """
+    Implementation of the diffusion-reaction equation.
+    """
+    x = input_.extract('x')
+    t = input_.extract('t')
+    u_t = grad(output_, input_, d='t')
+    u_x = grad(output_, input_, d='x')
+    u_xx = grad(u_x, input_, d='x')
+    r = torch.exp(-t) * (1.5 * torch.sin(2*x) + (8/3) * torch.sin(3*x) +
+                         (15/4) * torch.sin(4*x) + (63/8) * torch.sin(8*x))
+    return u_t - u_xx - r
+
+
+class DiffusionReactionProblem(TimeDependentProblem, SpatialProblem):
+    """
+    Implementation of the diffusion-reaction problem on the spatial interval
+    [-pi, pi] and temporal interval [0,1].
+    """
+    output_variables = ['u']
+    spatial_domain = CartesianDomain({'x': [-torch.pi, torch.pi]})
+    temporal_domain = CartesianDomain({'t': [0, 1]})
+
+    conditions = {
+        'D': Condition(
+            domain=CartesianDomain({'x': [-torch.pi, torch.pi], 't': [0, 1]}),
+            equation=Equation(diffusion_reaction))
+    }
+
+    def _solution(self, pts):
+        t = pts.extract('t')
+        x = pts.extract('x')
+        return torch.exp(-t) * (
+            torch.sin(x) + (1/2)*torch.sin(2*x) + (1/3)*torch.sin(3*x) +
+            (1/4)*torch.sin(4*x) + (1/8)*torch.sin(8*x)
+        )

pina/problem/zoo/inverse_diffusion_reaction.py

@@ -0,0 +1,51 @@
+""" Definition of the diffusion-reaction problem."""
+
+import torch
+from pina import Condition, LabelTensor
+from pina.problem import SpatialProblem, TimeDependentProblem, InverseProblem
+from pina.equation.equation import Equation
+from pina.domain import CartesianDomain
+from pina.operators import grad
+
+def diffusion_reaction(input_, output_):
+    """
+    Implementation of the diffusion-reaction equation.
+    """
+    x = input_.extract('x')
+    t = input_.extract('t')
+    u_t = grad(output_, input_, d='t')
+    u_x = grad(output_, input_, d='x')
+    u_xx = grad(u_x, input_, d='x')
+    r = torch.exp(-t) * (1.5 * torch.sin(2*x) + (8/3) * torch.sin(3*x) +
+                         (15/4) * torch.sin(4*x) + (63/8) * torch.sin(8*x))
+    return u_t - u_xx - r
+
+class InverseDiffusionReactionProblem(TimeDependentProblem,
+                                      SpatialProblem,
+                                      InverseProblem):
+    """
+    Implementation of the diffusion-reaction inverse problem on the spatial 
+    interval [-pi, pi] and temporal interval [0,1], with unknown parameters 
+    in the interval [-1,1].
+    """
+    output_variables = ['u']
+    spatial_domain = CartesianDomain({'x': [-torch.pi, torch.pi]})
+    temporal_domain = CartesianDomain({'t': [0, 1]})
+    unknown_parameter_domain = CartesianDomain({'mu': [-1, 1]})
+
+    conditions = {
+        'D': Condition(
+            domain=CartesianDomain({'x': [-torch.pi, torch.pi], 't': [0, 1]}),
+            equation=Equation(diffusion_reaction)),
+        'data' : Condition(
+            input_points=LabelTensor(torch.randn(10, 2), ['x', 't']),
+            output_points=LabelTensor(torch.randn(10, 1), ['u'])),
+    }
+
+    def _solution(self, pts):
+        t = pts.extract('t')
+        x = pts.extract('x')
+        return torch.exp(-t) * (
+            torch.sin(x) + (1/2)*torch.sin(2*x) + (1/3)*torch.sin(3*x) +
+            (1/4)*torch.sin(4*x) + (1/8)*torch.sin(8*x)
+        )

pina/problem/zoo/inverse_poisson_2d_square.py

@@ -0,0 +1,50 @@
+""" Definition of the inverse Poisson problem on a square domain."""
+
+import torch
+from pina import Condition, LabelTensor
+from pina.problem import SpatialProblem, InverseProblem
+from pina.operators import laplacian
+from pina.domain import CartesianDomain
+from pina.equation.equation import Equation
+from pina.equation.equation_factory import FixedValue
+
+def laplace_equation(input_, output_, params_):
+    """
+    Implementation of the laplace equation.
+    """
+    force_term = torch.exp(- 2*(input_.extract(['x']) - params_['mu1'])**2
+                            - 2*(input_.extract(['y']) - params_['mu2'])**2)
+    delta_u = laplacian(output_, input_, components=['u'], d=['x', 'y'])
+    return delta_u - force_term
+
+class InversePoisson2DSquareProblem(SpatialProblem, InverseProblem):
+    """
+    Implementation of the inverse 2-dimensional Poisson problem 
+    on a square domain, with parameter domain [-1, 1] x [-1, 1].
+    """
+    output_variables = ['u']
+    x_min, x_max = -2, 2
+    y_min, y_max = -2, 2
+    data_input = LabelTensor(torch.rand(10, 2), ['x', 'y'])
+    data_output = LabelTensor(torch.rand(10, 1), ['u'])
+    spatial_domain = CartesianDomain({'x': [x_min, x_max], 'y': [y_min, y_max]})
+    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]}),
+    }
+
+    conditions = {
+        'nil_g1': Condition(domain='g1', equation=FixedValue(0.0)),
+        'nil_g2': Condition(domain='g2', equation=FixedValue(0.0)),
+        'nil_g3': Condition(domain='g3', equation=FixedValue(0.0)),
+        'nil_g4': Condition(domain='g4', equation=FixedValue(0.0)),
+        'laplace_D': Condition(domain='D', equation=Equation(laplace_equation)),
+        'data': Condition(
+            input_points=data_input.extract(['x', 'y']),
+            output_points=data_output)
+    }

pina/problem/zoo/poisson_2d_square.py

@@ -2,23 +2,27 @@
 
 from pina.problem import SpatialProblem
 from pina.operators import laplacian
-from pina import LabelTensor, Condition
+from pina import 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_):
+    """
+    Implementation of the laplace equation.
+    """
     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):
+    """
+    Implementation of the 2-dimensional Poisson problem on a square domain.
+    """
     output_variables = ['u']
     spatial_domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]})
 
@@ -31,10 +35,10 @@ class Poisson2DSquareProblem(SpatialProblem):
     }
 
     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)),
+        'nil_g1': Condition(domain='g1', equation=FixedValue(0.0)),
+        'nil_g2': Condition(domain='g2', equation=FixedValue(0.0)),
+        'nil_g3': Condition(domain='g3', equation=FixedValue(0.0)),
+        'nil_g4': Condition(domain='g4', equation=FixedValue(0.0)),
         'laplace_D': Condition(domain='D', equation=my_laplace),
     }