zoomy-core 0.1.11__py3-none-any.whl

zoomy_core/transformation/to_openfoam.py

@@ -0,0 +1,254 @@
+import os
+import re
+import textwrap
+import sympy as sp
+from sympy.printing.cxx import CXX11CodePrinter
+
+class FoamPrinter(CXX11CodePrinter):
+    """
+    Convert SymPy expressions to OpenFOAM 12 compatible C++ code.
+    - Q, Qaux: Foam::List<Foam::scalar>
+    - Matrices: Foam::List<Foam::List<Foam::scalar>>
+    - Vectors: Foam::vector (.x(), .y(), .z())
+    """
+
+    def __init__(self, model, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.n_dof_q = model.n_variables
+        self.n_dof_qaux = model.n_aux_variables
+
+        # Map variable names to Q[i], Qaux[i]
+        self.map_Q = {k: f"Q[{i}]" for i, k in enumerate(model.variables.values())}
+        self.map_Qaux = {k: f"Qaux[{i}]" for i, k in enumerate(model.aux_variables.values())}
+        self.map_param = {k: str(float(model.parameter_values[i])) for i, k in enumerate(model.parameters.values())}
+        
+        # Map normal/position to n.x(), n.y(), n.z()
+        self.map_normal = {k: ["n.x()", "n.y()", "n.z()"][i] for i, k in enumerate(model.normal.values())}
+        self.map_position = {k: ["X.x()", "X.y()", "X.z()"][i] for i, k in enumerate(model.position.values())}
+
+        self._std_regex = re.compile(r'std::([A-Za-z_]\w*)')
+        
+        self._argument_table = {"Q": "const Foam::List<Foam::scalar>& Q",
+        "Qaux": "const Foam::List<Foam::scalar>& Qaux",
+        "n": "const Foam::vector& n",
+        "X": "const Foam::vector& X",
+        "time": "const Foam::scalar& time",
+        "dX": "const Foam::scalar& dX",
+        "z": "const Foam::scalar& z"
+        }
+        
+    def create_lambertw(self):
+        return textwrap.dedent("""\
+        inline Foam::scalar lambertw(const Foam::scalar x)
+            {
+                // valid for x > -exp(-1)
+                Foam::scalar w = (x < 1.0 ? x : log(1.0 + x));  // good initial guess
+                for (int i = 0; i < 5; ++i)
+                {
+                    Foam::scalar ew = exp(w);
+                    Foam::scalar wew = w * ew;
+                    Foam::scalar diff = wew - x;
+                    w -= diff / (ew * (w + 1.0) - (w + 2.0) * diff / (2.0 * w + 2.0));
+                }
+                return w;
+            }
+    """)
+                   
+    def get_function_arguments(self, arguments):
+        out = ",\n".join([self._argument_table[arg] for arg in arguments])
+        return out
+
+    # --- Symbol printing --------------------------------------------------
+    def _print_Symbol(self, s):
+        for m in [self.map_Q, self.map_Qaux, self.map_param, self.map_normal, self.map_position]:
+            if s in m:
+                return m[s]
+        return super()._print_Symbol(s)
+
+    # --- Pow printing -----------------------------------------------------
+    def _print_Pow(self, expr):
+        base, exp = expr.as_base_exp()
+        if exp.is_Integer:
+            n = int(exp)
+            if n == 0:
+                return "1.0"
+            if n == 1:
+                return self._print(base)
+            if n < 0:
+                return f"(1.0 / Foam::pow({self._print(base)}, {abs(n)}))"
+            return f"Foam::pow({self._print(base)}, {n})"
+        return f"Foam::pow({self._print(base)}, {self._print(exp)})"
+    
+    # Print as a plain C function call "lambertw(...)"
+    def _print_LambertW(self, expr):
+        return f"lambertw({self._print(expr.args[0])})"
+
+    # --- Expression conversion --------------------------------------------
+    def convert_expression_body(self, expr, target='res'):
+        tmp_sym = sp.numbered_symbols('t')
+        temps, simplified = sp.cse(expr, symbols=tmp_sym)
+        lines = []
+        for lhs, rhs in temps:
+            lines.append(f"Foam::scalar {self.doprint(lhs)} = {self.doprint(rhs)};")
+        for i in range(expr.rows):
+            for j in range(expr.cols):
+                lines.append(f"{target}[{i}][{j}] = {self.doprint(simplified[0][i, j])};")
+        return "\n        ".join(lines)
+
+    # --- Matrix factory ---------------------------------------------------
+    def createMatrix(self, rows, cols):
+        return f"Foam::List<Foam::List<Foam::scalar>>({rows}, Foam::List<Foam::scalar>({cols}, 0.0))"
+
+    # --- Header / Footer --------------------------------------------------
+    def create_file_header(self, n_dof_q, n_dof_qaux, dim, list_sorted_function_names):
+        return textwrap.dedent(f"""\
+        #pragma once
+        #include "List.H"
+        #include "vector.H"
+        #include "scalar.H"
+
+        namespace Model
+        {{
+        constexpr int n_dof_q    = {n_dof_q};
+        constexpr int n_dof_qaux = {n_dof_qaux};
+        constexpr int dimension  = {dim};
+        const Foam::List<Foam::word> map_boundary_tag_to_function_index{{ {", ".join(f'"{item}"' for item in list_sorted_function_names)} }};
+        """)
+
+    def create_file_footer(self):
+        return "\n} // namespace Model\n"
+    
+    def create_generic_function(self, name, expr, arguments, n_dof_q, n_dof_qaux, target='res'):
+        if isinstance(expr, list):
+            dim = len(expr)
+            return [self.create_function(f"{name}_{d}", expr[i], n_dof_q, n_dof_qaux)
+                    for i, d in enumerate(['x', 'y', 'z'][:dim])]
+
+        rows, cols = expr.shape
+        body = self.convert_expression_body(expr, target)
+        return f"""
+inline Foam::List<Foam::List<Foam::scalar>> {name}(
+    {self.get_function_arguments(arguments)})
+{{
+    auto {target} = {self.createMatrix(rows, cols)};
+    {body}
+    return {target};
+}}
+        """
+
+    # --- Function generators ---------------------------------------------
+    def create_function(self, name, expr, n_dof_q, n_dof_qaux, target='res'):
+        if isinstance(expr, list):
+            dim = len(expr)
+            return [self.create_function(f"{name}_{d}", expr[i], n_dof_q, n_dof_qaux)
+                    for i, d in enumerate(['x', 'y', 'z'][:dim])]
+
+        rows, cols = expr.shape
+        body = self.convert_expression_body(expr, target)
+        return f"""
+inline Foam::List<Foam::List<Foam::scalar>> {name}(
+    const Foam::List<Foam::scalar>& Q,
+    const Foam::List<Foam::scalar>& Qaux)
+{{
+    auto {target} = {self.createMatrix(rows, cols)};
+    {body}
+    return {target};
+}}
+        """
+
+    def create_function_normal(self, name, expr, n_dof_q, n_dof_qaux, dim, target='res'):
+        if isinstance(expr, list):
+            return [self.create_function_normal(f"{name}_{d}", expr[i], n_dof_q, n_dof_qaux, dim)
+                    for i, d in enumerate(['x', 'y', 'z'][:dim])]
+
+        rows, cols = expr.shape
+        body = self.convert_expression_body(expr, target)
+        return f"""
+inline Foam::List<Foam::List<Foam::scalar>> {name}(
+    const Foam::List<Foam::scalar>& Q,
+    const Foam::List<Foam::scalar>& Qaux,
+    const Foam::vector& n)
+{{
+    auto {target} = {self.createMatrix(rows, cols)};
+    {body}
+    return {target};
+}}
+        """
+
+    def create_function_interpolate(self, name, expr, n_dof_q, n_dof_qaux, target='res'):
+        rows, cols = expr.shape
+        body = self.convert_expression_body(expr, target)
+        return f"""
+inline Foam::List<Foam::List<Foam::scalar>> {name}(
+    const Foam::List<Foam::scalar>& Q,
+    const Foam::List<Foam::scalar>& Qaux,
+    const Foam::vector& X)
+{{
+    auto {target} = {self.createMatrix(rows, cols)};
+    {body}
+    return {target};
+}}
+        """
+
+    def create_function_boundary(self, name, expr, n_dof_q, n_dof_qaux, dim, target='res'):
+        rows, cols = expr.shape
+        body = self.convert_expression_body(expr, target)
+        return f"""
+inline Foam::List<Foam::List<Foam::scalar>> {name}(
+    const Foam::List<Foam::scalar>& Q,
+    const Foam::List<Foam::scalar>& Qaux,
+    const Foam::vector& n,
+    const Foam::vector& X,
+    const Foam::scalar& time,
+    const Foam::scalar& dX)
+{{
+    auto {target} = {self.createMatrix(rows, cols)};
+    {body}
+    return {target};
+}}
+        """
+
+    # --- Full model generation ------------------------------------------
+    def create_model(self, model, additional_writes=None):
+        n_dof = model.n_variables
+        n_dof_qaux = model.n_aux_variables
+        dim = model.dimension
+        funcs = []
+        funcs.append(self.create_lambertw())
+        funcs += self.create_function('flux', model.flux(), n_dof, n_dof_qaux)
+        funcs += self.create_function('flux_jacobian', model.flux_jacobian(), n_dof, n_dof_qaux)
+        funcs += self.create_function('dflux', model.dflux(), n_dof, n_dof_qaux)
+        funcs += self.create_function('dflux_jacobian', model.dflux_jacobian(), n_dof, n_dof_qaux)
+        funcs += self.create_function('nonconservative_matrix', model.nonconservative_matrix(), n_dof, n_dof_qaux)
+        funcs += self.create_function('quasilinear_matrix', model.quasilinear_matrix(), n_dof, n_dof_qaux)
+        funcs.append(self.create_function_normal('eigenvalues', model.eigenvalues(), n_dof, n_dof_qaux, dim))
+        funcs.append(self.create_function('left_eigenvectors', model.left_eigenvectors(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function('right_eigenvectors', model.right_eigenvectors(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function('source', model.source(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function('residual', model.residual(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function('source_implicit', model.source_implicit(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function_interpolate('interpolate', model.project_2d_to_3d(), n_dof, n_dof_qaux))
+        funcs.append(self.create_function_boundary(
+            'boundary_conditions',
+            model.boundary_conditions.get_boundary_condition_function(
+                model.time, model.position, model.distance,
+                model.variables, model.aux_variables, model.parameters, model.normal),
+            n_dof, n_dof_qaux, dim))
+        if additional_writes is not None:
+            for a in additional_writes:
+                funcs.append(self.create_generic_function(
+                    a['name'], a['expression'], a['arguments'], n_dof, n_dof_qaux))
+
+        return self.create_file_header(n_dof, n_dof_qaux, dim, model.boundary_conditions.list_sorted_function_names) + "\n".join(funcs) + self.create_file_footer()
+
+
+def write_code(model, settings, additional_writes=None):
+    printer = FoamPrinter(model)
+    code = printer.create_model(model, additional_writes=additional_writes)
+    main_dir = os.getenv("ZOOMY_DIR")
+    path = os.path.join(main_dir, settings.output.directory, ".foam_interface")
+    os.makedirs(path, exist_ok=True)
+    file_path = os.path.join(path, "Model.H")
+    with open(file_path, "w+") as f:
+        f.write(code)

zoomy_core/transformation/to_ufl.py

@@ -0,0 +1,67 @@
+from attrs import define
+import ufl
+from zoomy_core.transformation.to_numpy import NumpyRuntimeModel
+
+
+
+@define(kw_only=False, slots=True, frozen=True)
+class UFLRuntimeModel(NumpyRuntimeModel):
+    printer=None
+    
+    module = {
+        'ones_like': lambda x: 0*x + 1,
+        'zeros_like': lambda x: 0*x,
+        'array': ufl.as_vector,
+        'squeeze': lambda x: x,
+        
+        # --- Elementary arithmetic ---
+        "Abs": abs,
+        "sign": ufl.sign,
+        "Min": ufl.min_value,
+        "Max": ufl.max_value,
+        # --- Powers and roots ---
+        "sqrt": ufl.sqrt,
+        "exp": ufl.exp,
+        "ln": ufl.ln,
+        "pow": lambda x, y: x**y,
+        # --- Trigonometric functions ---
+        "sin": ufl.sin,
+        "cos": ufl.cos,
+        "tan": ufl.tan,
+        "asin": ufl.asin,
+        "acos": ufl.acos,
+        "atan": ufl.atan,
+        "atan2": ufl.atan2,
+        # --- Hyperbolic functions ---
+        "sinh": ufl.sinh,
+        "cosh": ufl.cosh,
+        "tanh": ufl.tanh,
+        # --- Piecewise / conditional logic ---
+        "Heaviside": lambda x: ufl.conditional(x >= 0, 1.0, 0.0),
+        "Piecewise": ufl.conditional,
+        "signum": ufl.sign,
+        # --- Vector & tensor ops ---
+        "dot": ufl.dot,
+        "inner": ufl.inner,
+        "outer": ufl.outer,
+        "cross": ufl.cross,
+        # --- Differential operators (used in forms) ---
+        "grad": ufl.grad,
+        "div": ufl.div,
+        "curl": ufl.curl,
+        # --- Common constants ---
+        "pi": ufl.pi,
+        "E": ufl.e,
+        # --- Matrix and linear algebra ---
+        "transpose": ufl.transpose,
+        "det": ufl.det,
+        "inv": ufl.inv,
+        "tr": ufl.tr,
+        # --- Python builtins (SymPy may emit these) ---
+        "abs": abs,
+        "min": ufl.min_value,
+        "max": ufl.max_value,
+        "sqrt": ufl.sqrt,
+        "sum": lambda x: ufl.Constant(sum(x)) if isinstance(x, (list, tuple)) else x,
+        "ImmutableDenseMatrix": lambda x: x,
+    }

zoomy_core-0.1.11.dist-info/METADATA

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: zoomy_core
+Version: 0.1.11
+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
+
+Flexible modeling and simulation software for free-surface flows.
+
+![](web/images/overview2.png)
+
+Zoomy's main objective is to provide a convenient modeling interface for complex free-surface flow models. Zoomy transitions from a **symbolic** modeling layer to **numerical** layer, compatible with a multitude of numerical solvers, e.g. Numpy, Jax, Firedrake, FenicsX, OpenFOAM and AMReX. Additionally, we support the PreCICE coupling framework in many of our numerical implementations, to allow for a convenient integration of our solver with your existing code.
+
+## Documentation
+
+See our [Documentation](https://mbd-rwth.github.io/Zoomy/) for details on
+
+-   how to get started
+-   tutorials
+-   examples
+-   API
+-   ...
+
+## License
+
+The Zoomy code is free open-source software, licensed under version 3 or later of the GNU General Public License. See the file [LICENSE](LICENSE) for full copying permissions.
+
+## BibTex Citation
+
+T.b.d.
+
+## Installation
+
+### Conda/Mamba
+
+The project is composed out of different environment files. We start by installing the base and than adding 'flavors', depdening on the solver backend that you want to use.
+
+#### Default solver (Linux / Mac)
+
+**Base Installation**
+
+```         
+cd install
+conda env create -f install/zoomy.yml
+./conda_config_setup.sh
+```
+
+**Mesh support for Numpy/Jax solver**
+
+```         
+conda env update -f install/env-mesh.yml
+```
+
+\*\* CPU/GPU solver with JAX\*\*
+
+```         
+conda env update -f install/env-jax.yml
+```
+
+#### FenicsX (Linux / Mac)
+
+**Base Installation**
+
+```         
+cd install
+conda env create -f install/zoomy.yml
+./conda_config_setup.sh
+```
+
+**FenicsX**
+
+```         
+conda env update -f install/env-fenicsx.yml
+```
+
+#### Firedrake (Linux / Mac)
+
+**Base Installation**
+
+```         
+cd install
+conda env create -f install/zoomy.yml
+./conda_config_setup.sh
+```
+
+**Firedrake**
+
+Activate the environment before installing any Firedrake dependencies.
+
+```         
+conda activate zoomy
+```
+
+Mainly follow the instructions on the [Firedrake Webpage](https://www.firedrakeproject.org/install.html#install-firedrake).
+
+Deviating from the instructions on the webpage, we use
+
+```         
+python3 ../firedrake-configure --show-petsc-configure-options --with-pnetcdf=0 | xargs -L1 ./configure
+```
+
+to compile PetSc without PNetCDF and then install Firedrake inside our conda environment
+
+```         
+pip install --no-binary h5py 'firedrake[check]'
+```
+
+#### AMReX (Linux / Mac)
+
+**Base Installation**
+
+```         
+cd install
+conda env create -f install/zoomy.yml
+./conda_config_setup.sh
+```
+
+**AMReX**
+
+Note that the AMReX installation is *completely indepdenent* and the AMReX solver does not depend on the Conda/Mamba environment. Follow the instructions on the [AMReX Webpage](https://amrex-codes.github.io/amrex/docs_html/Introduction.html)
+
+#### OpenFOAM 12 (Linux / Mac)
+
+T.b.d
+
+**Activation**
+
+```         
+conda activate zoomy
+```
+
+### Docker
+
+T.b.d
+
+### Apptainer
+
+T.b.d
+
+### Manual installation
+
+See the `install/zoomy.yml` for a complete list of requirements. Once the requirements are fulfilled, simply clone the repository.
+
+The following environment variables need to be set
+
+```{bash}
+PYTHONPATH=/path/to/Zoomy
+ZOOMY_DIR=/path/to/Zoomy
+JAX_ENABLE_X64=True
+PETSC_DIR=/path/to/petsc/installation
+PETSC_ARCH=architecture used for compiling petsc
+```
+
+### External dependencies
+
+#### PreCICE
+
+T.b.d.
+
+### Working in Jupyter Notebooks
+
+Make sure to export the environment variables
+
+```{bash}
+PYTHONPATH=/path/to/Zoomy
+ZOOMY_DIR=/path/to/Zoomy
+JAX_ENABLE_X64=True //(if you use JAX)
+PETSC_DIR=/path/to/petsc/installation
+PETSC_ARCH=architecture used for compiling petsc
+```
+
+## Testing
+
+T.b.d.
+
+## Publications
+
+T.b.d.
+
+## Dependencies and acknowledgements
+
+This

zoomy_core-0.1.11.dist-info/RECORD

@@ -0,0 +1,51 @@
+zoomy_core/__init__.py,sha256=Gur2AV4_XwhwlIzdBX-E5BBQhw9KZVPo2xpbQMOYaH4,216
+zoomy_core/decorators/decorators.py,sha256=4fmdDDkHKoRFRbxMpTdM3KqDMV-dOL02DH2Ig29cpR0,853
+zoomy_core/fvm/flux.py,sha256=5EKXY_xqnH5T5o4cZTC-_SON14WLoXwygel8OTbPdAk,1888
+zoomy_core/fvm/nonconservative_flux.py,sha256=80iRIOZ5xiRJ7yeVgzrlf-kNmLlrqnUzQTEZxsHPZyc,3359
+zoomy_core/fvm/ode.py,sha256=Cx7DgLoWm7aqIjPtWUhoD9FnScZyPjKSuI4--uaiuU0,1453
+zoomy_core/fvm/solver_numpy.py,sha256=y5szY7jz1FQ8kHQip5NvHy3ww4r68bSaz0jFoGa_Om4,10835
+zoomy_core/fvm/timestepping.py,sha256=SqYjV0YAj4v5Ug2y7sEdZgF3DRH1lHPDa5BFsXzrm14,405
+zoomy_core/mesh/mesh.py,sha256=52ca4gx-pbFWHz7LfmT1KYS1yHKsQVw2H4V0z1mFwzs,50213
+zoomy_core/mesh/mesh_extrude.py,sha256=ln9bD5l_BEELUgx--j1I70Wv3tGgdqVcrxcDXKBMVyE,5992
+zoomy_core/mesh/mesh_util.py,sha256=IOe5FZ2vhiCTGRsRxUHEoek1o6N2QQAceuLUhuioG_k,16174
+zoomy_core/misc/custom_types.py,sha256=l1kfQJWPzT0PEvW-8bh4MD4BaIspWmtfQ4Y8Oq2qcT4,141
+zoomy_core/misc/interpolation.py,sha256=Z27uhcGRE_BWPm9voUbxHV5Ptj3cJnWd9vAWNqIfGIM,5095
+zoomy_core/misc/io.py,sha256=I5gCL3-JX6lI8CrybIOVYWTkCy6WoWgV5GGZDttUsu0,14504
+zoomy_core/misc/logger_config.py,sha256=506zLc8d9hn7b-r55ZWHWWx7GY0NjayVGMLNcNJQr5E,478
+zoomy_core/misc/misc.py,sha256=yunquXkPtZqWOa8RwRx4Y7rdqAK69S6QKIyohzRICzk,7390
+zoomy_core/model/analysis.py,sha256=qt7cs3s5ijen5I11ntS3Y5pVPI8ufijjCJj-7Is9YMo,5332
+zoomy_core/model/basefunction.py,sha256=XtlKQCkamWnM_ohW0-3PYXrkK0_poIFHMtz-o52JYSo,3542
+zoomy_core/model/basemodel.py,sha256=RAVhFPNFo5GJ8OpxgrRfFsBXaW2ugIg3MqUGM38QQI8,16883
+zoomy_core/model/boundary_conditions.py,sha256=_TFYppTc9Q8ANXCjsKxcVvNbLyqHKr-VYjdcLZxV3no,6608
+zoomy_core/model/initial_conditions.py,sha256=3ZmJeABD1xHb-qZ2tBlIFnHVvHWJxygTgtIw5t7k1oM,5427
+zoomy_core/model/model.py,sha256=teSVpgtePlbdeAEthF05Edd3IIoQGVx_debIKQrd92c,1928
+zoomy_core/model/models/GN.py,sha256=ymOlDpn8I5Xzk2GvXm2gvialSWTzxpPSvxzkP0qOMlc,1913
+zoomy_core/model/models/advection.py,sha256=G-oDMNbKAahlW90ocyf-HGM55-JX59cMARV8JaRfe_g,2111
+zoomy_core/model/models/basisfunctions.py,sha256=ZHeQYXwgpB8YAZ-8l3NYYvi8CSuvFzJ0xiyaai4WsCA,5410
+zoomy_core/model/models/basismatrices.py,sha256=6zGgXXrGH-3VjJFlcvXR1W9Vv3AfWzjrONSpejEM4RM,13024
+zoomy_core/model/models/core.py,sha256=Tjc2kX0DfwgK_KtYnb60Y0YlTWpHm1hylzArk3lbieo,19350
+zoomy_core/model/models/coupled_constrained.py,sha256=q2qOh7Vf3ryG0rS9VXD4oUDMaHEZ7g74AtgHQePXEC0,1741
+zoomy_core/model/models/poisson.py,sha256=B_8qc_6FnEzB91-fdKzWlHo8Jiq1Kmjxp1xBC6YB-ag,1075
+zoomy_core/model/models/shallow_moments.py,sha256=kSNxnAQnCmmFBggcXmOh1yVlF_1_8-QxDGLPvajcELo,27098
+zoomy_core/model/models/shallow_moments_sediment.py,sha256=rt1ohClioEpPOYO0w1zB9VHGkjP0RWxM4M18BEA00rI,14292
+zoomy_core/model/models/shallow_moments_topo.py,sha256=_5KWvT3iUbPU5zAZN4J904b1r5yJiMTFojmeVD7oxsg,17402
+zoomy_core/model/models/shallow_moments_variants.py,sha256=NsRF9kaiYxQtV94oOZsMBDFXwzmm_R-rz6fAUuYQRxc,52059
+zoomy_core/model/models/shallow_water.py,sha256=1Sn8mVCUiYZue2SvLfGfRMOsfD0G9hL72x_ENdA9QRU,8412
+zoomy_core/model/models/shallow_water_topo.py,sha256=Y-ibbM9Hj7gPreZUmTEBcYlhM0AzIiMYKuEeJYi-Pxc,3455
+zoomy_core/model/models/shear_shallow_flow.py,sha256=O2JZaK1E8qUPVJHYaTksMDV3IuxD9nez1hHmdKHRJng,17250
+zoomy_core/model/models/sme_turbulent.py,sha256=8PzvbSdEYNEaz-9LCvahL_-Gt_tdGv3PPjBqYRz11V4,24048
+zoomy_core/model/models/vam.py,sha256=aHI1LCkNQC8g8uEZujp36NYVuaKxfCapl9W-5fSzLWk,15114
+zoomy_core/postprocessing/postprocessing.py,sha256=WD8o4H7PE6B6lEsKwVsMnJufhx2mUm2jCf_5aTYQV8E,2814
+zoomy_core/preprocessing/openfoam_moments.py,sha256=DJWXRGAwLH1gin2XwAINdP0QcCbs9wd7BH9nciu_9iY,14684
+zoomy_core/transformation/helpers.py,sha256=KClsyBc0LZNocKzbfknhhYPshA83cDLkzfAKkPGoy1o,915
+zoomy_core/transformation/to_amrex.py,sha256=usIOIS05reWBNk0MuH7xUdjDZV81JJ4sQmIlR0yQiV8,9593
+zoomy_core/transformation/to_c.py,sha256=a_22vacgMvSZTCsrr1XAZqD0SqVYgKbp25HnoBBZxjE,7198
+zoomy_core/transformation/to_jax.py,sha256=XkQHMv8hNm9kMcUm8xHZMhlsQqK9_4IDuUw8phFJviU,395
+zoomy_core/transformation/to_numpy.py,sha256=lUt7ijRuQ7jWu3i6zH9xQB3Za2cqb-CcTSfV36e8xlQ,4730
+zoomy_core/transformation/to_openfoam.py,sha256=KykbKVsr6ktPSjG2C1YYr9K1g1Adugd1GVOLymBsf9g,10676
+zoomy_core/transformation/to_ufl.py,sha256=U4TQpBStlR44bXP8_ochYYDSYk1kZTlpKl-aZ7WNTqw,1991
+zoomy_core-0.1.11.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+zoomy_core-0.1.11.dist-info/METADATA,sha256=KeDZvy2u0XSaH4jMjjf3K0oCfrjQ9ni0RU_ix6ZKPvI,5495
+zoomy_core-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+zoomy_core-0.1.11.dist-info/top_level.txt,sha256=NCamZmp9nka6uLXNdAbb47vtoiLmvm3uBKvaBuUdfdQ,11
+zoomy_core-0.1.11.dist-info/RECORD,,

zoomy_core-0.1.11.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+