pymrm 2.2.0__tar.gz → 2.2.2__tar.gz

{pymrm-2.2.0 → pymrm-2.2.2}/.github/workflows/analysis.yml

@@ -21,6 +21,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+    - name: Configure git safe.directory for container
+      run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
 
     - name: test flake 8
       run: scripts/run_linter.sh
@@ -42,6 +44,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+    - name: Configure git safe.directory for container
+      run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
     - name: Install myst-parser
       run: pip install myst-parser
     - name: Ensure _static directory exists
@@ -64,36 +68,3 @@ jobs:
       with:
         name: Documentation
         path: docs/sphinx/_build/html*
-
-  publish-analysis:
-    # For details checkout https://github.com/marketplace/actions/publish-test-results
-    runs-on: ubuntu-latest
-    container:
-      image: davevader/pymrm_linux:1.0
-# workaround, potentially leave the user as root in dockerfile
-# see here: https://github.com/actions/checkout/issues/956
-      options: --user root
-
-    name: Publish Tests Results
-    needs: [linter]
-    permissions:
-      checks: write
-      # only needed unless run with comment_mode: off
-      pull-requests: write
-      # only needed for private repository
-      contents: read
-      # only needed for private repository
-      issues: read
-    if: always()
-
-    steps:
-      - name: Download Artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: artifacts
-
-      - name: Publish Analysis
-        uses: EnricoMi/publish-unit-test-result-action@v2
-        with:
-          files: |
-            artifacts/linter/*.xml

pymrm-2.2.2/.github/workflows/build.yml

@@ -0,0 +1,38 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - main
+      - dev
+  pull_request:
+    branches:
+      - main
+      - dev
+
+jobs:
+  install:
+    runs-on: ubuntu-latest
+    container:
+      image: python:3.10
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Configure git safe.directory for container
+      run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+    - name: Test Install
+      run: python -m pip install .
+
+  documentation:
+    runs-on: ubuntu-latest
+    container:
+      image: python:3.10
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Configure git safe.directory for container
+      run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+    - name: Build documentation (with apidoc regeneration)
+      run: scripts/build_documentation.sh

{pymrm-2.2.0 → pymrm-2.2.2}/.github/workflows/test.yml

@@ -24,6 +24,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+    - name: Configure git safe.directory for container
+      run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
 
     - name: Install dependencies
       run: pip install pytest

{pymrm-2.2.0 → pymrm-2.2.2}/.github/workflows/verification.yml

@@ -21,6 +21,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+    - name: Configure git safe.directory for container
+      run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
 
     - name: run tutorials
       run: |
@@ -37,6 +39,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+    - name: Configure git safe.directory for container
+      run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
     - name: Run examples
       run: |
         python -m pip install .

{pymrm-2.2.0 → pymrm-2.2.2}/CITATION.cff

@@ -1,6 +1,6 @@
 cff-version: 1.2.0
 title: "pymrm: Python package for Multiphase Reactor Modeling"
-version: "2.2.0"
+version: "2.2.1"
 message: "If you use pymrm in your work, please cite the version you used."
 authors:
   - family-names: Peters
@@ -9,7 +9,7 @@ authors:
   - family-names: van Sint Annaland
     given-names: M.
     orcid: "https://orcid.org/0000-0002-2903-7443"
-date-released: "2026-01-09"
+date-released: "2026-04-17"
 identifiers:
   - type: doi
     value: 10.5281/zenodo.17065798

{pymrm-2.2.0 → pymrm-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymrm
-Version: 2.2.0
+Version: 2.2.2
 Summary: Functions for multiphase reactor modeling
 Author-email: "E.A.J.F. Peters" <e.a.j.f.peters@tue.nl>, "M. van Sint Annaland" <M.v.SintAnnaland@tue.nl>, "M. Galanti" <m.galanti@tue.nl>, "D.R. Rieder" <d.r.rieder@tue.nl>
 Maintainer-email: "E.A.J.F. Peters" <e.a.j.f.peters@tue.nl>

{pymrm-2.2.0 → pymrm-2.2.2}/docs/installation.md

@@ -82,7 +82,7 @@ PyMRM is available on PyPI and includes all necessary dependencies.
 ## Verifying the Installation
 
 1. **Test the Installation**:
-   - Navigate to the `examples` folder in the PyMRM repository or download example notebooks from the [PyMRM documentation](https://multiscale-modelling-multiphase-flows.github.io/pymrm-book).
+   - Navigate to the `examples` folder in the PyMRM repository or download example notebooks from the [PyMRM documentation](https://computational-chemical-engineering.github.io/pymrm-book).
    - Open a notebook in VS Code or Jupyter Notebook and execute the cells to verify that PyMRM and its dependencies are working correctly.
 
 2. **Optional: Test in Spyder**:
@@ -94,4 +94,4 @@ PyMRM is available on PyPI and includes all necessary dependencies.
 
 ## Conclusion
 
-You have successfully set up your environment for using PyMRM. Whether you use VS Code or Spyder, you are now ready to start modeling multiphase reactors. For further guidance, refer to the [PyMRM documentation](https://multiscale-modelling-multiphase-flows.github.io/pymrm-book).
+You have successfully set up your environment for using PyMRM. Whether you use VS Code or Spyder, you are now ready to start modeling multiphase reactors. For further guidance, refer to the [PyMRM documentation](https://computational-chemical-engineering.github.io/pymrm-book).

{pymrm-2.2.0 → pymrm-2.2.2}/docs/sphinx/modules.rst

@@ -1,4 +1,4 @@
-pyMRM
+pymrm
 =====
 
 .. toctree::

{pymrm-2.2.0 → pymrm-2.2.2}/docs/sphinx/pymrm.rst

@@ -1,66 +1,77 @@
+pymrm package
+=============
+
 Submodules
-==========
+----------
 
 pymrm.convect module
 --------------------
 
 .. automodule:: pymrm.convect
    :members:
+   :show-inheritance:
    :undoc-members:
+
+pymrm.coupling module
+---------------------
+
+.. automodule:: pymrm.coupling
+   :members:
    :show-inheritance:
+   :undoc-members:
 
 pymrm.grid module
 -----------------
 
 .. automodule:: pymrm.grid
    :members:
-   :undoc-members:
    :show-inheritance:
+   :undoc-members:
 
 pymrm.helpers module
 --------------------
 
 .. automodule:: pymrm.helpers
    :members:
-   :undoc-members:
    :show-inheritance:
+   :undoc-members:
 
 pymrm.interpolate module
 ------------------------
 
 .. automodule:: pymrm.interpolate
    :members:
-   :undoc-members:
    :show-inheritance:
+   :undoc-members:
 
 pymrm.numjac module
 -------------------
 
 .. automodule:: pymrm.numjac
    :members:
-   :undoc-members:
    :show-inheritance:
+   :undoc-members:
 
 pymrm.operators module
 ----------------------
 
 .. automodule:: pymrm.operators
    :members:
-   :undoc-members:
    :show-inheritance:
+   :undoc-members:
 
 pymrm.solve module
 ------------------
 
 .. automodule:: pymrm.solve
    :members:
-   :undoc-members:
    :show-inheritance:
+   :undoc-members:
 
 Module contents
 ---------------
 
 .. automodule:: pymrm
    :members:
-   :undoc-members:
    :show-inheritance:
+   :undoc-members:

{pymrm-2.2.0 → pymrm-2.2.2}/scripts/build_documentation.sh

@@ -5,6 +5,16 @@
 
 pip install myst-parser # workaround. Should be included in Docker image?
 pip install -e .
+sphinx-apidoc -f -o docs/sphinx src/pymrm
+if [[ "${CI}" == "true" ]]; then
+    api_rst_files=(docs/sphinx/pymrm.rst docs/sphinx/modules.rst)
+    if ! git diff --quiet HEAD -- "${api_rst_files[@]}"; then
+        echo "Detected outdated autogenerated Sphinx API files:"
+        git --no-pager diff HEAD -- "${api_rst_files[@]}"
+        echo "Run 'sphinx-apidoc -f -o docs/sphinx src/pymrm' and commit the updated rst files."
+        exit 1
+    fi
+fi
 cd docs/sphinx
 mkdir -p _static
 make html 2>documentation_errors.txt

{pymrm-2.2.0 → pymrm-2.2.2}/src/pymrm/__init__.py

@@ -1,50 +1,14 @@
-"""
-pymrm: A Python Package for Multiphase Reactor Modeling
-
-This package provides a comprehensive set of tools for modeling multiphase reactors,
-including grid generation, numerical operators, convection schemes, interpolation methods,
-nonlinear solvers, and utility functions.
-
-Submodules:
-- grid: Functions for generating uniform and non-uniform grids.
-- operator: Construction of gradient and divergence operators for finite volume methods.
-- convection: High-resolution convection schemes and TVD limiters.
-- interpolate: Interpolation techniques between staggered and cell-centered grids.
-- solve: Nonlinear solvers and numerical approaches.
-- helpers: Utility functions supporting core operations.
-- numjac: Numerical Jacobian construction for nonlinear systems.
-
-Example Usage:
-.. code-block:: python
-
-    import numpy as np
-    import matplotlib.pyplot as plt
-    from pymrm import construct_grad, construct_div
-
-    # Define the grid
-    shape = (100,)
-    x_f = np.linspace(0, 1, shape[0]+1)
-    x_c = 0.5*(x_f[1:] + x_f[:-1])
-
-    # Set boundary conditions
-    bc_L = {a: 0, b:1, d:1}
-    bc_R = {a: 0, b:1, d:0}
-    grad_mat, grad_bc = construct_grad(shape, x_f, x_c, bc=(bc_L, bc_R))
-    div_mat = construct_div(shape, x_f)
-    lapl_mat = div_mat @ grad_mat
-    lapl_bc = div_mat @ grad_bc
-
-    c = np.zeros(shape)
-    c[:] = lapl_mat.solve(lapl_bc)
-    plt.plot(x_c, c)
+"""Top-level package for :mod:`pymrm`.
 
-Authors:
-- E.A.J.F. Peters
-- M. van Sint Annaland
-- M. Galanti
-- D.R. Rieder
+The package provides numerical building blocks for multiphase reactor models,
+including:
 
-License: MIT License
+* grid generation utilities;
+* sparse gradient, divergence, and convective-flux operators;
+* interpolation routines between cell-centered and staggered layouts;
+* numerical Jacobian approximation tools;
+* nonlinear solver helpers for implicit schemes; and
+* coupling helpers for multi-domain/interface formulations.
 """
 
 from .grid import generate_grid, non_uniform_grid

pymrm-2.2.2/src/pymrm/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2.2.2'
+__version_tuple__ = version_tuple = (2, 2, 2)
+
+__commit_id__ = commit_id = 'g471977efe'

{pymrm-2.2.0 → pymrm-2.2.2}/src/pymrm/convect.py

@@ -1,28 +1,4 @@
-"""
-convection.py
-
-This submodule of pymrm provides functions to construct convective flux matrices using
-upwind schemes and apply Total Variation Diminishing (TVD) limiters for numerical stability.
-
-Functions:
-- construct_convflux_upwind: Constructs the convective flux matrix using the upwind scheme.
-- construct_convflux_upwind_int: Constructs the internal convective flux matrix.
-- construct_convflux_bc: Constructs the convective flux matrix for boundary conditions.
-- upwind: Upwind TVD limiter.
-- minmod: Minmod TVD limiter.
-- osher: Osher TVD limiter.
-- clam: CLAM TVD limiter.
-- muscl: MUSCL TVD limiter.
-- smart: SMART TVD limiter.
-- stoic: STOIC TVD limiter.
-- vanleer: Van Leer TVD limiter.
-
-Dependencies:
-- numpy
-- scipy.sparse (for csc_array)
-- pymrm.grid (for optional grid generation)
-- pymrm.helpers (for boundary condition handling)
-"""
+"""Convective-flux operators and TVD limiter functions."""
 
 import math
 import numpy as np
@@ -36,23 +12,33 @@ def construct_convflux_upwind(
     shape, x_f, x_c=None, bc=(None, None), v=1.0, axis=0, shapes_d=(None, None),
     format="csc"
 ):
-    """
-    Constructs the convective flux matrix using the upwind scheme.
-
-    Args:
-        shape (tuple or int): Shape of the multi-dimensional array. If an integer is provided, it is treated as 1D.
-        x_f (ndarray): Face positions.
-        x_c (ndarray, optional): Cell positions. If not provided, it will be calculated based on the face array.
-        bc (tuple, optional): Boundary conditions as a tuple of dictionaries
-            for left and right boundaries. Default is (None, None).
-        v (float or ndarray): Velocities on face positions. Can be a scalar or an array.
-        axis (int, optional): The axis along which the convection takes place. Default is 0.
-        shapes_d (tuple, optional): Shapes for boundary condition matrices. Default is (None, None).
-        format (str, optional): Sparse format, ``'csc'`` (default) or ``'csr'``.
-
-    Returns:
-        csc_array or csr_array: Convective flux matrix for internal faces.
-        csc_array or csr_array: Convective flux matrix for boundary conditions.
+    """Construct a first-order upwind convective-flux operator.
+
+    Parameters
+    ----------
+    shape : tuple[int, ...] or int
+        Cell-centered field shape.
+    x_f : array_like
+        Face coordinates along ``axis``.
+    x_c : array_like, optional
+        Cell-center coordinates. If omitted, arithmetic midpoints are used.
+    bc : tuple[dict | None, dict | None], optional
+        Left and right boundary-condition dictionaries with keys ``a``, ``b``,
+        and ``d``.
+    v : float or array_like, optional
+        Face velocity field. Scalars and broadcastable arrays are accepted.
+    axis : int, optional
+        Convection axis.
+    shapes_d : tuple[tuple | None, tuple | None], optional
+        Optional source-vector shapes for boundary inhomogeneities.
+    format : {'csc', 'csr'}, optional
+        Sparse format for returned operator matrices.
+
+    Returns
+    -------
+    tuple
+        Without ``shapes_d``: ``(conv_matrix, conv_bc)``.
+        With ``shapes_d``: ``(conv_matrix, conv_bc_left, conv_bc_right)``.
     """
     if isinstance(shape, int):
         shape = (shape,)
@@ -84,17 +70,23 @@ def construct_convflux_upwind(
 
 
 def construct_convflux_upwind_int(shape, v=1.0, axis=0, format="csc"):
-    """
-    Constructs the convective flux matrix for internal faces using the upwind scheme.
-
-    Args:
-        shape (tuple): Shape of the multi-dimensional array.
-        v (float or ndarray): Velocity array. Can be a scalar or an array.
-        axis (int, optional): The axis along which the numerical differentiation is performed. Default is 0.
-        format (str, optional): Sparse format, ``'csc'`` (default) or ``'csr'``.
-
-    Returns:
-        csc_array or csr_array: Convective flux matrix for internal faces.
+    """Construct the internal-face upwind advection operator.
+
+    Parameters
+    ----------
+    shape : tuple[int, ...]
+        Cell-centered field shape.
+    v : float or array_like, optional
+        Face velocity field.
+    axis : int, optional
+        Convection axis.
+    format : {'csc', 'csr'}, optional
+        Sparse format of the returned matrix.
+
+    Returns
+    -------
+    scipy.sparse.csc_array or scipy.sparse.csr_array
+        Sparse matrix mapping cell-centered values to interior face fluxes.
     """
     shape_f = shape[:axis] + (shape[axis] + 1,) + shape[axis + 1:]
     shape_t = (math.prod(shape[:axis]), shape[axis], math.prod(shape[axis + 1:]))
@@ -141,24 +133,34 @@ def construct_convflux_bc(
     shape, x_f, x_c=None, bc=(None, None), v=1.0, axis=0, shapes_d=(None, None),
     format="csc"
 ):
-    """
-    Constructs the convective flux matrix for boundary faces using the upwind scheme.
-
-    Args:
-        shape (tuple): Shape of the multi-dimensional array.
-        x_f (ndarray): Face positions.
-        x_c (ndarray, optional): Cell-centered positions. If not provided,
-            it is calculated based on the face array.
-        bc (tuple, optional): Boundary conditions as a tuple of dictionaries
-            for left and right boundaries. Default is (None, None).
-        v (float or ndarray): Velocity array. Can be a scalar or an array.
-        axis (int, optional): The axis along which the numerical differentiation is performed. Default is 0.
-        shapes_d (tuple, optional): Shapes for boundary condition matrices. Default is (None, None).
-        format (str, optional): Sparse format, ``'csc'`` (default) or ``'csr'``.
-
-    Returns:
-        csc_array or csr_array: Convective flux matrix for internal faces.
-        csc_array or csr_array: Convective flux matrix for boundary conditions.
+    """Construct boundary-face upwind corrections and source terms.
+
+    Parameters
+    ----------
+    shape : tuple[int, ...]
+        Cell-centered field shape.
+    x_f : array_like
+        Face coordinates along ``axis``.
+    x_c : array_like, optional
+        Cell-center coordinates.
+    bc : tuple[dict | None, dict | None], optional
+        Left and right boundary-condition dictionaries with keys ``a``, ``b``,
+        and ``d``.
+    v : float or array_like, optional
+        Face velocity field.
+    axis : int, optional
+        Convection axis.
+    shapes_d : tuple[tuple | None, tuple | None], optional
+        Optional source-vector shapes for inhomogeneous boundary terms.
+    format : {'csc', 'csr'}, optional
+        Sparse format for returned operator matrices.
+
+    Returns
+    -------
+    tuple
+        ``(conv_matrix_bc, conv_bc)`` when ``shapes_d`` is not supplied, or
+        ``(conv_matrix_left, conv_bc_left, conv_matrix_right, conv_bc_right)``
+        otherwise.
     """
 
     # Trick: Reshape to triplet shape_t
@@ -388,33 +390,13 @@ def construct_convflux_bc(
 
 
 def upwind(normalized_c_c, normalized_x_c, normalized_x_d):
-    """
-    Applies the upwind TVD limiter to reduce oscillations in numerical schemes.
-
-    Args:
-        normalized_c_c (ndarray): Normalized concentration at cell centers.
-        normalized_x_c (ndarray): Normalized position of cell centers.
-        normalized_x_d (ndarray): Normalized position of downwind face.
-
-    Returns:
-        ndarray: Normalized concentration difference (c_norm_d - c_norm_C).
-    """
+    """Return zero correction (first-order upwind limiter)."""
     normalized_concentration_diff = np.zeros_like(normalized_c_c)
     return normalized_concentration_diff
 
 
 def minmod(normalized_c_c, normalized_x_c, normalized_x_d):
-    """
-    Applies the Minmod TVD limiter to reduce oscillations in numerical schemes.
-
-    Args:
-        normalized_c_c (ndarray): Normalized concentration at cell centers.
-        normalized_x_c (ndarray): Normalized position of cell centers.
-        normalized_x_d (ndarray): Normalized position of downwind face.
-
-    Returns:
-        ndarray: Normalized concentration difference (c_norm_d - c_norm_C).
-    """
+    """Compute the Minmod TVD correction in normalized-variable space."""
     normalized_concentration_diff = np.maximum(
         0,
         (normalized_x_d - normalized_x_c)
@@ -426,17 +408,7 @@ def minmod(normalized_c_c, normalized_x_c, normalized_x_d):
 
 
 def osher(normalized_c_c, normalized_x_c, normalized_x_d):
-    """
-    Applies the Osher TVD limiter to reduce oscillations in numerical schemes.
-
-    Args:
-        normalized_c_c (ndarray): Normalized concentration at cell centers.
-        normalized_x_c (ndarray): Normalized position of cell centers.
-        normalized_x_d (ndarray): Normalized position of downwind face.
-
-    Returns:
-        ndarray: Normalized concentration difference (c_norm_d - c_norm_C).
-    """
+    """Compute the Osher TVD correction in normalized-variable space."""
     normalized_concentration_diff = np.maximum(
         0,
         np.where(
@@ -449,17 +421,7 @@ def osher(normalized_c_c, normalized_x_c, normalized_x_d):
 
 
 def clam(normalized_c_c, normalized_x_c, normalized_x_d):
-    """
-    Applies the CLAM TVD limiter to reduce oscillations in numerical schemes.
-
-    Args:
-        normalized_c_c (ndarray): Normalized concentration at cell centers.
-        normalized_x_c (ndarray): Normalized position of cell centers.
-        normalized_x_d (ndarray): Normalized position of downwind face.
-
-    Returns:
-        ndarray: Normalized concentration difference (c_norm_d - c_norm_C).
-    """
+    """Compute the CLAM TVD correction in normalized-variable space."""
     normalized_concentration_diff = np.maximum(
         0,
         np.where(
@@ -472,17 +434,7 @@ def clam(normalized_c_c, normalized_x_c, normalized_x_d):
 
 
 def muscl(normalized_c_c, normalized_x_c, normalized_x_d):
-    """
-    Applies the MUSCL TVD limiter to reduce oscillations in numerical schemes.
-
-    Args:
-        normalized_c_c (ndarray): Normalized concentration at cell centers.
-        normalized_x_c (ndarray): Normalized position of cell centers.
-        normalized_x_d (ndarray): Normalized position of downwind face.
-
-    Returns:
-        ndarray: Normalized concentration difference (c_norm_d - c_norm_C).
-    """
+    """Compute the MUSCL TVD correction in normalized-variable space."""
     normalized_concentration_diff = np.maximum(
         0,
         np.where(
@@ -500,17 +452,7 @@ def muscl(normalized_c_c, normalized_x_c, normalized_x_d):
 
 
 def smart(normalized_c_c, normalized_x_c, normalized_x_d):
-    """
-    Applies the SMART TVD limiter to reduce oscillations in numerical schemes.
-
-    Args:
-        normalized_c_c (ndarray): Normalized concentration at cell centers.
-        normalized_x_c (ndarray): Normalized position of cell centers.
-        normalized_x_d (ndarray): Normalized position of downwind face.
-
-    Returns:
-        ndarray: Normalized concentration difference (c_norm_d - c_norm_C).
-    """
+    """Compute the SMART TVD correction in normalized-variable space."""
     normalized_concentration_diff = np.maximum(
         0,
         np.where(
@@ -544,17 +486,7 @@ def smart(normalized_c_c, normalized_x_c, normalized_x_d):
 
 
 def stoic(normalized_c_c, normalized_x_c, normalized_x_d):
-    """
-    Applies the STOIC TVD limiter to reduce oscillations in numerical schemes.
-
-    Args:
-        normalized_c_c (ndarray): Normalized concentration at cell centers.
-        normalized_x_c (ndarray): Normalized position of cell centers.
-        normalized_x_d (ndarray): Normalized position of downwind face.
-
-    Returns:
-        ndarray: Normalized concentration difference (c_norm_d - c_norm_C).
-    """
+    """Compute the STOIC TVD correction in normalized-variable space."""
     normalized_concentration_diff = np.maximum(
         0,
         np.where(
@@ -603,17 +535,7 @@ def stoic(normalized_c_c, normalized_x_c, normalized_x_d):
 
 
 def vanleer(normalized_c_c, normalized_x_c, normalized_x_d):
-    """
-    Applies the van Leer TVD limiter to reduce oscillations in numerical schemes.
-
-    Args:
-        normalized_c_c (ndarray): Normalized concentration at cell centers.
-        normalized_x_c (ndarray): Normalized position of cell centers.
-        normalized_x_d (ndarray): Normalized position of downwind face.
-
-    Returns:
-        ndarray: Normalized concentration difference (c_norm_d - c_norm_C).
-    """
+    """Compute the van-Leer TVD correction in normalized-variable space."""
     normalized_concentration_diff = np.maximum(
         0,
         normalized_c_c