layercake-model 1.0.2a0__tar.gz

layercake_model-1.0.2a0/LICENSE.txt

@@ -0,0 +1,11 @@
+Copyright 2025-2026 Jonathan Demaeyer and Oisín Hamilton
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

layercake_model-1.0.2a0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: layercake_model
+Version: 1.0.2a0
+Summary: A framework to design systems of partial differential equations (PDEs), and convert them to ordinary differential equations (ODEs) via Galerkin-type expansions. 
+Author-email: Jonathan Demaeyer <jodemaey@meteo.be>, Oisín Hamilton <ush.hamilton@gmail.com>
+License-Expression: BSD-3-Clause
+Project-URL: homepage, https://github.com/Climdyn/LayerCake
+Project-URL: documentation, https://climdyn.github.io/LayerCake/
+Keywords: pde,symbolic-computation,ode-model
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: numba
+Requires-Dist: scipy
+Requires-Dist: sympy
+Requires-Dist: sparse
+Requires-Dist: pebble
+Dynamic: license-file
+
+# LayerCake
+
+> “Welcome to the layer cake son.”
+>
+> -- *Michael Gambon - Layer Cake (2004)*
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.19789922.svg)](https://doi.org/10.5281/zenodo.19789922)
+[![Documentation Status](https://img.shields.io/badge/docs-passing-green.svg)](https://climdyn.github.io/LayerCake/)
+
+## General Information
+
+LayerCake is a framework to design models based on systems of partial differential equations (PDEs), 
+and convert them to ordinary differential equations (ODEs) via Galerkin-type expansions.
+
+LayerCake allows you to construct systems of PDEs, and to specify coordinate systems and basis functions to build
+the corresponding ODE systems.
+To build these systems, LayerCake relies heavily on the [Sympy](https://www.sympy.org/) symbolic computation framework.
+The output of this procedure is either a [Numbaified](https://numba.pydata.org/) Python callable, 
+or a list of symbolic ODE tendencies that can be integrated in any of the supported languages 
+(Fortran, Julia and Python for the moment). These two kinds of output allow for the study of the computed models with 
+the modern tools available in all these languages.
+
+LayerCake has been designed with geophysics in mind, although it may be useful for other applications.
+
+## About
+
+(c) 2025-2026 Jonathan Demaeyer and Oisín Hamilton
+
+See [LICENSE.txt](https://github.com/Climdyn/LayerCake/blob/main/LICENSE.txt) for license information.
+
+## Installation
+
+### With pip
+
+The easiest way to install and run LayerCake is to use [pip](https://pypi.org/).
+Type in a terminal
+
+    pip install layercake-model
+
+and you are set!
+
+Additionally, you can clone the repository
+
+    git clone https://github.com/Climdyn/LayerCake.git
+
+and perform a test by running the script
+
+    python examples/atmospheric/barotropic_one_layer.py
+
+to see if everything runs smoothly (this should take less than 5 minutes).
+
+### With Anaconda
+
+The second-easiest way to install and run LayerCake is to use an appropriate environment 
+created through [Anaconda](https://www.anaconda.com/).
+
+First install Anaconda and clone the repository:
+
+    git clone https://github.com/jodemaey/LayerCake.git
+
+Then install and activate the Python3 Anaconda environment:
+
+    conda env create -f environment.yml
+    conda activate layercake
+
+You can then perform a test by running the script
+
+    python examples/atmospheric/barotropic_one_layer.py
+    
+to see if everything runs smoothly (this should take less than 5 minutes to run).
+
+## Documentation
+
+To build the documentation, please run (with the conda environment activated):
+
+    cd documentation
+    make html
+
+
+You may need to install [make](https://www.gnu.org/software/make/) if it is not already present on your system.
+Once built, the documentation is available [here](./documentation/build/html/index.html).
+
+The documentation is also available online at https://climdyn.github.io/LayerCake/. In particular, 
+please consider reading the [User guide](https://climdyn.github.io/LayerCake/files/user_guide.html#).
+
+## Examples
+
+A few examples are available in the [examples](./examples) folder. More examples will be provided as the code is 
+further developed.
+
+## Dependencies
+
+LayerCake needs mainly:
+
+* [Numpy](https://numpy.org/) for numeric support
+* [sparse](https://sparse.pydata.org/) for sparse multidimensional arrays support
+* [Numba](https://numba.pydata.org/) for code acceleration
+* [Sympy](https://www.sympy.org/) for symbolic manipulation of inner products
+
+Check the YAML file [environment.yml](https://raw.githubusercontent.com/Climdyn/LayerCake/main/environment.yml) for the dependencies.
+
+## Contributing
+
+LayerCake is in beta development phase, bug reports and tests of the features are welcome.
+Please simply raise an issue on [Github](https://github.com/Climdyn/LayerCake/issues).
+
+If you want to contribute actively to the development, please contact the main authors.
+In addition, if you have made changes that you think will be useful to others, please feel free to suggest these as a pull request 
+on the [LayerCake Github repository](https://github.com/Climdyn/LayerCake/pulls).

layercake_model-1.0.2a0/README.md

@@ -0,0 +1,109 @@
+# LayerCake
+
+> “Welcome to the layer cake son.”
+>
+> -- *Michael Gambon - Layer Cake (2004)*
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.19789922.svg)](https://doi.org/10.5281/zenodo.19789922)
+[![Documentation Status](https://img.shields.io/badge/docs-passing-green.svg)](https://climdyn.github.io/LayerCake/)
+
+## General Information
+
+LayerCake is a framework to design models based on systems of partial differential equations (PDEs), 
+and convert them to ordinary differential equations (ODEs) via Galerkin-type expansions.
+
+LayerCake allows you to construct systems of PDEs, and to specify coordinate systems and basis functions to build
+the corresponding ODE systems.
+To build these systems, LayerCake relies heavily on the [Sympy](https://www.sympy.org/) symbolic computation framework.
+The output of this procedure is either a [Numbaified](https://numba.pydata.org/) Python callable, 
+or a list of symbolic ODE tendencies that can be integrated in any of the supported languages 
+(Fortran, Julia and Python for the moment). These two kinds of output allow for the study of the computed models with 
+the modern tools available in all these languages.
+
+LayerCake has been designed with geophysics in mind, although it may be useful for other applications.
+
+## About
+
+(c) 2025-2026 Jonathan Demaeyer and Oisín Hamilton
+
+See [LICENSE.txt](https://github.com/Climdyn/LayerCake/blob/main/LICENSE.txt) for license information.
+
+## Installation
+
+### With pip
+
+The easiest way to install and run LayerCake is to use [pip](https://pypi.org/).
+Type in a terminal
+
+    pip install layercake-model
+
+and you are set!
+
+Additionally, you can clone the repository
+
+    git clone https://github.com/Climdyn/LayerCake.git
+
+and perform a test by running the script
+
+    python examples/atmospheric/barotropic_one_layer.py
+
+to see if everything runs smoothly (this should take less than 5 minutes).
+
+### With Anaconda
+
+The second-easiest way to install and run LayerCake is to use an appropriate environment 
+created through [Anaconda](https://www.anaconda.com/).
+
+First install Anaconda and clone the repository:
+
+    git clone https://github.com/jodemaey/LayerCake.git
+
+Then install and activate the Python3 Anaconda environment:
+
+    conda env create -f environment.yml
+    conda activate layercake
+
+You can then perform a test by running the script
+
+    python examples/atmospheric/barotropic_one_layer.py
+    
+to see if everything runs smoothly (this should take less than 5 minutes to run).
+
+## Documentation
+
+To build the documentation, please run (with the conda environment activated):
+
+    cd documentation
+    make html
+
+
+You may need to install [make](https://www.gnu.org/software/make/) if it is not already present on your system.
+Once built, the documentation is available [here](./documentation/build/html/index.html).
+
+The documentation is also available online at https://climdyn.github.io/LayerCake/. In particular, 
+please consider reading the [User guide](https://climdyn.github.io/LayerCake/files/user_guide.html#).
+
+## Examples
+
+A few examples are available in the [examples](./examples) folder. More examples will be provided as the code is 
+further developed.
+
+## Dependencies
+
+LayerCake needs mainly:
+
+* [Numpy](https://numpy.org/) for numeric support
+* [sparse](https://sparse.pydata.org/) for sparse multidimensional arrays support
+* [Numba](https://numba.pydata.org/) for code acceleration
+* [Sympy](https://www.sympy.org/) for symbolic manipulation of inner products
+
+Check the YAML file [environment.yml](https://raw.githubusercontent.com/Climdyn/LayerCake/main/environment.yml) for the dependencies.
+
+## Contributing
+
+LayerCake is in beta development phase, bug reports and tests of the features are welcome.
+Please simply raise an issue on [Github](https://github.com/Climdyn/LayerCake/issues).
+
+If you want to contribute actively to the development, please contact the main authors.
+In addition, if you have made changes that you think will be useful to others, please feel free to suggest these as a pull request 
+on the [LayerCake Github repository](https://github.com/Climdyn/LayerCake/pulls).

layercake_model-1.0.2a0/layercake/__init__.py

@@ -0,0 +1,16 @@
+
+from .variables.parameter import Parameter
+from .variables.field import Field, ParameterField, FunctionField
+from .basis.base import SymbolicBasis
+from .arithmetic.symbolic.expressions import Expression
+from .arithmetic.terms import *
+from .arithmetic.equation import Equation
+from .arithmetic.symbolic.operators import Laplacian, D
+from .bakery.layers import Layer
+from .bakery.cake import Cake
+
+__all__ = ['Parameter', 'ParameterField', 'FunctionField', 'Field', 'Expression', 'SymbolicBasis', 'vorticity_advection', 'Jacobian',
+           'OperatorTerm', 'ProductOfTerms', 'AdditionOfTerms', 'LinearTerm', 'ConstantTerm', 'Equation', 'Laplacian', 'D',
+           'Layer', 'Cake']
+
+__version__ = '1.0.2a0'

layercake_model-1.0.2a0/layercake/arithmetic/equation.py

@@ -0,0 +1,410 @@
+
+"""
+
+    Equation definition module
+    ==========================
+
+    Main class to define partial differential equation.
+    This class is the workhorse of LayerCake to define and specify
+    partial differential equation.
+
+"""
+
+from sympy import Symbol, S, Eq
+import matplotlib.pyplot as plt
+from layercake.arithmetic.terms.base import ArithmeticTerms
+from layercake.utils import isin
+
+
+# TODO: deal with the cases where lists of terms are empty - maybe nothing is needed but to check
+
+class Equation(object):
+    """Main class to define and specify partial differential equations.
+
+    Notes
+    -----
+    The left-hand side is always expressed as a partial time derivative of
+    something: :math:`\\partial_t` .
+
+    Parameters
+    ----------
+    field: ~field.Field
+        The spatial field over which the partial differential equation.
+    lhs_terms: ~arithmetic.terms.base.ArithmeticTerms or list(~arithmetic.terms.base.ArithmeticTerms), optional
+        Terms on the left-hand side of the equation. At least one must involve the field defined above.
+    name: str, optional
+        Name for the equation.
+
+    Attributes
+    ----------
+    field: ~field.Field
+        The spatial field over which the partial differential equation.
+    rhs_terms: list(~arithmetic.terms.base.ArithmeticTerms)
+        List of additive terms in the right-hand side of the equation.
+    lhs_terms: ListOfArithmeticTerms(~arithmetic.terms.base.ArithmeticTerms)
+        Term on the left-hand side of the equation.
+    name: str
+        Optional name for the equation.
+    """
+
+    _t = Symbol('t')
+
+    def __init__(self, field, lhs_terms=None, name=''):
+
+        self.field = field
+        self.field._equation = self
+        self.rhs_terms = ListOfAdditiveArithmeticTerms()
+        if lhs_terms is None:
+            self.lhs_terms = ListOfAdditiveArithmeticTerms()
+        elif isinstance(lhs_terms, list):
+            self.lhs_terms = ListOfAdditiveArithmeticTerms(lhs_terms)
+        else:
+            self.lhs_terms = ListOfAdditiveArithmeticTerms([lhs_terms])
+        self.name = name
+        self._layer = None
+        self._cake = None
+
+    def add_rhs_term(self, term):
+        """Add a term to the right-hand side of the equation.
+
+        Parameters
+        ----------
+        term: ~arithmetic.terms.base.ArithmeticTerms
+            Term to be added to the right-hand side of the equation.
+        """
+        if not issubclass(term.__class__, ArithmeticTerms):
+            raise ValueError('Provided term must be a valid ArithmeticTerm object.')
+        self.terms.append(term)
+
+    def add_rhs_terms(self, terms):
+        """Add multiple terms to the right-hand side of the equation.
+
+        Parameters
+        ----------
+        terms: list(~arithmetic.terms.base.ArithmeticTerms)
+            Terms to be added to the right-hand side of the equation.
+        """
+        for t in terms:
+            self.add_rhs_term(t)
+
+    def add_lhs_term(self, term):
+        """Add a term to the left-hand side of the equation.
+
+        Parameters
+        ----------
+        term: ~arithmetic.terms.base.ArithmeticTerms
+            Term to be added to the left-hand side of the equation.
+        """
+        if not issubclass(term.__class__, ArithmeticTerms):
+            raise ValueError('Provided term must be a valid ArithmeticTerm object.')
+        self.lhs_terms.append(term)
+
+    def add_lhs_terms(self, terms):
+        """Add multiple terms to the left-hand side of the equation.
+
+        Parameters
+        ----------
+        terms: list(~arithmetic.terms.base.ArithmeticTerms)
+            Terms to be added to the left-hand side of the equation.
+        """
+        for t in terms:
+            self.add_lhs_term(t)
+
+    @property
+    def terms(self):
+        """Alias for the list of RHS arithmetic terms."""
+        return self.rhs_terms
+
+    @property
+    def other_fields(self):
+        """list(~field.Field): List of additional fields present in the equation."""
+        other_fields = list()
+        for equation_term in self.terms:
+            for term in equation_term.terms:
+                if term.field is not self.field and term.field.dynamical and term.field not in other_fields:
+                    other_fields.append(term.field)
+        other_fields = other_fields + self.other_fields_in_lhs
+        return other_fields
+
+    @property
+    def other_fields_in_lhs(self):
+        """list(~field.Field): List of additional fields present in the LHS of the equation."""
+        other_fields = list()
+        for equation_term in self.lhs_terms:
+            for term in equation_term.terms:
+                if term.field is not self.field and term.field.dynamical and term.field not in other_fields:
+                    other_fields.append(term.field)
+        return other_fields
+
+    @property
+    def parameter_fields(self):
+        """list(~field.ParameterField): List of non-dynamical parameter fields present in the equation."""
+        parameter_fields = list()
+        for equation_term in self.terms:
+            for term in equation_term.terms:
+                if term.field is not self.field and not term.field.dynamical and term.field not in parameter_fields:
+                    parameter_fields.append(term.field)
+        for equation_term in self.lhs_terms:
+            for term in equation_term.terms:
+                if term.field is not self.field and not term.field.dynamical and term.field not in parameter_fields:
+                    parameter_fields.append(term.field)
+        return parameter_fields
+
+    @property
+    def parameters(self):
+        """list(~parameter.Parameter): List of parameters present in the equation."""
+        parameters_list = list()
+        for term in self.terms + self.lhs_terms:
+            params_list = term.parameters
+            for param in params_list:
+                if not isin(param, parameters_list):
+                    parameters_list.append(param)
+
+        for param_field in self.parameter_fields:
+            for param in param_field.parameters:
+                if param is not None and not isin(param, parameters_list):
+                    parameters_list.append(param)
+
+        return parameters_list
+
+    @property
+    def parameters_symbols(self):
+        """list(~sympy.core.symbol.Symbol): List of parameter's symbols present in the equation."""
+        return [p.symbol for p in self.parameters]
+
+    @property
+    def symbolic_expression(self):
+        """~sympy.core.expr.Expr: Symbolic expression of the equation."""
+        return Eq(self.symbolic_lhs.diff(self._t, evaluate=False), self.rhs_terms.symbolic_expression)
+
+    @property
+    def numerical_expression(self):
+        """~sympy.core.expr.Expr: Expression of the equation with parameters replaced by their
+        configured values."""
+        return Eq(self.numerical_lhs.diff(self._t, evaluate=False), self.rhs_terms.symbolic_expression)
+
+    @property
+    def symbolic_rhs(self):
+        """~sympy.core.expr.Expr: Symbolic expression of the right-hand side of the equation."""
+        return self.rhs_terms.symbolic_expression
+
+    @property
+    def numerical_rhs(self):
+        """~sympy.core.expr.Expr: Expression of the right-hand side of the equation with
+        parameters replaced by their configured values."""
+        return self.rhs_terms.numerical_expression
+
+    @property
+    def symbolic_lhs(self):
+        """~sympy.core.expr.Expr: Symbolic expression of the left-hand side of the equation."""
+        return self.lhs_terms.symbolic_expression
+
+    @property
+    def numerical_lhs(self):
+        """~sympy.core.expr.Expr: Expression of the left-hand side of the equation with
+        parameters replaced by their configured values."""
+        return self.lhs_terms.numerical_expression
+
+    @property
+    def lhs_inner_products(self):
+        """list(~sympy.matrices.immutable.ImmutableSparseMatrix or ~sympy.tensor.array.ImmutableSparseNDimArray) or list(sparse.COO(float)): Inner products of each term of
+        the left-hand side of the equation, if available."""
+        return [term.inner_products for term in self.lhs_terms]
+
+    @property
+    def lhs_inner_products_addition(self):
+        """~sympy.matrices.immutable.ImmutableSparseMatrix or ~sympy.tensor.array.ImmutableSparseNDimArray or sparse.COO(float): Added left-hand
+        side inner products of the equation, if available. Might raise an error if not all terms are compatible."""
+        result = self.lhs_terms[0].inner_products.copy()
+        for term in self.lhs_terms[1:]:
+            result = result + term.inner_products
+        return result
+
+    @property
+    def maximum_rank(self):
+        """int: Maximum rank of the right-hand side terms tensors."""
+        return max(self.terms.maximum_rank, self.lhs_terms.maximum_rank)
+
+    def compute_inner_products(self, basis, numerical=False, timeout=None, num_threads=None, permute=False):
+        """Compute the inner products tensor of the left-hand and right-hand side terms.
+
+        Parameters
+        ----------
+        basis: SymbolicBasis
+            Basis with which to compute the inner products.
+        numerical: bool, optional
+            Whether the resulting computed inner products must be numerical or symbolic.
+            Default to `False`, i.e. symbolic output.
+        num_threads: int or None, optional
+            Number of threads to use to compute the inner products. If `None` use all the cpus available.
+            Default to `None`.
+        timeout: int or float or bool or None, optional
+            Control the switch from symbolic to numerical integration. By default, `parallel_integration` workers will try to integrate
+            |Sympy| expressions symbolically, but a fallback to numerical integration can be enforced.
+            The options are:
+
+            * `None`: This is the "full-symbolic" mode. No timeout will be applied, and the switch to numerical integration will never happen.
+              Can result in very long and improbable computation time.
+            * `True`: This is the "full-numerical" mode. Symbolic computations do not occur, and the workers try directly to integrate
+              numerically.
+            * `False`: Same as `None`.
+            * An integer: defines a timeout after which, if a symbolic integration have not completed, the worker switch to the
+              numerical integration.
+        permute: bool, optional
+            If `True`, applies all the possible permutations to the tensor indices
+            from 1 to the rank of the tensor.
+            Default to `False`, i.e. no permutation is applied.
+        """
+        self.lhs_terms.compute_inner_products(basis, numerical, timeout, num_threads, permute)
+        self.rhs_terms.compute_inner_products(basis, numerical, timeout, num_threads, permute)
+
+    def to_latex(self, enclose_lhs=True, drop_first_lhs_char=True, drop_first_rhs_char=False):
+        """Generate a LaTeX string representing the equation mathematically.
+
+        Parameters
+        ----------
+        enclose_lhs: bool, optional
+            Whether to enclose the left-hand side term inside parenthesis.
+            Default to `True`.
+        drop_first_lhs_char: bool, optional
+            Whether to drop the first two character of the left-hand side latex string.
+            Useful to drop the sign in front of it.
+            Default to `True`.
+        drop_first_rhs_char: bool, optional
+            Whether to drop the first two character of the right-hand side latex string.
+            Useful to drop the sign in front of it.
+            Default to `False`.
+
+        Returns
+        -------
+        str
+            The LaTeX string representing the equation.
+        """
+        lhs = self.lhs_terms[0].latex
+        for term in self.lhs_terms[1:]:
+            lhs += term.latex
+        if drop_first_lhs_char:
+            lhs = lhs[2:]
+        if enclose_lhs:
+            latex_string = r'\frac{\partial}{\partial t} ' + r'\left(' + lhs + r'\right)'
+        else:
+            latex_string = r'\frac{\partial}{\partial t} ' + lhs
+
+        first_term = self.terms[0].latex
+        if drop_first_rhs_char:
+            first_term = first_term[2:]
+        latex_string += ' = ' + first_term
+
+        for term in self.terms[1:]:
+            latex_string += term.latex
+
+        return latex_string
+
+    def show_latex(self, enclose_lhs=True, drop_first_lhs_char=True, drop_first_rhs_char=False):
+        """Show the LaTeX string representing the equation mathematically rendered in a window.
+
+        Parameters
+        ----------
+        enclose_lhs: bool, optional
+            Whether to enclose the left-hand side term inside parenthesis.
+            Default to `True`.
+        drop_first_lhs_char: bool, optional
+            Whether to drop the first two character of the left-hand side latex string.
+            Useful to drop the sign in front of it.
+            Default to `True`.
+        drop_first_rhs_char: bool, optional
+            Whether to drop the first two character of the right-hand side latex string.
+            Useful to drop the sign in front of it.
+            Default to `False`.
+        """
+
+        latex_string = self.to_latex(enclose_lhs=enclose_lhs,
+                                     drop_first_lhs_char=drop_first_lhs_char,
+                                     drop_first_rhs_char=drop_first_rhs_char
+                                     )
+
+        plt.figure(figsize=(8, 2))
+        plt.axis('off')
+        plt.text(-0.1, 0.5, '$%s$' % latex_string)
+        plt.show()
+
+    def __repr__(self):
+        eq = self.symbolic_expression
+        return f'{eq.lhs} = {eq.rhs}'
+
+    def __str__(self):
+        return self.__repr__()
+
+
+class ListOfAdditiveArithmeticTerms(list):
+    """Class holding list of additive arithmetic terms in equations."""
+
+    def compute_inner_products(self, basis, numerical=False, timeout=None, num_threads=None, permute=False):
+        """Compute the inner products tensor of the all the terms of the list.
+
+        Parameters
+        ----------
+        basis: SymbolicBasis
+            Basis with which to compute the inner products.
+        numerical: bool, optional
+            Whether the resulting computed inner products must be numerical or symbolic.
+            Default to `False`, i.e. symbolic output.
+        num_threads: int or None, optional
+            Number of threads to use to compute the inner products. If `None` use all the cpus available.
+            Default to `None`.
+        timeout: int or float or bool or None, optional
+            Control the switch from symbolic to numerical integration. By default, `parallel_integration` workers will try to integrate
+            |Sympy| expressions symbolically, but a fallback to numerical integration can be enforced.
+            The options are:
+
+            * `None`: This is the "full-symbolic" mode. No timeout will be applied, and the switch to numerical integration will never happen.
+              Can result in very long and improbable computation time.
+            * `True`: This is the "full-numerical" mode. Symbolic computations do not occur, and the workers try directly to integrate
+              numerically.
+            * `False`: Same as `None`.
+            * An integer: defines a timeout after which, if a symbolic integration have not completed, the worker switch to the
+              numerical integration.
+        permute: bool, optional
+            If `True`, applies all the possible permutations to the tensor indices
+            from 1 to the rank of the tensor.
+            Default to `False`, i.e. no permutation is applied.
+        """
+
+        for term in self:
+            term.compute_inner_products(basis, numerical, timeout, num_threads, permute)
+
+    @property
+    def maximum_rank(self):
+        """int: Maximum rank of the right-hand side terms tensors."""
+        max_rank = 0
+        for term in self:
+            max_rank = max(max_rank, term.rank)
+        return max_rank
+
+    @property
+    def same_rank(self):
+        """bool: Check if all terms have the same rank."""
+        rank = self[0].rank
+        for term in self[1:]:
+            if term.rank != rank:
+                return False
+        return True
+
+    @property
+    def symbolic_expression(self):
+        """~sympy.core.expr.Expr: Symbolic expression of the collection of additive arithmetic terms."""
+
+        rterm = S.Zero
+        for term in self:
+            rterm += term.symbolic_expression
+        return rterm
+
+    @property
+    def numerical_expression(self):
+        """~sympy.core.expr.Expr: Expression of the collection of additive arithmetic terms with
+        parameters replaced by their configured values."""
+
+        rterm = S.Zero
+        for term in self:
+            rterm += term.numerical_expression
+        return rterm