add value and add equation_factory tests

Author: GiovanniCanali

docs/source/_rst/equation/equation_factory.rst

@@ -14,6 +14,6 @@ Equation Factory
    :members:
    :show-inheritance:
 
-.. autoclass:: Laplace
+.. autoclass:: FixedLaplacian
    :members:
    :show-inheritance:

pina/equation/__init__.py

@@ -6,9 +6,14 @@
     "FixedValue",
     "FixedGradient",
     "FixedFlux",
-    "Laplace",
+    "FixedLaplacian",
 ]
 
 from .equation import Equation
-from .equation_factory import FixedFlux, FixedGradient, Laplace, FixedValue
+from .equation_factory import (
+    FixedFlux,
+    FixedGradient,
+    FixedLaplacian,
+    FixedValue,
+)
 from .system_equation import SystemEquation

pina/equation/equation_factory.py

@@ -110,15 +110,16 @@ def equation(input_, output_):
         super().__init__(equation)
 
 
-class Laplace(Equation):
+class FixedLaplacian(Equation):
     """
-    Equation to enforce a null laplacian for a specific condition.
+    Equation to enforce a fixed laplacian for a specific condition.
     """
 
-    def __init__(self, components=None, d=None):
+    def __init__(self, value, components=None, d=None):
         """
-        Initialization of the :class:`Laplace` class.
+        Initialization of the :class:`FixedLaplacian` class.
 
+        :param float value: The fixed value to be enforced to the laplacian.
         :param list[str] components: The name of the output variables for which
             the null laplace condition is applied. It should be a subset of the
             output labels. If ``None``, all output variables are considered.
@@ -131,7 +132,7 @@ def __init__(self, components=None, d=None):
 
         def equation(input_, output_):
             """
-            Definition of the equation to enforce a null laplacian.
+            Definition of the equation to enforce a fixed laplacian.
 
             :param LabelTensor input_: Input points where the equation is
                 evaluated.
@@ -140,6 +141,8 @@ def equation(input_, output_):
             :return: The computed residual of the equation.
             :rtype: LabelTensor
             """
-            return laplacian(output_, input_, components=components, d=d)
+            return (
+                laplacian(output_, input_, components=components, d=d) - value
+            )
 
         super().__init__(equation)

tests/test_equation/test_equation_factory.py

@@ -0,0 +1,70 @@
+from pina.equation import FixedValue, FixedGradient, FixedFlux, FixedLaplacian
+from pina import LabelTensor
+import torch
+import pytest
+
+# Define input and output values
+pts = LabelTensor(torch.rand(10, 3, requires_grad=True), labels=["x", "y", "z"])
+u = torch.pow(pts, 2)
+u.labels = ["u", "v", "w"]
+
+
+@pytest.mark.parametrize("value", [0, 10, -7.5])
+@pytest.mark.parametrize("components", [None, "u", ["u", "w"]])
+def test_fixed_value(value, components):
+
+    # Constructor
+    equation = FixedValue(value=value, components=components)
+
+    # Residual
+    residual = equation.residual(pts, u)
+    len_c = len(components) if components is not None else u.shape[1]
+    assert residual.shape == (pts.shape[0], len_c)
+
+
+@pytest.mark.parametrize("value", [0, 10, -7.5])
+@pytest.mark.parametrize("components", [None, "u", ["u", "w"]])
+@pytest.mark.parametrize("d", [None, "x", ["x", "z"]])
+def test_fixed_gradient(value, components, d):
+
+    # Constructor
+    equation = FixedGradient(value=value, components=components, d=d)
+
+    # Residual
+    residual = equation.residual(pts, u)
+    len_c = len(components) if components is not None else u.shape[1]
+    len_d = len(d) if d is not None else pts.shape[1]
+    assert residual.shape == (pts.shape[0], len_c * len_d)
+
+
+@pytest.mark.parametrize("value", [0, 10, -7.5])
+@pytest.mark.parametrize("components", [None, "u", ["u", "w"]])
+@pytest.mark.parametrize("d", [None, "x", ["x", "z"]])
+def test_fixed_flux(value, components, d):
+
+    # Divergence requires components and d to be of the same length
+    len_c = len(components) if components is not None else u.shape[1]
+    len_d = len(d) if d is not None else pts.shape[1]
+    if len_c != len_d:
+        return
+
+    # Constructor
+    equation = FixedFlux(value=value, components=components, d=d)
+
+    # Residual
+    residual = equation.residual(pts, u)
+    assert residual.shape == (pts.shape[0], 1)
+
+
+@pytest.mark.parametrize("value", [0, 10, -7.5])
+@pytest.mark.parametrize("components", [None, "u", ["u", "w"]])
+@pytest.mark.parametrize("d", [None, "x", ["x", "z"]])
+def test_fixed_laplacian(value, components, d):
+
+    # Constructor
+    equation = FixedLaplacian(value=value, components=components, d=d)
+
+    # Residual
+    residual = equation.residual(pts, u)
+    len_c = len(components) if components is not None else u.shape[1]
+    assert residual.shape == (pts.shape[0], len_c)

tutorials/tutorial12/tutorial.ipynb

@@ -152,8 +152,7 @@
     "Once the equations are set as above in the problem conditions, the PINN solver will aim to minimize the residuals described in each equation during the training phase. \n",
     "\n",
     "### Available classes of equations:\n",
-    "- `FixedGradient` and `FixedFlux`: These work analogously to the `FixedValue` class, where we can enforce a constant value on the gradient or the divergence of the solution, respectively.\n",
-    "- `Laplace`: This class can be used to enforce that the Laplacian of the solution is zero.\n",
+    "- `FixedGradient`, `FixedFlux`, `FixedLaplacian`: These work analogously to the `FixedValue` class, where we can enforce a constant value on the gradient, on the divergence, or on the laplacian of the solution, respectively.\n",
     "- `SystemEquation`: This class allows you to enforce multiple conditions on the same subdomain by passing a list of residual equations defined in the problem.\n",
     "\n",
     "## Defining a new Equation class\n",