zoomy-core 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

{zoomy_core-0.1.2.dist-info → zoomy_core-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zoomy_core
-Version: 0.1.2
+Version: 0.1.4
 Summary: A simulation software for dimensionally-reduced free surface flows.
 Author-email: Ingo Steldermann <steldermann@mbd.rwth-aachen.de>
 License: GNU
@@ -20,6 +20,7 @@ Requires-Dist: attrs
 Requires-Dist: sympy>=1.13.3
 Requires-Dist: numpy
 Requires-Dist: scipy
+Requires-Dist: loguru
 Provides-Extra: gui
 Requires-Dist: pyvista; extra == "gui"
 Requires-Dist: trame; extra == "gui"

{zoomy_core-0.1.2.dist-info → zoomy_core-0.1.4.dist-info}/RECORD

@@ -1,17 +1,16 @@
+zoomy_core/__init__.py,sha256=Gur2AV4_XwhwlIzdBX-E5BBQhw9KZVPo2xpbQMOYaH4,216
 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.py,sha256=gS1nbtksShi8a8BAvVl6LV2KT7cTQjr80hWe0VvsbbY,50110
 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/io.py,sha256=rK1k6Aftab-u9uHmyRRRIXWn9BSnRJvzXLWYp0KX1Mg,14524
 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
@@ -27,7 +26,6 @@ zoomy_core/model/models/basisfunctions.py,sha256=ZHeQYXwgpB8YAZ-8l3NYYvi8CSuvFzJ
 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
@@ -37,7 +35,6 @@ zoomy_core/model/models/shallow_water.py,sha256=j3WwmAxVvF1YzyLBg5sUdERxk2yk4j0p
 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
@@ -48,8 +45,8 @@ zoomy_core/transformation/to_jax.py,sha256=XlGqqpJpIyt9UMZhfNJPndjOTQviS2a-goAD6
 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.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+zoomy_core-0.1.4.dist-info/METADATA,sha256=dIbZjruTgFqrWeQmCDOqwwiBbACPF0nJ-ft-7pJwcx4,5541
+zoomy_core-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+zoomy_core-0.1.4.dist-info/top_level.txt,sha256=NCamZmp9nka6uLXNdAbb47vtoiLmvm3uBKvaBuUdfdQ,11
+zoomy_core-0.1.4.dist-info/RECORD,,

zoomy_core/mesh/gmsh_loader.py

@@ -1,301 +0,0 @@
-## DISCLAIMER: This file is a modified version of the mesh2xdmf converter used in dolfin (https://github.com/floiseau/msh2xdmf)
-## Modifications:
-## - should carry the boundary condition name as a tag, to be identifyable by name
-## - allow for more element types
-
-# import argparse
-import meshio
-import os
-import numpy as np
-
-# from configparser import ConfigParser
-# from compas.datastructures import Mesh as MeshCompas
-import h5py
-
-from library.zoomy_core.mesh.mesh_util import get_global_cell_index_from_vertices
-
-
-def gmsh_to_domain_boundary_mesh(mesh_name, mesh_type="triangle", directory="."):
-    """
-    Function converting a MSH mesh into XDMF files.
-    The XDMF files are:
-        - "domain.xdmf": the domain;
-        - "boundaries.xdmf": the boundaries physical groups from GMSH;
-    """
-    # Set cell type
-    if mesh_type == "triangle":
-        cell_type = "triangle"
-        dim = 2
-    elif mesh_type == "quad":
-        cell_type = "quad"
-        dim = 2
-    elif mesh_type == "tetra":
-        cell_type = "tetra"
-        dim = 3
-    else:
-        assert False
-
-    # Get the mesh name has prefix
-    prefix = mesh_name.split(".")[0]
-    # Read the input mesh
-    msh = meshio.read("{}/{}".format(directory, mesh_name))
-
-    gmsh_association_table = _get_association_table(msh, prefix, directory)
-    # Generate the domain as cells_points
-    domain = export_domain(msh, mesh_type, directory, prefix)
-    # msh = fvm_mesh.Mesh.load_cell_point_mesh(cells, points, cell_type, dim, [] )
-    # compas_msh = MeshCompas.from_vertices_and_faces(points, cells)
-    # (
-    #     dimension,
-    #     type,
-    #     n_elements,
-    #     n_vertices,
-    #     n_edges,
-    #     n_nodes_per_element,
-    #     vertex_coordinates,
-    #     element_vertices,
-    #     element_edge_length,
-    #     element_centers,
-    #     element_volume,
-    #     element_incircle,
-    #     element_edge_normal,
-    #     element_neighbors,
-    #     element_n_neighbors,
-    # ) = fvm_mesh.Mesh.from_comas_mesh_volume(compas_msh, mesh_type, dim)
-
-    # Generate the boundaries as cells points
-    boundaries = export_boundaries(
-        msh, mesh_type, directory, prefix, gmsh_association_table
-    )
-    # compas_msh = MeshCompas.from_vertices_and_faces(points, cells)
-    # runtime_boundaries_mesh = fvm_mesh.Mesh.from_comas_mesh_boundaries(compas_msh, mesh_type, dim)
-    return domain, boundaries
-
-
-def export_domain(msh, mesh_type, directory, prefix):
-    """
-    Export the domain as well as the subdomains values. Export types are
-    - write to XDMF file
-    - return (simple) cells and point data. Simple means only one (the first) element type is returned.
-    """
-    # Set cell type
-    if mesh_type == "triangle":
-        cell_type = "triangle"
-        dim = 2
-    elif mesh_type == "quad":
-        cell_type = "quad"
-        dim = 2
-    elif mesh_type == "tetra":
-        cell_type = "tetra"
-        dim = 3
-    else:
-        assert False
-    # Generate the cell block for the domain cells
-    data_array = []
-    for obj in msh.cells:
-        if obj.type == cell_type:
-            data_array.append(obj.data)
-    # data_array = [arr for (t, arr) in msh.cells if t == cell_type]
-    if len(data_array) == 0:
-        print("WARNING: No domain physical group found.")
-        return
-    else:
-        data = np.concatenate(data_array)
-    cells = [
-        meshio.CellBlock(
-            cell_type=cell_type,
-            data=data,
-        )
-    ]
-    # Generate a meshio Mesh for the domain
-    domain = meshio.Mesh(
-        points=msh.points[:, :],
-        cells=cells,
-        # cell_data=cell_data,
-    )
-
-    return domain
-
-
-def export_boundaries(msh, mesh_type, directory, prefix, gmsh_association_table):
-    """
-    Export the boundaries XDMF file.
-    """
-    # Set the cell type
-    if mesh_type == "triangle":
-        cell_type = "line"
-        dim = 2
-    elif mesh_type == "quad":
-        cell_type = "line"
-        dim = 2
-    elif mesh_type == "tetra":
-        cell_type = "triangle"
-        dim = 3
-    else:
-        assert False
-    # Generate the cell block for the boundaries cells
-    # data_array = [arr for (t, arr) in msh.cells if t == cell_type]
-    offset = 0
-    data = []
-    tags = []
-    corresponding_cells = []
-
-    sort_order_list = []
-    for i, (cellBlock, physical_tag_ids) in enumerate(
-        zip(msh.cells, msh.cell_data["gmsh:physical"])
-    ):
-        if cellBlock.type == cell_type:
-            data.append(cellBlock.data)
-            tags.append([gmsh_association_table[tag_id] for tag_id in physical_tag_ids])
-            corresponding_cells.append(
-                _get_boundary_edges_cells(msh, cellBlock.data, mesh_type)
-            )
-            sort_order_list.append(
-                (offset)
-                + _sort_order_for_periodic_boundary_conditions(
-                    dim, msh.points, cellBlock.data
-                )
-            )
-            offset += cellBlock.data.shape[0]
-
-    if len(data) == 0:
-        print("WARNING: No boundary physical group found.")
-        return
-    else:
-        data = np.concatenate(data)
-        tags = np.concatenate(tags)
-        corresponding_cells = np.concatenate(corresponding_cells)
-        sort_order = np.concatenate(sort_order_list)
-    boundaries_cells = [
-        meshio.CellBlock(
-            cell_type=cell_type,
-            data=data[sort_order],
-        )
-    ]
-
-    cell_data = {
-        "boundary_tag": [tags[sort_order]],
-        "corresponding_cell": [corresponding_cells[sort_order]],
-    }
-    # Generate the boundaries cells data
-    # cell_data = {
-    #     "boundary_tag": [
-    #         np.concatenate(
-    #             [
-    #                 [ gmsh_association_table[tag_id] for tag_id in msh.cell_data["gmsh:physical"][i] ]
-    #                 for i, cellBlock in enumerate(msh.cells)
-    #                 if cellBlock.type == cell_type
-    #             ]
-    #         )[sort_order]
-    #     ],
-    #     "corresponding_cell": [
-    #         np.concatenate(
-    #             [
-    #                 _get_boundary_edges_cells(msh, cellBlock.data)
-    #                 for i, cellBlock in enumerate(msh.cells)
-    #                 if cellBlock.type == cell_type
-    #             ]
-    #         )[sort_order]
-    #     ]
-    # }
-    # Generate the meshio Mesh for the boundaries physical groups
-    boundaries = meshio.Mesh(
-        points=msh.points[:, :],
-        cells=boundaries_cells,
-        cell_data=cell_data,
-    )
-
-    return boundaries
-
-
-def _sort_order_for_periodic_boundary_conditions(dimension, points, data):
-    edge_coordinates = points[data]
-    center_coordinates = np.array(
-        [np.mean(edge_coordinates[i], axis=0) for i in range(edge_coordinates.shape[0])]
-    )
-    if dimension == 1:
-        indices_sorted = np.lexsort((center_coordinates[:, 0],))
-    elif dimension == 2:
-        indices_sorted = np.lexsort(
-            (
-                center_coordinates[:, 0],
-                center_coordinates[:, 1],
-            )
-        )
-    elif dimension == 3:
-        indices_sorted = np.lexsort(
-            (
-                center_coordinates[:, 0],
-                center_coordinates[:, 1],
-                center_coordinates[:, 2],
-            )
-        )
-    else:
-        assert False
-    return indices_sorted
-
-
-def _get_boundary_edges_cells(msh, list_of_edges, element_type):
-    results = np.empty(len(list_of_edges), dtype=int)
-    for i_edge, edge in enumerate(list_of_edges):
-        # hit = get_global_cell_index_from_vertices(msh.cells[-1].data, edge)
-        offset = 0
-        for cell in msh.cells:
-            if cell.type == element_type:
-                hit = get_global_cell_index_from_vertices(
-                    cell.data, edge, return_first=True, offset=offset
-                )
-                if hit != []:
-                    break
-                offset += cell.data.shape[0]
-        assert hit is not False
-        assert hit is not []
-        results[i_edge] = hit
-    return list(results)
-
-
-def _get_association_table(msh, prefix="mesh", directory=".", verbose=True):
-    """
-    Display the association between the physical group label and the mesh
-    value.
-    """
-    # Create association table
-    association_table = {}
-
-    for label, arrays in msh.cell_sets.items():
-        # Get the index of the array in arrays
-        for i, array in enumerate(arrays):
-            if array.size != 0:
-                index = i
-        # Added check to make sure that the association table
-        # doesn't try to import irrelevant information.
-        if label != "gmsh:bounding_entities":
-            value = msh.cell_data["gmsh:physical"][index][0]
-            # Store the association table in a dictionnary
-            association_table[value] = label
-    return association_table
-
-
-if __name__ == "__main__":
-    # parser = argparse.ArgumentParser()
-    # parser.add_argument(
-    #     "msh_file",
-    #     help="input .msh file",
-    #     type=str,
-    # )
-    # parser.add_argument(
-    #     "-d",
-    #     "--dimension",
-    #     help="dimension of the domain",
-    #     type=int,
-    #     default=2,
-    # )
-    # args = parser.parse_args()
-    # # Get current directory
-    # current_directory = os.getcwd()
-    # # Conert the mesh
-    # msh2xdmf(args.msh_file, args.dimension, directory=current_directory)
-    # msh2xdmf('./meshes/tetra_3d/mesh.msh', 'tetra', './')
-    # msh2xdmf('./meshes/tetra_3d/test.msh', 'tetra', './')
-    # msh2runtime_fvm_mesh_simple('./meshes/tetra_3d/test.msh', 'tetra', './')
-    msh2runtime_fvm_mesh_simple("./meshes/quad_2d/mesh_coarse.msh", "quad", "./")

zoomy_core/misc/gui.py

@@ -1,61 +0,0 @@
-# go though all files in curent directory
-# check the docstring of all functions and classes in thhese files
-# parse the docstring using the docstring_parser module and print out all gui tags
-
-import os
-import inspect
-from docstring_parser.rest import parse
-import yaml
-
-import importlib.util
-
-
-def import_module_from_path(path):
-    spec = importlib.util.spec_from_file_location(
-        os.path.splitext(os.path.basename(path))[0], path
-    )
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
-# Go through all files in library
-# go though all files and files of subdirectories until you find a .py file
-def browse_all_gui_tags(path):
-    for root, dirs, files in os.walk(path):
-        for file in files:
-            get_gui_tags(os.path.join(root, file))
-        for dir in dirs:
-            browse_all_gui_tags(os.path.join(root, dir))
-
-
-def get_gui_tags(path):
-    # Import the module
-    if not path.endswith(".py"):
-        return
-    try:
-        module = import_module_from_path(path)
-
-        # Check the docstring of all functions and classes in these files
-        for name, obj in inspect.getmembers(module):
-            if (
-                inspect.isfunction(obj) or inspect.isclass(obj)
-            ) and obj.__module__ == module.__name__:
-                docstring = inspect.getdoc(obj)
-                if docstring:
-                    # Parse the docstring using the docstring_parser module
-                    parsed_docstring = parse(docstring)
-
-                    # Print out all 'gui' tags
-                    for meta in parsed_docstring.meta:
-                        if meta.args == ["gui"]:
-                            yml = yaml.safe_load(meta.description)
-                            print(os.path.basename(path), obj.__name__, yml)
-    except:
-        print(f"Could not import module from {path}")
-        pass
-
-
-if __name__ == "__main__":
-    main_dir = os.getenv("ZOOMY_DIR")
-    browse_all_gui_tags(os.path.join(main_dir, "library"))