zoomy-core 0.1.11__tar.gz → 0.1.14__tar.gz

zoomy_core-0.1.14/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: zoomy_core
+Version: 0.1.14
+Summary: A simulation software for dimensionally-reduced free surface flows.
+Author-email: Ingo Steldermann <steldermann@mbd.rwth-aachen.de>
+License: GNU
+Project-URL: Homepage, https://github.com/mbd-rwth/Zoomy
+Project-URL: Documentation, https://mbd-rwth.github.io/Zoomy
+Project-URL: Source, https://github.com/mbd-rwth/Zoomy
+Project-URL: Issues, https://github.com/mbd-rwth/Zoomy/issues
+Keywords: simulation,shallow flow,free surface flow,shallow moments,shallow water,VAM
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: Jupyter
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: attrs
+Requires-Dist: sympy>=1.14
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: loguru
+Requires-Dist: h5py
+Requires-Dist: matplotlib
+Requires-Dist: meshio
+Requires-Dist: pytest
+Provides-Extra: gui
+Requires-Dist: pyvista; extra == "gui"
+Requires-Dist: trame; extra == "gui"
+Requires-Dist: trame-vtk; extra == "gui"
+Requires-Dist: trame-vuetify; extra == "gui"
+Requires-Dist: panel; extra == "gui"
+Provides-Extra: coupling
+Requires-Dist: precice; extra == "coupling"
+Provides-Extra: testing
+Requires-Dist: swashes; extra == "testing"
+Requires-Dist: pyswashes; extra == "testing"
+Provides-Extra: mesh
+Requires-Dist: gmsh; extra == "mesh"
+Requires-Dist: python-gmsh; extra == "mesh"
+Requires-Dist: rasterio; extra == "mesh"
+Provides-Extra: dev
+Requires-Dist: watchfiles; extra == "dev"
+Requires-Dist: Cython; extra == "dev"
+Requires-Dist: pytest-html; extra == "dev"
+Dynamic: license-file
+
+# zoomy-core
+
+This repository is a submodule of the the [Zoomy Lab](https://github.com/ZoomyLab/Zoomy) repository.
+

zoomy_core-0.1.14/README.md

@@ -0,0 +1,4 @@
+# zoomy-core
+
+This repository is a submodule of the the [Zoomy Lab](https://github.com/ZoomyLab/Zoomy) repository.
+

{zoomy_core-0.1.11/library/zoomy_core → zoomy_core-0.1.14}/mesh/mesh.py

@@ -34,6 +34,8 @@ import zoomy_core.mesh.mesh_util as mesh_util
 from zoomy_core.mesh.mesh_util import compute_subvolume, get_extruded_mesh_type
 from zoomy_core.misc.custom_types import CArray, FArray, IArray
 from zoomy_core.model.boundary_conditions import Periodic
+from zoomy_core.misc import misc as misc
+
 
 # petsc4py.init(sys.argv)
 
@@ -1061,7 +1063,8 @@ class Mesh:
             raise RuntimeError(
                 "Mesh.write_to_hdf5() requires h5py, which is not available."
             )
-        main_dir = os.getenv("ZOOMY_DIR")
+        main_dir = misc.get_main_directory()
+
         with h5py.File(os.path.join(main_dir, filepath), "w") as f:
             mesh = f.create_group("mesh")
             mesh.create_dataset("dimension", data=self.dimension)

{zoomy_core-0.1.11/library/zoomy_core → zoomy_core-0.1.14}/misc/io.py

@@ -21,11 +21,13 @@ except ImportError:
 from zoomy_core.mesh.mesh import Mesh
 import zoomy_core.mesh.mesh_util as mesh_util
 from zoomy_core.misc.misc import Zstruct, Settings
+from zoomy_core.misc import misc as misc
 from zoomy_core.misc.logger_config import logger
 
 
 def init_output_directory(path, clean):
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     path = os.path.join(main_dir, path)
     os.makedirs(path, exist_ok=True)
     if clean:
@@ -81,14 +83,16 @@ def load_hdf5_to_dict(group):
 
 
 def save_settings(settings):
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     filepath = os.path.join(main_dir, settings.output.directory)
     with h5py.File(os.path.join(filepath, "settings.h5"), "w") as f:
         write_dict_to_hdf5(f, settings.as_dict(recursive=True))
 
 
 def load_settings(filepath):
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     filepath = os.path.join(main_dir, filepath)
     with h5py.File(os.path.join(filepath, "settings.h5"), "r") as f:
         d = load_hdf5_to_dict(f)
@@ -98,7 +102,8 @@ def load_settings(filepath):
 
 
 def load_settings2(filepath):
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     filepath = os.path.join(main_dir, filepath)
     with h5py.File(os.path.join(filepath, "settings.h5"), "r") as f:
         model = f["model"]
@@ -156,7 +161,8 @@ def load_settings2(filepath):
 
 
 def clean_files(filepath, filename=".vtk"):
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     abs_filepath = os.path.join(main_dir, filepath)
     if os.path.exists(abs_filepath):
         for file in os.listdir(abs_filepath):
@@ -166,7 +172,8 @@ def clean_files(filepath, filename=".vtk"):
 
 def _save_fields_to_hdf5(filepath, i_snapshot, time, Q, Qaux=None, overwrite=True):
     i_snap = int(i_snapshot)
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     filepath = os.path.join(main_dir, filepath)
     with h5py.File(filepath, "a") as f:
         if i_snap == 0 and not "fields" in f.keys():
@@ -191,7 +198,8 @@ def _save_fields_to_hdf5(filepath, i_snapshot, time, Q, Qaux=None, overwrite=Tru
 def get_save_fields_simple(_filepath, write_all, overwrite=True):
     def _save_hdf5(i_snapshot, time, Q, Qaux):
         i_snap = int(i_snapshot)
-        main_dir = os.getenv("ZOOMY_DIR")
+        main_dir = misc.get_main_directory()
+
         filepath = os.path.join(main_dir, _filepath)
 
         with h5py.File(filepath, "a") as f:
@@ -218,7 +226,8 @@ def get_save_fields_simple(_filepath, write_all, overwrite=True):
 
 def _save_hdf5(_filepath, i_snapshot, time, Q, Qaux, overwrite=True):
     i_snap = int(i_snapshot)
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     filepath = os.path.join(main_dir, _filepath)
 
     with h5py.File(filepath, "a") as f:
@@ -277,7 +286,8 @@ def load_mesh_from_hdf5(filepath):
 
 
 def load_fields_from_hdf5(filepath, i_snapshot=-1):
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     filepath = os.path.join(main_dir, filepath)
     with h5py.File(filepath, "r") as f:
         fields = f["fields"]
@@ -293,7 +303,8 @@ def load_fields_from_hdf5(filepath, i_snapshot=-1):
 
 
 def load_timeline_of_fields_from_hdf5(filepath):
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     filepath = os.path.join(main_dir, filepath)
     l_time = []
     l_Q = []
@@ -370,8 +381,7 @@ def generate_vtk(
     filename="out",
     warp=False,
 ):
-    # main_dir = os.getenv("ZOOMY_DIR")
-    main_dir = ""
+    main_dir =  misc.get_main_directory()
     abs_filepath = os.path.join(main_dir, filepath)
     path = os.path.dirname(abs_filepath)
     full_filepath_out = os.path.join(path, filename)
@@ -431,9 +441,8 @@ def generate_vtk(
                 "time": time,
             }
         )
-
     # finalize vtk
-    with open(os.path.join(path, f"{full_filepath_out}.vtk.series"), "w") as f:
+    with open(os.path.join(path, f"{filename}.vtk.series"), "w") as f:
         json.dump(vtk_timestamp_file, f)
 
     file.close()

{zoomy_core-0.1.11/library/zoomy_core → zoomy_core-0.1.14}/misc/misc.py

@@ -16,6 +16,11 @@ from zoomy_core.misc.logger_config import logger
 
 
 
+def get_main_directory():
+    main_dir = os.getenv("ZOOMY_DIR")
+    if main_dir is None:
+        main_dir = ""
+    return main_dir
 
 
 

{zoomy_core-0.1.11/library/zoomy_core → zoomy_core-0.1.14}/model/basemodel.py

@@ -355,6 +355,7 @@ class Model:
         #     self.n_variables, self.n_variables, self.dimension
         # )
         JacF = ZArray(sympy.derive_by_array(self.flux(), self.variables.get_list()))
+        JacF_d = ZArray.zeros(*JacF.shape)
         for d in range(self.dimension):
             JacF_d = JacF[:, :, d]
             JacF_d = ZArray(JacF_d.tomatrix().T)

{zoomy_core-0.1.11/library/zoomy_core → zoomy_core-0.1.14}/model/model.py

@@ -10,6 +10,7 @@ from zoomy_core.model.models.advection import Advection
 import zoomy_core.model.initial_conditions as IC
 import zoomy_core.model.boundary_conditions as BC
 from zoomy_core.mesh.fvm_mesh import Mesh
+from zoomy_core.misc import misc as misc
 
 
 def create_default_mesh_and_model(
@@ -20,7 +21,8 @@ def create_default_mesh_and_model(
     parameters: Union[int, list, dict] = 0,
     settings: dict = {},
 ):
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     assert main_dir != ""
     ic = IC.Constant()
 

{zoomy_core-0.1.11/library/zoomy_core → zoomy_core-0.1.14}/model/models/basismatrices.py

@@ -5,9 +5,11 @@ from sympy import integrate, diff, Matrix
 from sympy.abc import z
 from time import time as get_time
 
+
 from scipy.optimize import least_squares as lsq
 
 from zoomy_core.model.models.basisfunctions import Legendre_shifted
+from zoomy_core.misc import misc as misc
 
 
 class Basismatrices:
@@ -18,7 +20,8 @@ class Basismatrices:
         self.cache_subdir = f"basismatrices/{basis.name}/{basis.level}"
 
     def load_cached_matrices(self):
-        main_dir = os.getenv("ZOOMY_DIR")
+        main_dir = misc.get_main_directory()
+
         path = os.path.join(os.path.join(main_dir, self.cache_dir), self.cache_subdir)
         failed = False
         try:
@@ -37,7 +40,8 @@ class Basismatrices:
         return failed
 
     def save_cached_matrices(self):
-        main_dir = os.getenv("ZOOMY_DIR")
+        main_dir = misc.get_main_directory()
+
         path = os.path.join(os.path.join(main_dir, self.cache_dir), self.cache_subdir)
         os.makedirs(path, exist_ok=True)
         np.save(os.path.join(path, "phib"), self.phib)

zoomy_core-0.1.14/postprocessing/plotting.py

@@ -0,0 +1,244 @@
+import os
+import json
+import meshio
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.collections import PolyCollection
+
+
+# ---------- I/O ----------
+
+
+def read_vtk_or_series(path, index=0, verbose=True):
+    """Read either .vtk or .vtk.series (relative paths handled)."""
+    path = os.path.abspath(path)
+
+    if path.endswith(".vtk"):
+        if verbose:
+            print(f"📁 Reading single VTK file: {path}")
+        return meshio.read(path)
+
+    if path.endswith(".vtk.series"):
+        with open(path, "r") as f:
+            series = json.load(f)
+
+        entries = series.get("files", [])
+        files, times = [], []
+        for e in entries:
+            fname = e.get("name") or e.get("filename") or e.get("file")
+            if fname:
+                files.append(fname)
+                times.append(e.get("time", None))
+
+        if not files:
+            raise ValueError("No valid file entries found in .vtk.series.")
+
+        n_files = len(files)
+        if verbose:
+            print(f"📂 Loaded VTK series: {path}")
+            print(f"   • Available indices: {n_files}")
+            if any(t is not None for t in times):
+                print("   • Time values:", [t for t in times if t is not None])
+            print(f"   • Reading index {index}")
+
+        if not (0 <= index < n_files):
+            raise IndexError(f"Index {index} out of range (0..{n_files - 1})")
+
+        base_dir = os.path.dirname(path)
+        file_path = os.path.join(base_dir, files[index])
+        return meshio.read(file_path)
+
+    raise ValueError("Expected a .vtk or .vtk.series file")
+
+
+# ---------- Field listing ----------
+
+
+def list_available_fields(mesh, print_out=True):
+    """List all available point and cell fields."""
+    fields = {
+        "point_data": list(mesh.point_data.keys()),
+        "cell_data": list(mesh.cell_data_dict.keys()),
+    }
+
+    if print_out:
+        print("\n📊 Available fields:")
+        if fields["point_data"]:
+            print("  • Point data:")
+            for name in fields["point_data"]:
+                arr = mesh.point_data[name]
+                print(f"     - {name} ({arr.shape})")
+        else:
+            print("  • Point data: none")
+
+        if fields["cell_data"]:
+            print("  • Cell data:")
+            for name in fields["cell_data"]:
+                entry = mesh.cell_data_dict[name]
+                types = ", ".join(entry.keys())
+                print(f"     - {name} (types: {types})")
+        else:
+            print("  • Cell data: none")
+        print()
+
+    return fields
+
+
+# ---------- Cell helpers ----------
+
+
+def get_cell_block(mesh, types):
+    for block in mesh.cells:
+        if block.type in types:
+            return block
+    return None
+
+
+def get_cell_field_for_block(mesh, field_name, cell_block):
+    """Get cell-centered data for the specified block."""
+    if cell_block is None:
+        return None
+    ctype = cell_block.type
+    if field_name is not None:
+        field = mesh.cell_data_dict.get(field_name)
+        if field is None:
+            return None
+        return field.get(ctype)
+    for name, mapping in mesh.cell_data_dict.items():
+        if ctype in mapping:
+            return mapping[ctype]
+    return None
+
+
+# ---------- 1D Plotting ----------
+
+
+def plot_1d_mesh(mesh, ax, field_name=None, **_):
+    """
+    Plot a 1D mesh as a line plot on the given Axes.
+    Returns (vmin, vmax) for consistency.
+    """
+    points = mesh.points
+    x = points[:, 0]
+
+    line_block = get_cell_block(mesh, ("line", "line3"))
+    if line_block is not None:
+        connectivity = line_block.data
+        unique_order = []
+        for conn in connectivity:
+            for i in conn:
+                if i not in unique_order:
+                    unique_order.append(i)
+        x = x[unique_order]
+
+    y = None
+    field_data = get_cell_field_for_block(mesh, field_name, line_block)
+    if field_data is not None:
+        cell_centers = np.array(
+            [np.mean(mesh.points[cell, 0]) for cell in line_block.data]
+        )
+        y = np.interp(x, cell_centers, field_data)
+    elif field_name and field_name in mesh.point_data:
+        y = mesh.point_data[field_name]
+    elif mesh.point_data:
+        field_name, y = next(iter(mesh.point_data.items()))
+
+    if y is None:
+        y = np.zeros_like(x)
+        field_name = field_name or "default"
+
+    ax.plot(x, y, "-o", markersize=3)
+    return float(np.min(y)), float(np.max(y))
+
+
+# ---------- 2D Plotting ----------
+
+
+def plot_2d_mesh(
+    mesh,
+    ax,
+    field_name=None,
+    show_legend=True,
+    legend_location="right",
+    cmap="viridis",
+):
+    """
+    Plot a 2D mesh (unstructured) using meshio connectivity.
+    Adds polygons to the provided Axes.
+    Returns (vmin, vmax).
+    """
+    points = mesh.points[:, :2]
+    cell_block = get_cell_block(mesh, ("triangle", "quad", "polygon"))
+    if cell_block is None:
+        raise ValueError("No 2D cells found.")
+
+    connectivity = cell_block.data
+    field_data = get_cell_field_for_block(mesh, field_name, cell_block)
+    if field_data is None:
+        field_data = np.zeros(len(connectivity))
+        field_name = field_name or "default"
+
+    polygons = [points[cell] for cell in connectivity]
+    vmin, vmax = float(field_data.min()), float(field_data.max())
+    if vmin == vmax:
+        vmin, vmax = vmin - 0.5, vmax + 0.5
+
+    coll = PolyCollection(
+        polygons,
+        array=field_data,
+        cmap=cmap,
+        norm=plt.Normalize(vmin=vmin, vmax=vmax),
+        edgecolors="k",
+        linewidths=0.2,
+    )
+    ax.add_collection(coll)
+    ax.autoscale()
+    ax.set_aspect("equal")
+
+    if show_legend:
+        if legend_location == "bottom":
+            cbar = plt.colorbar(
+                coll, ax=ax, orientation="horizontal", fraction=0.05, pad=0.05
+            )
+        else:  # right
+            cbar = plt.colorbar(coll, ax=ax)
+        cbar.set_label(field_name)
+
+    return vmin, vmax
+
+
+# ---------- Auto Dispatch ----------
+
+
+def plot_mesh(
+    mesh,
+    ax,
+    field_name=None,
+    show_legend=True,
+    legend_location="right",
+):
+    """
+    Auto-detect mesh type (1D or 2D) and plot on the provided Axes.
+    Returns (vmin, vmax).
+    """
+    has_2d = get_cell_block(mesh, ("triangle", "quad", "polygon")) is not None
+    has_1d = get_cell_block(mesh, ("line", "line3")) is not None
+
+    if has_2d:
+        return plot_2d_mesh(mesh, ax, field_name, show_legend, legend_location)
+    elif has_1d:
+        return plot_1d_mesh(mesh, ax, field_name)
+    else:
+        raise ValueError(f"Unsupported mesh types: {[c.type for c in mesh.cells]}")
+
+
+# # ---------- Example ----------
+
+# if __name__ == "__main__":
+#     mesh = read_vtk_or_series("outputs/swe/out.vtk.series", index=0)
+#     list_available_fields(mesh)
+
+#     fig, ax = plt.subplots(figsize=(5, 4))
+#     vmin, vmax = plot_mesh(mesh, ax, field_name=None, show_legend=True, legend_location="right")
+#     print(f"Color range: {vmin:.3g} – {vmax:.3g}")
+#     plt.show()

{zoomy_core-0.1.11/library/zoomy_core → zoomy_core-0.1.14}/postprocessing/postprocessing.py

@@ -12,6 +12,8 @@ import zoomy_core.mesh.mesh as petscMesh
 import zoomy_core.misc.io as io
 from zoomy_core.misc.logger_config import logger
 from zoomy_core.transformation.to_numpy import NumpyRuntimeModel
+from zoomy_core.misc import misc as misc
+
 
 def vtk_project_2d_to_3d(
     model, settings, start_at_time=0, scale_h=1.0, filename='out_3d'
@@ -19,7 +21,8 @@ def vtk_project_2d_to_3d(
     if not _HAVE_H5PY:
         raise ImportError("h5py is required for vtk_project_2d_to_3d function.")
     Nz = model.number_of_points_3d
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     path_to_simulation = os.path.join(main_dir, os.path.join(settings.output.directory, f"{settings.output.filename}.h5"))    
     sim = h5py.File(path_to_simulation, "r")
     settings = io.load_settings(settings.output.directory)

{zoomy_core-0.1.11/library/zoomy_core → zoomy_core-0.1.14}/preprocessing/openfoam_moments.py

@@ -21,7 +21,8 @@ from zoomy_core.misc.io import _save_fields_to_hdf5 as save_fields_to_hdf5
 import zoomy_core.misc.io as io
 
 
-main_dir = os.getenv("ZOOMY_DIR")
+main_dir = misc.get_main_directory()
+
 
 
 def load_file(filename):

{zoomy_core-0.1.11 → zoomy_core-0.1.14}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "zoomy_core"
-version = "0.1.11"
+version = "0.1.14"
 description = "A simulation software for dimensionally-reduced free surface flows."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -71,7 +71,6 @@ Issues = "https://github.com/mbd-rwth/Zoomy/issues"
 
 
 [tool.setuptools.packages.find]
-where = ["library"]
-include = ["zoomy_core*"]
+include = ["*"]
 
 

{zoomy_core-0.1.11/library/zoomy_core → zoomy_core-0.1.14}/transformation/to_amrex.py

@@ -4,6 +4,8 @@ import sympy as sp
 from copy import deepcopy
 
 from zoomy_core.misc.misc import Zstruct
+from zoomy_core.misc import misc as misc
+
 from zoomy_core.model.sympy2c import create_module
 from zoomy_core.transformation.helpers import regularize_denominator, substitute_sympy_attributes_with_symbol_matrix
 
@@ -230,7 +232,8 @@ class AmrexPrinter(CXX11CodePrinter):
 def write_code(model, settings):
     printer = AmrexPrinter(model)
     expr = printer.create_model(model)
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     path = os.path.join(main_dir, settings.output.directory, ".amrex_interface")
     os.makedirs(path, exist_ok=True)
     path = os.path.join(path, "Model.h")

{zoomy_core-0.1.11/library/zoomy_core → zoomy_core-0.1.14}/transformation/to_c.py

@@ -4,6 +4,9 @@ import textwrap
 import sympy as sp
 from sympy.printing.cxx import CXX11CodePrinter
 
+from zoomy_core.misc import misc as misc
+
+
 class CPrinter(CXX11CodePrinter):
     """
     Convert SymPy expressions to C code.
@@ -173,7 +176,8 @@ inline double* {name}(
 def write_code(model, settings):
     printer = CPrinter(model)
     code = printer.create_model(model)
-    main_dir = os.getenv("ZOOMY_DIR")
+    main_dir = misc.get_main_directory()
+
     path = os.path.join(main_dir, settings.output.directory, ".c_interface")
     os.makedirs(path, exist_ok=True)
     file_path = os.path.join(path, "Model.H")

{zoomy_core-0.1.11/library/zoomy_core → zoomy_core-0.1.14}/transformation/to_numpy.py

@@ -50,39 +50,42 @@ class NumpyRuntimeModel:
     def __attrs_post_init__(self):
         model = self.model
 
+        modules = [self.module]
+        if self.printer:
+            modules.append(self.printer)
         
-        flux=model._flux.lambdify(modules=[self.module, self.printer])
-        dflux=model._dflux.lambdify(modules=[self.module, self.printer])
+        flux=model._flux.lambdify(modules=modules)
+        dflux=model._dflux.lambdify(modules=modules)
         nonconservative_matrix=model._nonconservative_matrix.lambdify(
-            modules=[self.module, self.printer]
+            modules=modules
         )
         quasilinear_matrix=model._quasilinear_matrix.lambdify(
-            modules=[self.module, self.printer]
+            modules=modules
         )
         eigenvalues=model._eigenvalues.lambdify(
-            modules=[self.module, self.printer]
+            modules=modules
         )
         left_eigenvectors=model._left_eigenvectors.lambdify(
-            modules=[self.module, self.printer]
+            modules=modules
         )
         right_eigenvectors=model._right_eigenvectors.lambdify(
-            modules=[self.module, self.printer]
+            modules=modules
         )
-        source=model._source.lambdify(modules=[self.module, self.printer])
+        source=model._source.lambdify(modules=modules)
         source_jacobian_wrt_variables=model._source_jacobian_wrt_variables.lambdify(
-            modules=[self.module, self.printer]
+            modules=modules
         )
         source_jacobian_wrt_aux_variables=model._source_jacobian_wrt_aux_variables.lambdify(
-            modules=[self.module, self.printer]
+            modules=modules
         )
-        residual=model._residual.lambdify(modules=[self.module, self.printer])
+        residual=model._residual.lambdify(modules=modules)
         project_2d_to_3d=model._project_2d_to_3d.lambdify(
-            modules=[self.module, self.printer]
+            modules=modules
         )
         project_3d_to_2d=model._project_3d_to_2d.lambdify(
-            modules=[self.module, self.printer]
+            modules=modules
         )
-        bcs = model._boundary_conditions.lambdify(modules=[self.module, self.printer])
+        bcs = model._boundary_conditions.lambdify(modules=modules)
 
 
         # --- Assign frozen fields -------------------------------------