zoomy-core 0.1.0__py3-none-any.whl → 0.1.2__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 library.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.0.dist-info → zoomy_core-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zoomy_core
-Version: 0.1.0
+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.dist-info/RECORD

@@ -0,0 +1,55 @@
+zoomy_core/decorators/decorators.py,sha256=4fmdDDkHKoRFRbxMpTdM3KqDMV-dOL02DH2Ig29cpR0,853
+zoomy_core/fvm/flux.py,sha256=hO5SYSSuPLJDiNs58ZrQHWZ5uhki94UPYxgNPlmw2yU,2696
+zoomy_core/fvm/nonconservative_flux.py,sha256=l7jga6rNnchzrpW9Q0bTvyuxmdI0u8mprYubZJss9Qc,3412
+zoomy_core/fvm/ode.py,sha256=Cx7DgLoWm7aqIjPtWUhoD9FnScZyPjKSuI4--uaiuU0,1453
+zoomy_core/fvm/solver_numpy.py,sha256=CvcjKFRnZBCPbcPf-bUF_jVzr--_Tpa58fU3rgul1Ck,11523
+zoomy_core/fvm/timestepping.py,sha256=SqYjV0YAj4v5Ug2y7sEdZgF3DRH1lHPDa5BFsXzrm14,405
+zoomy_core/mesh/gmsh_loader.py,sha256=weW62smAmlr6wcIiqzDSiNkKppCVRQ9zDS-rpaOHYkY,9610
+zoomy_core/mesh/mesh.py,sha256=vtxcgi5EkOxtAQwWlmx6TGUNEaw4Z48aAuLEGD7bW80,49134
+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/gui.py,sha256=xpmluxsMsFVtyUhs412JrWk1-YA_CHbL0kPcopQep_o,2024
+zoomy_core/misc/interpolation.py,sha256=pWtKT9KCOIA8zikJdWnPRDFNVMK_5ko2rjx9ZQA1dnY,5111
+zoomy_core/misc/io.py,sha256=KiY85umLarqFyMSTjYxE0sB19-3oD1UFBmkb_eZgDcg,14072
+zoomy_core/misc/logger_config.py,sha256=506zLc8d9hn7b-r55ZWHWWx7GY0NjayVGMLNcNJQr5E,478
+zoomy_core/misc/misc.py,sha256=3STgN-YrnFkhZfHUEzFVyRqPD4G1rBbsc9nbpUpNZLg,7526
+zoomy_core/misc/static_class.py,sha256=SkvMefakhKENEQMzigGYAPDZjhGl1AvNo22tcHXxKSM,2658
+zoomy_core/model/analysis.py,sha256=qt7cs3s5ijen5I11ntS3Y5pVPI8ufijjCJj-7Is9YMo,5332
+zoomy_core/model/basefunction.py,sha256=uNl5jU0FtOCbYbBU_70L8RrdPFKsNYcnJKHwl6aBKtE,3550
+zoomy_core/model/basemodel.py,sha256=R97gmFKUCVtzBZ-2nqbpEQXx_PxtCTTTyyyCGDzsIuE,16923
+zoomy_core/model/boundary_conditions.py,sha256=YSHu5XG3hRKwXNsOZmCnBcjvgK0eZrd8VoIhZ588kM4,6635
+zoomy_core/model/initial_conditions.py,sha256=etU0wbq_ZaAsenVNddBroUo8ga6_xLJmKNZQ12Z0IiY,5467
+zoomy_core/model/model.py,sha256=GUYUW-UnzJdZLOG8DAFaUdtTeKg40tiCvGMcFy3rxXw,1976
+zoomy_core/model/models/GN.py,sha256=Qaki-68uZZlW4ApmVNskTl03QLnNFpir0grhkV76DpU,1945
+zoomy_core/model/models/advection.py,sha256=nYzWL1djx0aleZ1acM0-nS2T14l4vkuPZEb7kkzizCA,2151
+zoomy_core/model/models/basisfunctions.py,sha256=ZHeQYXwgpB8YAZ-8l3NYYvi8CSuvFzJ0xiyaai4WsCA,5410
+zoomy_core/model/models/basismatrices.py,sha256=gimOx2XXqHGy6tFsVj6fXh2QxEO6lcW-o7VqP-PmSLk,13032
+zoomy_core/model/models/core.py,sha256=Tjc2kX0DfwgK_KtYnb60Y0YlTWpHm1hylzArk3lbieo,19350
+zoomy_core/model/models/coupled_constrained.py,sha256=wF9yHsRCKg0rLtrlwxYr0yYDE1nON1JlalHL3ZD4U7c,1765
+zoomy_core/model/models/old_smm copy.py,sha256=XmFVcjq7ytdQNOEnl6ARNW5NBIRuz_7nG2rIpTP3WUk,31465
+zoomy_core/model/models/poisson.py,sha256=-EoZDfHI15ZIJSxKiE6DeNkAAaS91nQdwKa4olFObL0,1107
+zoomy_core/model/models/shallow_moments.py,sha256=H9pmnzwInBf8OvFblHxoYPKBUMgByAfXKFe1QtBE0n8,27138
+zoomy_core/model/models/shallow_moments_sediment.py,sha256=jfDrC8Lk-KQr-tW9pcoX38WTRZCEBRDaH0Lw1AU8qxA,14300
+zoomy_core/model/models/shallow_moments_topo.py,sha256=32cxlYt3cib-Ex8dNtau-IVCLqFfxDeOYQkUeXzNH6U,17434
+zoomy_core/model/models/shallow_moments_variants.py,sha256=yqOywfZj1yh5yneEBjbh06zHouiPEA7d-iR5zPap-1Q,52091
+zoomy_core/model/models/shallow_water.py,sha256=j3WwmAxVvF1YzyLBg5sUdERxk2yk4j0pywfkViJyO2o,8452
+zoomy_core/model/models/shallow_water_topo.py,sha256=vQKRBJwLBuYuFWtZXPfQwAeas0qhH1FMBnin6KVmTFg,3495
+zoomy_core/model/models/shear_shallow_flow.py,sha256=kB-EjPLwPxx265cDDA4fobFZwKBfGPlScBTGTfZH_T4,17266
+zoomy_core/model/models/sme_turbulent.py,sha256=GavPnWjfCsqmwA5T814hskQHfe0FI4_ha2cxw2fPYh8,24080
+zoomy_core/model/models/swe_old.py,sha256=xrMIi3HTe0SUMr54ENwxlQg7UuTMVeS1Q2ebEWdsD08,31773
+zoomy_core/model/models/vam.py,sha256=4b-79jy6k-oPePjf6SE6ddJPd5NHTiPKtQfn6Z-qERo,15138
+zoomy_core/postprocessing/postprocessing.py,sha256=AratOPHlinDZEx2atCMO_sOsVdzDX9X8lVc-3sR9Vks,2846
+zoomy_core/preprocessing/openfoam_moments.py,sha256=IuqZNyB7uXFnfateFV8au6kUT1tymS3GL6aoBQLyU7k,14708
+zoomy_core/transformation/helpers.py,sha256=wsuAC7FX5aX0q9eYkAvl_3LOvkTn7csZMfqzHNbmztI,923
+zoomy_core/transformation/to_amrex.py,sha256=lLy0vWJCFWpVeoRxCF2KlQIIGt1HYifKIAgpthhcCIU,9617
+zoomy_core/transformation/to_c.py,sha256=a_22vacgMvSZTCsrr1XAZqD0SqVYgKbp25HnoBBZxjE,7198
+zoomy_core/transformation/to_jax.py,sha256=XlGqqpJpIyt9UMZhfNJPndjOTQviS2a-goAD6wifdTk,403
+zoomy_core/transformation/to_numpy.py,sha256=SqT1QKujMB0L_BtV0aaGVyEFxsg-oRW9q8qVQ6SrBkM,4738
+zoomy_core/transformation/to_openfoam.py,sha256=KykbKVsr6ktPSjG2C1YYr9K1g1Adugd1GVOLymBsf9g,10676
+zoomy_core/transformation/to_ufl.py,sha256=U7NMMo25WK6XF5_9EVocDzQYohzAvSSgxaMOfrkNX9c,1999
+zoomy_core-0.1.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+zoomy_core-0.1.2.dist-info/METADATA,sha256=YXxI-Q8zW_jNnVPqdYPFC7En6gEPjHzQQAfoSUozj5M,5519
+zoomy_core-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+zoomy_core-0.1.2.dist-info/top_level.txt,sha256=NCamZmp9nka6uLXNdAbb47vtoiLmvm3uBKvaBuUdfdQ,11
+zoomy_core-0.1.2.dist-info/RECORD,,

zoomy_core-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+zoomy_core

zoomy_core-0.1.0.dist-info/RECORD

@@ -1,5 +0,0 @@
-zoomy_core-0.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-zoomy_core-0.1.0.dist-info/METADATA,sha256=PttAX5FbKRiBycnZDdkXuDOYyadoSBeXe743B4A6_gE,5519
-zoomy_core-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-zoomy_core-0.1.0.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-zoomy_core-0.1.0.dist-info/RECORD,,

zoomy_core-0.1.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-