add acoustic wave problem

Author: GiovanniCanali

docs/source/_rst/_code.rst

@@ -215,6 +215,7 @@ Problems Zoo
 .. toctree::
     :titlesonly:
 
+    AcousticWaveProblem <problem/zoo/acoustic_wave.rst>
     AdvectionProblem <problem/zoo/advection.rst>
     AllenCahnProblem <problem/zoo/allen_cahn.rst>
     DiffusionReactionProblem <problem/zoo/diffusion_reaction.rst>

docs/source/_rst/problem/zoo/acoustic_wave.rst

@@ -0,0 +1,9 @@
+AcousticWaveProblem
+=====================
+.. currentmodule:: pina.problem.zoo.acoustic_wave
+
+.. automodule:: pina.problem.zoo.acoustic_wave
+
+.. autoclass:: AcousticWaveProblem
+    :members:
+    :show-inheritance:

pina/equation/__init__.py

@@ -13,6 +13,7 @@
     "DiffusionReaction",
     "Helmholtz",
     "Poisson",
+    "AcousticWave",
 ]
 
 from .equation import Equation
@@ -27,5 +28,6 @@
     DiffusionReaction,
     Helmholtz,
     Poisson,
+    AcousticWave,
 )
 from .system_equation import SystemEquation

pina/equation/equation_factory.py

@@ -6,9 +6,6 @@
 from ..operator import grad, div, laplacian
 from ..utils import check_consistency
 
-# Pylint warning disabled because the classes defined in this module
-# inherit from Equation and are meant to be simple containers for equations.
-
 
 class FixedValue(Equation):  # pylint: disable=R0903
     """
@@ -452,3 +449,60 @@ def equation(input_, output_):
             return lap - self.forcing_term(input_)
 
         super().__init__(equation)
+
+
+class AcousticWave(Equation):  # pylint: disable=R0903
+    r"""
+    Implementation of the N-dimensional isotropic acoustic wave equation.
+    The equation is defined as follows:
+
+    .. math::
+
+        \frac{\partial^2 u}{\partial t^2} - c^2 \Delta u = 0
+
+    or alternatively:
+
+    .. math::
+
+        \Box u = 0
+
+    Here, :math:`c` is the wave propagation speed, and :math:`\Box` is the
+    d'Alembert operator.
+    """
+
+    def __init__(self, c):
+        """
+        Initialization of the :class:`AcousticWaveEquation` class.
+
+        :param c: The wave propagation speed.
+        :type c: float | int
+        """
+        check_consistency(c, (float, int))
+        self.c = c
+
+        def equation(input_, output_):
+            """
+            Implementation of the acoustic wave equation.
+
+            :param LabelTensor input_: The input data of the problem.
+            :param LabelTensor output_: The output data of the problem.
+            :return: The residual of the acoustic wave equation.
+            :rtype: LabelTensor
+            :raises ValueError: If the ``input_`` labels do not contain the time
+                variable 't'.
+            """
+            # Ensure time is passed as input
+            if "t" not in input_.labels:
+                raise ValueError(
+                    "The ``input_`` labels must contain the time 't' variable."
+                )
+
+            # Compute the time second derivative and the spatial laplacian
+            u_tt = laplacian(output_, input_, d=["t"])
+            u_xx = laplacian(
+                output_, input_, d=[di for di in input_.labels if di != "t"]
+            )
+
+            return u_tt - self.c**2 * u_xx
+
+        super().__init__(equation)

pina/problem/zoo/__init__.py

@@ -8,6 +8,7 @@
     "Poisson2DSquareProblem",
     "DiffusionReactionProblem",
     "InversePoisson2DSquareProblem",
+    "AcousticWaveProblem",
 ]
 
 from .supervised_problem import SupervisedProblem
@@ -17,3 +18,4 @@
 from .poisson_2d_square import Poisson2DSquareProblem
 from .diffusion_reaction import DiffusionReactionProblem
 from .inverse_poisson_2d_square import InversePoisson2DSquareProblem
+from .acoustic_wave import AcousticWaveProblem

pina/problem/zoo/acoustic_wave.py

@@ -0,0 +1,97 @@
+"""Formulation of the acoustic wave problem."""
+
+import torch
+from ... import Condition
+from ...problem import SpatialProblem, TimeDependentProblem
+from ...utils import check_consistency
+from ...domain import CartesianDomain
+from ...equation import (
+    Equation,
+    SystemEquation,
+    FixedValue,
+    FixedGradient,
+    AcousticWave,
+)
+
+
+def initial_condition(input_, output_):
+    """
+    Definition of the initial condition of the acoustic wave problem.
+
+    :param LabelTensor input_: The input data of the problem.
+    :param LabelTensor output_: The output data of the problem.
+    :return: The residual of the initial condition.
+    :rtype: LabelTensor
+    """
+    arg = torch.pi * input_["x"]
+    return output_ - torch.sin(arg) - 0.5 * torch.sin(4 * arg)
+
+
+class AcousticWaveProblem(TimeDependentProblem, SpatialProblem):
+    r"""
+    Implementation of the acoustic wave problem in the spatial interval
+    :math:`[0, 1]` and temporal interval :math:`[0, 1]`.
+
+    .. seealso::
+
+        **Original reference**: Wang, Sifan, Xinling Yu, and
+        Paris Perdikaris. *When and why PINNs fail to train:
+        A neural tangent kernel perspective*. Journal of
+        Computational Physics 449 (2022): 110768.
+        DOI: `10.1016 <https://doi.org/10.1016/j.jcp.2021.110768>`_.
+
+    :Example:
+
+        >>> problem = AcousticWaveProblem(c=2.0)
+    """
+
+    output_variables = ["u"]
+    spatial_domain = CartesianDomain({"x": [0, 1]})
+    temporal_domain = CartesianDomain({"t": [0, 1]})
+
+    domains = {
+        "D": CartesianDomain({"x": [0, 1], "t": [0, 1]}),
+        "t0": CartesianDomain({"x": [0, 1], "t": 0.0}),
+        "g1": CartesianDomain({"x": 0.0, "t": [0, 1]}),
+        "g2": CartesianDomain({"x": 1.0, "t": [0, 1]}),
+    }
+
+    conditions = {
+        "g1": Condition(domain="g1", equation=FixedValue(value=0.0)),
+        "g2": Condition(domain="g2", equation=FixedValue(value=0.0)),
+        "t0": Condition(
+            domain="t0",
+            equation=SystemEquation(
+                [Equation(initial_condition), FixedGradient(value=0.0, d="t")]
+            ),
+        ),
+    }
+
+    def __init__(self, c=2.0):
+        """
+        Initialization of the :class:`AcousticWaveProblem` class.
+
+        :param c: The wave propagation speed. Default is 2.0.
+        :type c: float | int
+        """
+        super().__init__()
+        check_consistency(c, (float, int))
+        self.c = c
+
+        self.conditions["D"] = Condition(
+            domain="D", equation=AcousticWave(self.c)
+        )
+
+    def solution(self, pts):
+        """
+        Implementation of the analytical solution of the acoustic wave problem.
+
+        :param LabelTensor pts: Points where the solution is evaluated.
+        :return: The analytical solution of the acoustic wave problem.
+        :rtype: LabelTensor
+        """
+        arg_x = torch.pi * pts["x"]
+        arg_t = self.c * torch.pi * pts["t"]
+        term1 = torch.sin(arg_x) * torch.cos(arg_t)
+        term2 = 0.5 * torch.sin(4 * arg_x) * torch.cos(4 * arg_t)
+        return term1 + term2

pina/problem/zoo/advection.py

@@ -33,6 +33,7 @@ class AdvectionProblem(SpatialProblem, TimeDependentProblem):
         DOI: `arXiv:2308.08468  <https://arxiv.org/abs/2308.08468>`_.
 
     :Example:
+
         >>> problem = AdvectionProblem(c=1.0)
     """
 
@@ -53,7 +54,7 @@ def __init__(self, c=1.0):
         """
         Initialization of the :class:`AdvectionProblem`.
 
-        :param c: The advection velocity parameter.
+        :param c: The advection velocity parameter. Default is 1.0.
         :type c: float | int
         """
         super().__init__()

pina/problem/zoo/allen_cahn.py

@@ -28,6 +28,7 @@ class AllenCahnProblem(TimeDependentProblem, SpatialProblem):
     :math:`[-1, 1]` and temporal interval :math:`[0, 1]`.
 
     .. seealso::
+
         **Original reference**: Sokratis J. Anagnostopoulos, Juan D. Toscano,
         Nikolaos Stergiopulos, and George E. Karniadakis.
         *Residual-based attention and connection to information
@@ -37,7 +38,8 @@ class AllenCahnProblem(TimeDependentProblem, SpatialProblem):
         j.cma.2024.116805 <https://doi.org/10.1016/j.cma.2024.116805>`_.
 
     :Example:
-        >>> problem = AllenCahnProblem()
+
+        >>> problem = AllenCahnProblem(alpha=1e-4, beta=5.0)
     """
 
     output_variables = ["u"]
@@ -57,9 +59,9 @@ def __init__(self, alpha=1e-4, beta=5):
         """
         Initialization of the :class:`AllenCahnProblem`.
 
-        :param alpha: The diffusion coefficient.
+        :param alpha: The diffusion coefficient. Default is 1e-4.
         :type alpha: float | int
-        :param beta: The reaction coefficient.
+        :param beta: The reaction coefficient. Default is 5.0.
         :type beta: float | int
         """
         super().__init__()

pina/problem/zoo/diffusion_reaction.py

@@ -34,12 +34,14 @@ class DiffusionReactionProblem(TimeDependentProblem, SpatialProblem):
     :math:`[-\pi, \pi]` and temporal interval :math:`[0, 1]`.
 
     .. seealso::
+
         **Original reference**: Si, Chenhao, et al. *Complex Physics-Informed
         Neural Network.* arXiv preprint arXiv:2502.04917 (2025).
         DOI: `arXiv:2502.04917 <https://arxiv.org/abs/2502.04917>`_.
 
     :Example:
-        >>> problem = DiffusionReactionProblem()
+
+        >>> problem = DiffusionReactionProblem(alpha=1e-4)
     """
 
     output_variables = ["u"]
@@ -54,16 +56,16 @@ class DiffusionReactionProblem(TimeDependentProblem, SpatialProblem):
     }
 
     conditions = {
-        "g1": Condition(domain="g1", equation=FixedValue(0.0)),
-        "g2": Condition(domain="g2", equation=FixedValue(0.0)),
+        "g1": Condition(domain="g1", equation=FixedValue(value=0.0)),
+        "g2": Condition(domain="g2", equation=FixedValue(value=0.0)),
         "t0": Condition(domain="t0", equation=Equation(initial_condition)),
     }
 
     def __init__(self, alpha=1e-4):
         """
         Initialization of the :class:`DiffusionReactionProblem`.
 
-        :param alpha: The diffusion coefficient.
+        :param alpha: The diffusion coefficient. Default is 1e-4.
         :type alpha: float | int
         """
         super().__init__()

pina/problem/zoo/helmholtz.py

@@ -14,12 +14,14 @@ class HelmholtzProblem(SpatialProblem):
     :math:`[-1, 1] \times [-1, 1]`.
 
     .. seealso::
+
         **Original reference**: Si, Chenhao, et al. *Complex Physics-Informed
         Neural Network.* arXiv preprint arXiv:2502.04917 (2025).
         DOI: `arXiv:2502.04917 <https://arxiv.org/abs/2502.04917>`_.
 
     :Example:
-        >>> problem = HelmholtzProblem()
+
+        >>> problem = HelmholtzProblem(alpha=3.0)
     """
 
     output_variables = ["u"]
@@ -34,17 +36,17 @@ class HelmholtzProblem(SpatialProblem):
     }
 
     conditions = {
-        "g1": Condition(domain="g1", equation=FixedValue(0.0)),
-        "g2": Condition(domain="g2", equation=FixedValue(0.0)),
-        "g3": Condition(domain="g3", equation=FixedValue(0.0)),
-        "g4": Condition(domain="g4", equation=FixedValue(0.0)),
+        "g1": Condition(domain="g1", equation=FixedValue(value=0.0)),
+        "g2": Condition(domain="g2", equation=FixedValue(value=0.0)),
+        "g3": Condition(domain="g3", equation=FixedValue(value=0.0)),
+        "g4": Condition(domain="g4", equation=FixedValue(value=0.0)),
     }
 
     def __init__(self, alpha=3.0):
         """
         Initialization of the :class:`HelmholtzProblem` class.
 
-        :param alpha: Parameter of the forcing term.
+        :param alpha: Parameter of the forcing term. Default is 3.0.
         :type alpha: float | int
         """
         super().__init__()