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/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)
+        )