add checks on Fixed equations

Author: GiovanniCanali

pina/_src/equation/zoo/fixed_flux.py

@@ -2,6 +2,7 @@
 
 from pina._src.equation.equation import Equation
 from pina._src.core.operator import div
+from pina._src.core.utils import check_consistency
 
 
 class FixedFlux(Equation):
@@ -13,15 +14,29 @@ def __init__(self, value, components=None, d=None):
         """
         Initialization of the :class:`FixedFlux` class.
 
-        :param float value: The fixed value to be enforced to the flux.
-        :param list[str] components: The name of the output variables for which
-            the fixed flux condition is applied. It should be a subset of the
-            output labels. If ``None``, all output variables are considered.
-            Default is ``None``.
-        :param list[str] d: The name of the input variables on which the flux
-            is computed. It should be a subset of the input labels. If ``None``,
-            all the input variables are considered. Default is ``None``.
+        :param value: The fixed value to be enforced to the flux.
+        :type value: float | int
+        :param components: The name of the output variables for which the fixed
+            flux condition is applied. It should be a subset of the output
+            labels. If ``None``, all output variables are considered. Default is
+            ``None``.
+        :type components: str | list[str]
+        :param d: The name of the input variables on which the flux is computed.
+            It should be a subset of the input labels. If ``None``, all the
+            input variables are considered. Default is ``None``.
+        :type d: str | list[str]
+        :raises ValueError: If ``value`` is neither a float nor an integer.
+        :raises ValueError: If, when provided, ``components`` is neither a
+            string nor a list of strings.
+        :raises ValueError: If, when provided, ``d`` is neither a string nor a
+            list of strings.
         """
+        # Check consistency
+        check_consistency(value, (float, int))
+        if components is not None:
+            check_consistency(components, str)
+        if d is not None:
+            check_consistency(d, str)
 
         def equation(input_, output_):
             """

pina/_src/equation/zoo/fixed_gradient.py

@@ -2,6 +2,7 @@
 
 from pina._src.equation.equation import Equation
 from pina._src.core.operator import grad
+from pina._src.core.utils import check_consistency
 
 
 class FixedGradient(Equation):
@@ -14,15 +15,27 @@ def __init__(self, value, components=None, d=None):
         Initialization of the :class:`FixedGradient` class.
 
         :param float value: The fixed value to be enforced to the gradient.
-        :param list[str] components: The name of the output variables for which
-            the fixed gradient condition is applied. It should be a subset of
-            the output labels. If ``None``, all output variables are considered.
-            Default is ``None``.
-        :param list[str] d: The name of the input variables on which the
-            gradient is computed. It should be a subset of the input labels.
-            If ``None``, all the input variables are considered.
-            Default is ``None``.
+        :param components: The name of the output variables for which the fixed
+            gradient condition is applied. It should be a subset of the output
+            labels. If ``None``, all output variables are considered. Default is
+            ``None``.
+        :type components: str | list[str]
+        :param d: The name of the input variables on which the gradient is
+            computed. It should be a subset of the input labels. If ``None``,
+            all the input variables are considered. Default is ``None``.
+        :type d: str | list[str]
+        :raises ValueError: If ``value`` is neither a float nor an integer.
+        :raises ValueError: If, when provided, ``components`` is neither a
+            string nor a list of strings.
+        :raises ValueError: If, when provided, ``d`` is neither a string nor a
+            list of strings.
         """
+        # Check consistency
+        check_consistency(value, (float, int))
+        if components is not None:
+            check_consistency(components, str)
+        if d is not None:
+            check_consistency(d, str)
 
         def equation(input_, output_):
             """

pina/_src/equation/zoo/fixed_laplacian.py

@@ -3,6 +3,7 @@
 import warnings
 from pina._src.equation.equation import Equation
 from pina._src.core.operator import laplacian
+from pina._src.core.utils import check_consistency
 
 
 class FixedLaplacian(Equation):
@@ -14,16 +15,29 @@ def __init__(self, value, components=None, d=None):
         """
         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 fixed laplace condition is applied. It should be a subset of the
-            output labels. If ``None``, all output variables are considered.
-            Default is ``None``.
-        :param list[str] d: The name of the input variables on which the
-            laplacian is computed. It should be a subset of the input labels.
-            If ``None``, all the input variables are considered.
-            Default is ``None``.
+        :param value: The fixed value to be enforced to the laplacian.
+        :type value: float | int
+        :param components: The name of the output variables for which the fixed
+            laplace condition is applied. It should be a subset of the output
+            labels. If ``None``, all output variables are considered. Default is
+            ``None``.
+        :type components: str | list[str]
+        :param d: The name of the input variables on which the laplacian is
+            computed. It should be a subset of the input labels. If ``None``,
+            all the input variables are considered. Default is ``None``.
+        :type d: str | list[str]
+        :raises ValueError: If ``value`` is neither a float nor an integer.
+        :raises ValueError: If, when provided, ``components`` is neither a
+            string nor a list of strings.
+        :raises ValueError: If, when provided, ``d`` is neither a string nor a
+            list of strings.
         """
+        # Check consistency
+        check_consistency(value, (float, int))
+        if components is not None:
+            check_consistency(components, str)
+        if d is not None:
+            check_consistency(d, str)
 
         def equation(input_, output_):
             """

pina/_src/equation/zoo/fixed_value.py

@@ -1,6 +1,7 @@
 """Module for defining the fixed value equation."""
 
 from pina._src.equation.equation import Equation
+from pina._src.core.utils import check_consistency
 
 
 class FixedValue(Equation):
@@ -13,12 +14,21 @@ def __init__(self, value, components=None):
         """
         Initialization of the :class:`FixedValue` class.
 
-        :param float value: The fixed value to be enforced.
-        :param list[str] components: The name of the output variables for which
-            the fixed value condition is applied. It should be a subset of the
-            output labels. If ``None``, all output variables are considered.
-            Default is ``None``.
+        :param value: The fixed value to be enforced.
+        :type value: float | int
+        :param components: The name of the output variables for which the fixed
+            value condition is applied. It should be a subset of the output
+            labels. If ``None``, all output variables are considered. Default is
+            ``None``.
+        :type components: str | list[str]
+        :raises ValueError: If ``value`` is neither a float nor an integer.
+        :raises ValueError: If, when provided, ``components`` is neither a
+            string nor a list of strings.
         """
+        # Check consistency
+        check_consistency(value, (float, int))
+        if components is not None:
+            check_consistency(components, str)
 
         def equation(_, output_):
             """

tests/test_equation_zoo/test_fixed_flux.py

@@ -26,3 +26,15 @@ def test_fixed_flux(value, components, d):
     # Residual
     residual = equation.residual(pts, u)
     assert residual.shape == (pts.shape[0], 1)
+
+    # Should fail if value is neither a float nor an integer
+    with pytest.raises(ValueError):
+        FixedFlux(value="invalid", components=components, d=d)
+
+    # Should fail if components is neither a string nor a list of strings
+    with pytest.raises(ValueError):
+        FixedFlux(value=value, components=123, d=d)
+
+    # Should fail if d is neither a string nor a list of strings
+    with pytest.raises(ValueError):
+        FixedFlux(value=value, components=components, d=123)

tests/test_equation_zoo/test_fixed_gradient.py

@@ -22,3 +22,15 @@ def test_fixed_gradient(value, components, d):
     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)
+
+    # Should fail if value is neither a float nor an integer
+    with pytest.raises(ValueError):
+        FixedGradient(value="invalid", components=components, d=d)
+
+    # Should fail if components is neither a string nor a list of strings
+    with pytest.raises(ValueError):
+        FixedGradient(value=value, components=123, d=d)
+
+    # Should fail if d is neither a string nor a list of strings
+    with pytest.raises(ValueError):
+        FixedGradient(value=value, components=components, d=123)

tests/test_equation_zoo/test_fixed_laplacian.py

@@ -21,3 +21,15 @@ def test_fixed_laplacian(value, components, d):
     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)
+
+    # Should fail if value is neither a float nor an integer
+    with pytest.raises(ValueError):
+        FixedLaplacian(value="invalid", components=components, d=d)
+
+    # Should fail if components is neither a string nor a list of strings
+    with pytest.raises(ValueError):
+        FixedLaplacian(value=value, components=123, d=d)
+
+    # Should fail if d is neither a string nor a list of strings
+    with pytest.raises(ValueError):
+        FixedLaplacian(value=value, components=components, d=123)

tests/test_equation_zoo/test_fixed_value.py

@@ -20,3 +20,11 @@ def test_fixed_value(value, components):
     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)
+
+    # Should fail if value is neither a float nor an integer
+    with pytest.raises(ValueError):
+        FixedValue(value="not a number", components=components)
+
+    # Should fail if components is neither a string nor a list of strings
+    with pytest.raises(ValueError):
+        FixedValue(value=value, components=123)