zoomy-core 0.1.1__tar.gz → 0.1.2__tar.gz

{zoomy_core-0.1.1 → zoomy_core-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zoomy_core
-Version: 0.1.1
+Version: 0.1.2
 Summary: A simulation software for dimensionally-reduced free surface flows.
 Author-email: Ingo Steldermann <steldermann@mbd.rwth-aachen.de>
 License: GNU

zoomy_core-0.1.2/library/zoomy_core/decorators/decorators.py

@@ -0,0 +1,25 @@
+
+def require(requirement):
+    """
+    Decorator to check if a requirement is met before executing the decorated function.
+
+    Parameters:
+    - requirement (str): The requirement string to evaluate. Should evaluate to True or False.
+
+    Returns:
+    - wrapper: The decorated function that will check the requirement before executing.
+    """
+
+    # decorator to check the assertion given in requirements given the settings
+    def req_decorator(func):
+        @wraps(func)
+        def wrapper(settings, *args, **kwargs):
+            requirement_evaluated = eval(requirement)
+            if not requirement_evaluated:
+                print("Requirement {}: {}".format(requirement, requirement_evaluated))
+                assert requirement_evaluated
+            return func(settings, *args, **kwargs)
+
+        return wrapper
+
+    return req_decorator

zoomy_core-0.1.2/library/zoomy_core/fvm/flux.py

@@ -0,0 +1,97 @@
+import numpy as np
+
+"""
+Dummy flux
+"""
+
+
+def Zero():
+    def flux(Qi, Qj, Qauxi, Qauxj, param, normal, model_functions, mesh_props=None):
+        Qout = np.zeros_like(Qi)
+        return Qout, False
+
+    return flux
+
+
+"""
+Lax-Friedrichs flux implementation
+"""
+
+
+def LF():
+    def flux(Qi, Qj, Qauxi, Qauxj, param, normal, model_functions, mesh_props=None):
+        assert mesh_props is not None
+        dt_dx = mesh_props.dt_dx
+        Qout = np.zeros_like(Qi)
+        flux = model_functions.flux
+        dim = normal.shape[0]
+        num_eq = Qi.shape[0]
+        for d in range(dim):
+            Fi = flux[d](Qi, Qauxi, param)
+            Fj = flux[d](Qj, Qauxj, param)
+            Qout += 0.5 * (Fi + Fj) * normal[d]
+        Qout -= 0.5 * dt_dx * (Qj - Qi)
+        return Qout, False
+
+    return flux
+
+
+"""
+Rusanov (local Lax-Friedrichs) flux implementation
+"""
+
+
+def LLF():
+    def flux(Qi, Qj, Qauxi, Qauxj, param, normal, model_functions, mesh_props=None):
+        EVi = model_functions.eigenvalues(Qi, Qauxi, param, normal)
+        EVj = model_functions.eigenvalues(Qj, Qauxj, param, normal)
+        assert not np.isnan(EVi).any()
+        assert not np.isnan(EVj).any()
+        smax = np.max(np.abs(np.vstack([EVi, EVj])))
+        Qout = np.zeros_like(Qi)
+        flux = model_functions.flux
+        dim = normal.shape[0]
+        num_eq = Qi.shape[0]
+        for d in range(dim):
+            Fi = flux[d](Qi, Qauxi, param)
+            Fj = flux[d](Qj, Qauxj, param)
+            Qout += 0.5 * (Fi + Fj) * normal[d]
+        Qout -= 0.5 * smax * (Qj - Qi)
+        return Qout, False
+
+    return flux
+
+
+"""
+Rusanov (local Lax-Friedrichs) flux implementation
+with topography fix (e.g. for model SWEtopo)
+with WB fix for lake at rest
+"""
+
+
+def LLF_wb():
+    def flux(Qi, Qj, Qauxi, Qauxj, param, normal, model_functions, mesh_props=None):
+        IWB = np.eye(Qi.shape[0])
+        IWB[-1, :] = 0.0
+        IWB[0, -1] = 0.0
+        EVi = np.zeros_like(Qi)
+        EVj = np.zeros_like(Qj)
+        EVi = model_functions.eigenvalues(Qi, Qauxi, param, normal)
+        EVj = model_functions.eigenvalues(Qj, Qauxj, param, normal)
+        assert not np.isnan(EVi).any()
+        assert not np.isnan(EVj).any()
+        smax = np.max(np.abs(np.vstack([EVi, EVj])))
+        Qout = np.zeros_like(Qi)
+        flux = model_functions.flux
+        dim = normal.shape[0]
+        num_eq = Qi.shape[0]
+        Fi = np.zeros((num_eq))
+        Fj = np.zeros((num_eq))
+        for d in range(dim):
+            flux[d](Qi, Qauxi, param, Fi)
+            flux[d](Qj, Qauxj, param, Fj)
+            Qout += 0.5 * (Fi + Fj) * normal[d]
+        Qout -= 0.5 * smax * IWB @ (Qj - Qi)
+        return Qout, False
+
+    return flux

zoomy_core-0.1.2/library/zoomy_core/fvm/nonconservative_flux.py

@@ -0,0 +1,97 @@
+import numpy as np
+from numpy.polynomial.legendre import leggauss
+from functools import partial
+
+
+def zero():
+    def nc_flux(Qi, Qauxi, Qj, Qauxj, parameters, normal, model):
+        return np.zeros_like(Qi), False
+
+    return nc_flux
+
+def segmentpath(integration_order=3, scheme='rusanov'):
+    # compute integral of NC-Matrix int NC(Q(s)) ds for segment path Q(s) = Ql + (Qr-Ql)*s for s = [0,1]
+    samples, weights = leggauss(integration_order)
+    # shift from [-1, 1] to [0,1]
+    samples = 0.5 * (samples + 1)
+    weights *= 0.5
+
+    def priceC(
+        Qi, Qj, Qauxi, Qauxj, parameters, normal, svA, svB, vol_face, dt, model
+    ):
+        dim = normal.shape[0]
+        n_variables = Qi.shape[0]
+        n_cells = Qi.shape[1]
+
+        def B(s):
+            out = np.zeros((n_variables, n_variables, n_cells), dtype=float)
+            tmp = np.zeros_like(out)
+            for d in range(dim):
+                tmp = model.quasilinear_matrix[d](
+                    Qi + s * (Qj - Qi), Qauxi + s * (Qauxj - Qauxi), parameters
+                )
+                out = out + tmp * normal[d]
+                # out[:,:,:] += tmp * normal[d]
+            return out
+
+        Bint = np.zeros((n_variables, n_variables, n_cells))
+        for w, s in zip(weights, samples):
+            Bint += w * B(s)
+
+        Bint_sq = np.einsum("ij..., jk...->ik...", Bint, Bint)
+        I = np.zeros_like(Bint)
+        for i in range(n_variables):
+            # I[i, i, :] = 1.
+            I = I.at[i, i, :].set(1.0)
+            
+        Am = (
+            0.5 * Bint
+            - (svA * svB) / (svA + svB) * 1.0 / (dt * vol_face) * I
+            - 1 / 4 * (dt * vol_face) / (svA + svB) * Bint_sq
+        )
+        # Am = 0.5* Bint - np.einsum('..., ij...->ij...', (svA * svB)/(svA + svB) * 1./(dt * vol_face) ,I)  - 1/4 * np.einsum('..., ij...->ij...', (dt * vol_face)/(svA + svB) , Bint_sq)
+
+        return np.einsum("ij..., j...->i...", Am, (Qj - Qi)), False
+
+
+    def rusanov(
+        Qi, Qj, Qauxi, Qauxj, parameters, normal, svA, svB, vol_face, dt, model
+    ):
+        dim = normal.shape[0]
+        n_variables = Qi.shape[0]
+        n_cells = Qi.shape[1]
+
+        def B(s):
+            # out = np.zeros((n_variables, n_variables, n_cells), dtype=float)
+            # tmp = np.zeros_like(out)
+            # for d in range(dim):
+            #     tmp = model.quasilinear_matrix[d](
+            #         Qi + s * (Qj - Qi), Qauxi + s * (Qauxj - Qauxi), parameters
+            #     )
+            #     out = out + tmp * normal[d]
+            out = np.einsum("ijd..., d...->ij...", model.quasilinear_matrix(
+                Qi + s * (Qj - Qi), Qauxi + s * (Qauxj - Qauxi), parameters
+            ), normal)
+            return out
+
+        Am = np.zeros((n_variables, n_variables, n_cells))
+        for w, s in zip(weights, samples):
+            Am += w * B(s)
+
+        I = np.zeros_like(Am)
+        for i in range(n_variables):
+            I[i, i, :] = 1.0
+
+        ev_i = model.eigenvalues(Qi, Qauxi, parameters, normal)
+        ev_j = model.eigenvalues(Qj, Qauxj, parameters, normal)
+        sM = np.maximum(np.abs(ev_i).max(axis=0), np.abs(ev_j).max(axis=0))
+
+        return np.einsum("ij..., j...->i...", 0.5 * Am + 0.5 * sM * I, (Qj - Qi)), np.einsum("ij..., j...->i...", 0.5 * Am - 0.5 * sM * I, (Qj - Qi)), False
+
+    if scheme == 'rusanov':
+        return rusanov
+    elif scheme=='priceC':
+        return priceC
+
+
+

zoomy_core-0.1.2/library/zoomy_core/fvm/ode.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+
+def RK1(func, Q, Qaux, param, dt, func_jac=None, func_bc=None):
+    dQ = np.zeros_like(Q)
+    dQ = func(dt, Q, Qaux, param, dQ)
+    return Q + dt * dQ
+
+
+def RK2(func, Q, Qaux, param, dt, func_jac=None, func_bc=None):
+    """
+    heun scheme
+    """
+    dQ = np.zeros_like(Q)
+    Q0 = np.array(Q)
+    dQ = func(dt, Q, Qaux, param, dQ)
+    Q1 = Q + dt * dQ
+    dQ = func(dt, Q1, Qaux, param, dQ)
+    Q2 = Q1 + dt * dQ
+    return 0.5 * (Q0 + Q2)
+
+
+def RK3(func, Q, Qaux, param, dt, func_jac=None, func_bc=None):
+    """ """
+    dQ = np.zeros_like(Q)
+    Q0 = np.array(Q)
+    dQ = func(dt, Q, Qaux, param, dQ)
+    Q1 = Q + dt * dQ
+    dQ = func(dt, Q1, Qaux, param, dQ)
+    Q2 = 3.0 / 4 * Q0 + 1.0 / 4 * (Q1 + dt * dQ)
+    dQ = func(dt, Q2, Qaux, param, dQ)
+    Q3 = 1.0 / 3 * Q0 + 2 / 3 * (Q2 + dt * dQ)
+    # TODO see old implementation
+    # func(dt, Q3, Qaux, param, dQ)
+    return Q3
+
+
+def RKimplicit(func, Q, Qaux, param, dt, func_jac=None, func_bc=None):
+    """
+    implicit euler
+    """
+    assert func_jac is not None
+    Jac = np.zeros((Q.shape[0], Q.shape[0], Q.shape[1]), dtype=float)
+    dQ = np.zeros_like(Q)
+    I = np.eye(Q.shape[0])
+
+    dQ = func(dt, Q, Qaux, param, dQ)
+    Jac = func_jac(dt, Q, Qaux, param, Jac)
+
+    b = Q + dt * dQ
+    for i in range(Q.shape[1]):
+        A = I - dt * Jac[:, :, i]
+        b[:, i] += -dt * np.dot(Jac[:, :, i], Q[:, i])
+        Q[:, i] = np.linalg.solve(A, b[:, i])
+    return Q

zoomy_core-0.1.2/library/zoomy_core/fvm/solver_numpy.py

@@ -0,0 +1,305 @@
+import os
+from time import time as gettime
+
+import numpy as np
+from attr import define
+
+from typing import Callable
+from attrs import define, field
+
+from library.zoomy_core.misc.logger_config import logger
+
+
+
+import library.zoomy_core.fvm.flux as flux
+import library.zoomy_core.fvm.nonconservative_flux as nonconservative_flux
+import library.zoomy_core.misc.io as io
+from library.zoomy_core.misc.misc import Zstruct, Settings
+import library.zoomy_core.fvm.ode as ode
+import library.zoomy_core.fvm.timestepping as timestepping
+from library.zoomy_core.transformation.to_numpy import NumpyRuntimeModel
+
+
+@define(frozen=True, slots=True, kw_only=True)            
+class Solver():
+    settings: Zstruct = field(factory=lambda: Settings.default())
+
+    def __attrs_post_init__(self):
+        defaults = Settings.default()
+        defaults.update(self.settings)
+        object.__setattr__(self, 'settings', defaults)
+        
+
+    def initialize(self, mesh, model):
+        # model.boundary_conditions.initialize(
+        #     mesh,
+        #     model.time,
+        #     model.position,
+        #     model.distance,
+        #     model.variables,
+        #     model.aux_variables,
+        #     model.parameters,
+        #     model.normal,
+        # )
+
+        n_variables = model.n_variables
+        n_cells = mesh.n_cells
+        n_aux_variables = model.aux_variables.length()
+
+        Q = np.empty((n_variables, n_cells), dtype=float)
+        Qaux = np.empty((n_aux_variables, n_cells), dtype=float)
+        return Q, Qaux
+        
+    def create_runtime(self, Q, Qaux, mesh, model):      
+        mesh.resolve_periodic_bcs(model.boundary_conditions)
+        Q, Qaux = np.asarray(Q), np.asarray(Qaux)
+        parameters = np.asarray(model.parameter_values)
+        runtime_model = NumpyRuntimeModel(model)        
+        return Q, Qaux, parameters, mesh, runtime_model
+
+    def get_compute_source(self, mesh, model):
+        def compute_source(dt, Q, Qaux, parameters, dQ):
+            dQ = model.source(
+                    Q[:, :],
+                    Qaux[:, :],
+                    parameters,
+            )
+            return dQ
+
+        return compute_source
+
+    def get_compute_source_jacobian_wrt_variables(self, mesh, model):
+        def compute_source(dt, Q, Qaux, parameters, dQ):
+            dQ = model.source_jacobian_wrt_variables(
+                    Q[:, : mesh.n_inner_cells],
+                    Qaux[:, : mesh.n_inner_cells],
+                    parameters,
+                )
+            return dQ
+
+        return compute_source
+    
+    def get_apply_boundary_conditions(self, mesh, model):
+        # runtime_bcs = tuple(model.bcs)
+
+        # def apply_boundary_conditions(time, Q, Qaux, parameters):
+        #     for i in range(mesh.n_boundary_faces):
+        #         i_face = mesh.boundary_face_face_indices[i]
+        #         i_bc_func = mesh.boundary_face_function_numbers[i]
+        #         q_cell = Q[:, mesh.boundary_face_cells[i]]  # Shape: (Q_dim,)
+        #         qaux_cell = Qaux[:, mesh.boundary_face_cells[i]]
+        #         normal = mesh.face_normals[:, i_face]
+        #         position = mesh.face_centers[i_face, :]
+        #         position_ghost = mesh.cell_centers[:, mesh.boundary_face_ghosts[i]]
+        #         distance = np.linalg.norm(position - position_ghost)
+        #         q_ghost = runtime_bcs[i_bc_func](time, position, distance, q_cell, qaux_cell, parameters, normal)
+        #         Q[:,  mesh.boundary_face_ghosts[i]] = q_ghost
+        #     return Q
+        
+        def apply_boundary_conditions(time, Q, Qaux, parameters):
+            for i in range(mesh.n_boundary_faces):
+                i_face = mesh.boundary_face_face_indices[i]
+                i_bc_func = mesh.boundary_face_function_numbers[i]
+                q_cell = Q[:, mesh.boundary_face_cells[i]]  # Shape: (Q_dim,)
+                qaux_cell = Qaux[:, mesh.boundary_face_cells[i]]
+                normal = mesh.face_normals[:, i_face]
+                position = mesh.face_centers[i_face, :]
+                position_ghost = mesh.cell_centers[:, mesh.boundary_face_ghosts[i]]
+                distance = np.linalg.norm(position - position_ghost)
+                q_ghost = model.boundary_conditions(i_bc_func, time, position, distance, q_cell, qaux_cell, parameters, normal)
+                Q[:,  mesh.boundary_face_ghosts[i]] = q_ghost
+            return Q
+
+        return apply_boundary_conditions
+    
+    def update_q(self, Q, Qaux, mesh, model, parameters):
+        """
+        Update variables before the solve step.
+        """
+        # This is a placeholder implementation. Replace with actual logic as needed.
+        return Q
+    
+    def update_qaux(self, Q, Qaux, Qold, Qauxold, mesh, model, parameters, time, dt):
+        """
+        Update auxiliary variables
+        """
+        # This is a placeholder implementation. Replace with actual logic as needed.
+        return Qaux
+    
+    def solve(self, mesh, model):
+        logger.error(
+            "Solver.solve() is not implemented. Please implement this method in the derived class."
+        )
+        raise NotImplementedError("Solver.solve() must be implemented in derived classes.")
+
+ 
+@define(frozen=True, slots=True, kw_only=True)            
+class HyperbolicSolver(Solver):
+    settings: Zstruct = field(factory=lambda: Settings.default())
+    compute_dt: Callable = field(factory=lambda: timestepping.adaptive(CFL=0.45))
+    num_flux: Callable = field(factory=lambda: flux.Zero())
+    nc_flux: Callable = field(factory=lambda: nonconservative_flux.segmentpath())
+    time_end: float = 0.1
+
+
+    def __attrs_post_init__(self):
+        super().__attrs_post_init__()
+        defaults = Settings.default()
+        defaults.output.update(Zstruct(snapshots=10))
+        defaults.update(self.settings)
+        object.__setattr__(self, 'settings', defaults)
+        
+
+    def initialize(self, mesh, model):
+        Q, Qaux = super().initialize(mesh, model)
+        Q = model.initial_conditions.apply(mesh.cell_centers, Q)
+        Qaux = model.aux_initial_conditions.apply(mesh.cell_centers, Qaux)
+        return Q, Qaux
+
+    def get_compute_max_abs_eigenvalue(self, mesh, model):
+        def compute_max_abs_eigenvalue(Q, Qaux, parameters):
+            max_abs_eigenvalue = -np.inf
+            i_cellA = mesh.face_cells[0]
+            i_cellB = mesh.face_cells[1]
+            qA = Q[:, i_cellA]
+            qB = Q[:, i_cellB]
+            qauxA = Qaux[:, i_cellA]
+            qauxB = Qaux[:, i_cellB]
+            normal = mesh.face_normals
+            evA = model.eigenvalues(qA, qauxA, parameters, normal)
+            evB = model.eigenvalues(qB, qauxB, parameters, normal)
+            max_abs_eigenvalue = np.maximum(np.abs(evA).max(axis=0), np.abs(evB).max(axis=0))
+            return max_abs_eigenvalue
+        return compute_max_abs_eigenvalue
+
+    def get_flux_operator(self, mesh, model):
+        def flux_operator(dt, Q, Qaux, parameters, dQ):
+            compute_num_flux = self.num_flux
+            compute_nc_flux = self.nc_flux
+            # Initialize dQ as zeros using jax.numpy
+            dQ = np.zeros_like(dQ)
+
+            iA = mesh.face_cells[0]
+            iB = mesh.face_cells[1]
+
+            qA = Q[:, iA]
+            qB = Q[:, iB]
+            qauxA = Qaux[:, iA]
+            qauxB = Qaux[:, iB]
+            normals = mesh.face_normals
+            face_volumes = mesh.face_volumes
+            cell_volumesA = mesh.cell_volumes[iA]
+            cell_volumesB = mesh.cell_volumes[iB]
+            svA = mesh.face_subvolumes[:, 0]
+            svB = mesh.face_subvolumes[:, 1]
+
+            Dp, Dm, failed = compute_nc_flux(
+                qA,
+                qB,
+                qauxA,
+                qauxB,
+                parameters,
+                normals,
+                svA,
+                svB,
+                face_volumes,
+                dt,
+                model,
+            )
+            flux_out = Dm * face_volumes / cell_volumesA
+            flux_in = Dp * face_volumes / cell_volumesB
+
+            dQ[:, iA]-= flux_out
+            dQ[:, iB]-= flux_in
+            return dQ
+        return flux_operator
+
+    def solve(self, mesh, model, write_output=True):
+        Q, Qaux = self.initialize(mesh, model)
+        
+        Q, Qaux, parameters, mesh, model = self.create_runtime(Q, Qaux, mesh, model)
+        
+        # init once with dummy values for dt
+        Qaux = self.update_qaux(Q, Qaux, Q, Qaux, mesh, model, parameters, 0.0, 1.0)
+
+        
+        if write_output:
+            output_hdf5_path = os.path.join(
+                self.settings.output.directory, f"{self.settings.output.filename}.h5"
+            )
+            save_fields = io.get_save_fields(output_hdf5_path, write_all=False)
+        else:
+            def save_fields(time, time_stamp, i_snapshot, Q, Qaux):
+                return i_snapshot
+
+        def run(Q, Qaux, parameters, model):
+            iteration = 0.0
+            time = 0.0
+
+            i_snapshot = 0.0
+            dt_snapshot = self.time_end / (self.settings.output.snapshots - 1)
+            if write_output:
+                io.init_output_directory(
+                    self.settings.output.directory, self.settings.output.clean_directory
+                )
+                mesh.write_to_hdf5(output_hdf5_path)
+                io.save_settings(self.settings)
+            i_snapshot = save_fields(time, 0.0, i_snapshot, Q, Qaux)
+
+            Qnew = Q
+            Qauxnew = Qaux
+
+            compute_max_abs_eigenvalue = self.get_compute_max_abs_eigenvalue(mesh, model)
+            flux_operator = self.get_flux_operator(mesh, model)
+            source_operator = self.get_compute_source(mesh, model)
+            boundary_operator = self.get_apply_boundary_conditions(mesh, model)
+            Qnew = boundary_operator(time, Qnew, Qaux, parameters)
+
+
+            cell_inradius_face = np.minimum(mesh.cell_inradius[mesh.face_cells[0, :]], mesh.cell_inradius[mesh.face_cells[1,:]])
+
+            while time < self.time_end:
+                Q = Qnew
+                Qaux = Qauxnew
+                
+                dt = self.compute_dt(
+                    Q, Qaux, parameters, cell_inradius_face, compute_max_abs_eigenvalue
+                )
+
+                Q1 = ode.RK1(flux_operator, Q, Qaux, parameters, dt)
+                Q2 = ode.RK1(
+                    source_operator,
+                    Q1,
+                    Qaux,
+                    parameters,
+                    dt,
+                )
+
+                Q3 = boundary_operator(time, Q2, Qaux, parameters)
+                
+                # Update solution and time
+                time += dt
+                iteration += 1
+
+                time_stamp = (i_snapshot) * dt_snapshot
+                
+                Qnew = self.update_q(Q3, Qaux, mesh, model, parameters)
+                Qauxnew = self.update_qaux(Qnew, Qaux, Q, Qaux, mesh, model, parameters, time, dt)
+
+
+                i_snapshot = save_fields(time, time_stamp, i_snapshot, Qnew, Qauxnew)
+
+                if iteration % 10 == 0:
+                    logger.info(
+                        f"iteration: {int(iteration)}, time: {float(time):.6f}, "
+                        f"dt: {float(dt):.6f}, next write at time: {float(time_stamp):.6f}"
+                    )
+
+            return Qnew, Qaux
+
+        time_start = gettime()
+        Qnew, Qaux = run(Q, Qaux, parameters, model)
+        time = gettime() - time_start
+        logger.info(f"Finished simulation with in {time:.3f} seconds")
+        return Qnew, Qaux
+    

zoomy_core-0.1.2/library/zoomy_core/fvm/timestepping.py

@@ -0,0 +1,13 @@
+def constant(dt=0.1):
+    def compute_dt(Q, Qaux, parameters, min_inradius, compute_max_abs_eigenvalue):
+        return dt
+
+    return compute_dt
+
+
+def adaptive(CFL=0.9):
+    def compute_dt(Q, Qaux, parameters, min_inradius, compute_max_abs_eigenvalue):
+        ev_abs_max = compute_max_abs_eigenvalue(Q, Qaux, parameters)
+        return (CFL * 2 * min_inradius / ev_abs_max).min()
+
+    return compute_dt