cardiac-geometriesx 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

cardiac_geometries/cli.py

@@ -8,8 +8,10 @@ from . import mesh
 
 meta = metadata("cardiac-geometriesx")
 __version__ = meta["Version"]
-__author__ = meta["Author"]
+__author__ = meta["Author-email"]
 __license__ = meta["License"]
+__email__ = meta["Author-email"]
+__program_name__ = meta["Name"]
 
 
 @click.group()

cardiac_geometries/fibers/lv_ellipsoid.py

@@ -131,9 +131,11 @@ def create_microstructure(
     )
 
     if outdir is not None:
-        with dolfinx.io.XDMFFile(mesh.comm, Path(outdir) / "laplace.xdmf", "w") as file:
-            file.write_mesh(mesh)
-            file.write_function(t)
+        with dolfinx.io.VTXWriter(
+            mesh.comm, Path(outdir) / "laplace.bp", [t], engine="BP4"
+        ) as file:
+            file.write(0.0)
+
     system = compute_system(
         t,
         function_space=function_space,

cardiac_geometries/fibers/slab.py

@@ -134,9 +134,10 @@ def create_microstructure(
         function_space=function_space,
     )
     if outdir is not None:
-        with dolfinx.io.XDMFFile(mesh.comm, Path(outdir) / "laplace.xdmf", "w") as file:
-            file.write_mesh(mesh)
-            file.write_function(t)
+        with dolfinx.io.VTXWriter(
+            mesh.comm, Path(outdir) / "laplace.bp", [t], engine="BP4"
+        ) as file:
+            file.write(0.0)
 
     system = compute_system(
         t,

cardiac_geometries/fibers/utils.py

@@ -20,9 +20,11 @@ def save_microstructure(
     from ..utils import element2array
 
     # Save for paraview visualization
-    with dolfinx.io.VTXWriter(mesh.comm, Path(outdir) / "microstructure-viz.bp", functions, engine="BP4") as file:
+    with dolfinx.io.VTXWriter(
+        mesh.comm, Path(outdir) / "microstructure-viz.bp", functions, engine="BP4"
+    ) as file:
         file.write(0.0)
-        
+
     # Save with proper function space
     filename = Path(outdir) / "microstructure.bp"
     for function in functions:

cardiac_geometries/geometry.py

@@ -12,12 +12,14 @@ import numpy as np
 from . import utils
 
 
-@dataclass#(frozen=True, slots=True)
+@dataclass  # (frozen=True, slots=True)
 class Geometry:
     mesh: dolfinx.mesh.Mesh
-    markers: dict[str, tuple[str, str]] = field(default_factory=dict)
-    ffun: dolfinx.mesh.MeshTags | None = None
+    markers: dict[str, tuple[int, int]] = field(default_factory=dict)
     cfun: dolfinx.mesh.MeshTags | None = None
+    ffun: dolfinx.mesh.MeshTags | None = None
+    efun: dolfinx.mesh.MeshTags | None = None
+    vfun: dolfinx.mesh.MeshTags | None = None
     f0: dolfinx.fem.Function | None = None
     s0: dolfinx.fem.Function | None = None
     n0: dolfinx.fem.Function | None = None
@@ -25,8 +27,7 @@ class Geometry:
     def save(self, path: str | Path) -> None:
         path = Path(path)
 
-        if path.exists() and self.mesh.comm.rank == 0:
-            shutil.rmtree(path)
+        shutil.rmtree(path, ignore_errors=True)
         self.mesh.comm.barrier()
         adios4dolfinx.write_mesh(mesh=self.mesh, filename=path)
 
@@ -37,11 +38,33 @@ class Geometry:
             attributes={k: np.array(v, dtype=np.uint8) for k, v in self.markers.items()},
         )
 
+        if self.cfun is not None:
+            adios4dolfinx.write_meshtags(
+                meshtags=self.cfun,
+                mesh=self.mesh,
+                filename=path,
+                meshtag_name="Cell tags",
+            )
         if self.ffun is not None:
             adios4dolfinx.write_meshtags(
                 meshtags=self.ffun,
                 mesh=self.mesh,
                 filename=path,
+                meshtag_name="Facet tags",
+            )
+        if self.efun is not None:
+            adios4dolfinx.write_meshtags(
+                meshtags=self.efun,
+                mesh=self.mesh,
+                filename=path,
+                meshtag_name="Edge tags",
+            )
+        if self.vfun is not None:
+            adios4dolfinx.write_meshtags(
+                meshtags=self.vfun,
+                mesh=self.mesh,
+                filename=path,
+                meshtag_name="Vertex tags",
             )
 
         if self.f0 is not None:
@@ -60,26 +83,49 @@ class Geometry:
         if self.n0 is not None:
             adios4dolfinx.write_function(u=self.n0, filename=path, name="n0")
 
+        self.mesh.comm.barrier()
+
     @classmethod
     def from_file(cls, comm: MPI.Intracomm, path: str | Path) -> "Geometry":
         path = Path(path)
+
         mesh = adios4dolfinx.read_mesh(comm=comm, filename=path)
         markers = adios4dolfinx.read_attributes(comm=comm, filename=path, name="markers")
-        ffun = adios4dolfinx.read_meshtags(mesh=mesh, meshtag_name="Facet tags", filename=path)
+        tags = {}
+        for name, meshtag_name in (
+            ("cfun", "Cell tags"),
+            ("ffun", "Facet tags"),
+            ("efun", "Edge tags"),
+            ("vfun", "Vertex tags"),
+        ):
+            try:
+                tags[name] = adios4dolfinx.read_meshtags(
+                    mesh=mesh, meshtag_name=meshtag_name, filename=path
+                )
+            except KeyError:
+                tags[name] = None
+
+        functions = {}
         function_space = adios4dolfinx.read_attributes(
             comm=comm, filename=path, name="function_space"
         )
-        element = utils.array2element(function_space["f0"])
-        # Assume same function space for all functions
-        V = dolfinx.fem.functionspace(mesh, element)
-        f0 = dolfinx.fem.Function(V, name="f0")
-        s0 = dolfinx.fem.Function(V, name="s0")
-        n0 = dolfinx.fem.Function(V, name="n0")
-
-        adios4dolfinx.read_function(u=f0, filename=path, name="f0")
-        adios4dolfinx.read_function(u=s0, filename=path, name="s0")
-        adios4dolfinx.read_function(u=n0, filename=path, name="n0")
-        return cls(mesh=mesh, markers=markers, ffun=ffun, f0=f0, s0=s0, n0=n0)
+        for name, el in function_space.items():
+            element = utils.array2element(el)
+            V = dolfinx.fem.functionspace(mesh, element)
+            f = dolfinx.fem.Function(V, name=name)
+            try:
+                adios4dolfinx.read_function(u=f, filename=path, name=name)
+            except KeyError:
+                continue
+            else:
+                functions[name] = f
+
+        return cls(
+            mesh=mesh,
+            markers=markers,
+            **functions,
+            **tags,
+        )
 
     @classmethod
     def from_folder(cls, comm: MPI.Intracomm, folder: str | Path) -> "Geometry":
@@ -87,7 +133,7 @@ class Geometry:
 
         # Read mesh
         if (folder / "mesh.xdmf").exists():
-            mesh, cfun, ffun = utils.read_mesh(comm=comm, filename=folder / "mesh.xdmf")
+            mesh, tags = utils.read_mesh(comm=comm, filename=folder / "mesh.xdmf")
         else:
             raise ValueError("No mesh file found")
 
@@ -101,22 +147,26 @@ class Geometry:
         else:
             markers = {}
 
+        functions = {}
         microstructure_path = folder / "microstructure.bp"
         if microstructure_path.exists():
             function_space = adios4dolfinx.read_attributes(
                 comm=MPI.COMM_WORLD, filename=microstructure_path, name="function_space"
             )
-            # Assume same function space for all functions
-            element = utils.array2element(function_space["f0"])
-            V = dolfinx.fem.functionspace(mesh, element)
-            f0 = dolfinx.fem.Function(V, name="f0")
-            s0 = dolfinx.fem.Function(V, name="s0")
-            n0 = dolfinx.fem.Function(V, name="n0")
-
-            adios4dolfinx.read_function(u=f0, filename=microstructure_path, name="f0")
-            adios4dolfinx.read_function(u=s0, filename=microstructure_path, name="s0")
-            adios4dolfinx.read_function(u=n0, filename=microstructure_path, name="n0")
-        else:
-            f0 = s0 = n0 = None
-
-        return cls(mesh=mesh, ffun=ffun, cfun=cfun, markers=markers, f0=f0, s0=s0, n0=n0)
+            for name, el in function_space.items():
+                element = utils.array2element(el)
+                V = dolfinx.fem.functionspace(mesh, element)
+                f = dolfinx.fem.Function(V, name=name)
+                try:
+                    adios4dolfinx.read_function(u=f, filename=microstructure_path, name=name)
+                except KeyError:
+                    continue
+                else:
+                    functions[name] = f
+
+        return cls(
+            mesh=mesh,
+            markers=markers,
+            **functions,
+            **tags,
+        )

cardiac_geometries/mesh.py

@@ -40,8 +40,8 @@ def biv_ellipsoid(
     b_epi_rv: float = 2.5,
     c_epi_rv: float = 2.0,
     create_fibers: bool = False,
-    fiber_angle_endo: float = -60,
-    fiber_angle_epi: float = +60,
+    fiber_angle_endo: float = 60,
+    fiber_angle_epi: float = -60,
     fiber_space: str = "P_1",
     verbose: bool = False,
 ) -> Geometry:
@@ -92,9 +92,9 @@ def biv_ellipsoid(
     create_fibers : bool, optional
         If True create analytic fibers, by default False
     fiber_angle_endo : float, optional
-        Angle for the endocardium, by default -60
+        Angle for the endocardium, by default 60
     fiber_angle_epi : float, optional
-        Angle for the epicardium, by default +60
+        Angle for the epicardium, by default -60
     fiber_space : str, optional
         Function space for fibers of the form family_degree, by default "P_1"
     verbose : bool, optional
@@ -102,7 +102,7 @@ def biv_ellipsoid(
 
     Returns
     -------
-    Geometry
+    cardiac_geometries.geometry.Geometry
         A Geometry with the mesh, markers, markers functions and fibers.
 
     """
@@ -178,7 +178,30 @@ def biv_ellipsoid(
             json.dump(geometry.markers, f, default=utils.json_serial)
     comm.barrier()
     if create_fibers:
-        raise NotImplementedError("Fibers not implemented yet for biv ellipsoid.")
+        try:
+            import ldrb
+        except ImportError:
+            msg = (
+                "To create fibers you need to install the ldrb package "
+                "which you can install with pip install fenicsx-ldrb"
+            )
+            raise ImportError(msg)
+
+        system = ldrb.dolfinx_ldrb(
+            mesh=geometry.mesh,
+            ffun=geometry.ffun,
+            markers=geometry.markers,
+            alpha_endo_lv=fiber_angle_endo,
+            alpha_epi_lv=fiber_angle_epi,
+            beta_endo_lv=0,
+            beta_epi_lv=0,
+            fiber_space=fiber_space,
+        )
+        from .fibers.utils import save_microstructure
+
+        save_microstructure(
+            mesh=geometry.mesh, functions=(system.f0, system.s0, system.n0), outdir=outdir
+        )
         # from .fibers._biv_ellipsoid import create_biv_fibers
 
         # create_biv_fibers(
@@ -222,8 +245,8 @@ def biv_ellipsoid_torso(
     b_epi_rv: float = 2.5,
     c_epi_rv: float = 2.0,
     create_fibers: bool = False,
-    fiber_angle_endo: float = -60,
-    fiber_angle_epi: float = +60,
+    fiber_angle_endo: float = 60,
+    fiber_angle_epi: float = -60,
     fiber_space: str = "P_1",
     verbose: bool = False,
 ) -> Geometry:
@@ -286,9 +309,9 @@ def biv_ellipsoid_torso(
     create_fibers : bool, optional
         If True create analytic fibers, by default False
     fiber_angle_endo : float, optional
-        Angle for the endocardium, by default -60
+        Angle for the endocardium, by default 60
     fiber_angle_epi : float, optional
-        Angle for the epicardium, by default +60
+        Angle for the epicardium, by default -60
     fiber_space : str, optional
         Function space for fibers of the form family_degree, by default "P_1"
     verbose : bool, optional
@@ -296,7 +319,7 @@ def biv_ellipsoid_torso(
 
     Returns
     -------
-    Geometry
+    cardiac_geometries.geometry.Geometry
         A Geometry with the mesh, markers, markers functions and fibers.
 
     """
@@ -417,8 +440,8 @@ def lv_ellipsoid(
     mu_apex_epi: float = -math.pi,
     mu_base_epi: float = -math.acos(5 / 20),
     create_fibers: bool = False,
-    fiber_angle_endo: float = -60,
-    fiber_angle_epi: float = +60,
+    fiber_angle_endo: float = 60,
+    fiber_angle_epi: float = -60,
     fiber_space: str = "P_1",
     aha: bool = True,
     verbose: bool = False,
@@ -450,9 +473,9 @@ def lv_ellipsoid(
     create_fibers : bool, optional
         If True create analytic fibers, by default False
     fiber_angle_endo : float, optional
-        Angle for the endocardium, by default -60
+        Angle for the endocardium, by default 60
     fiber_angle_epi : float, optional
-        Angle for the epicardium, by default +60
+        Angle for the epicardium, by default -60
     fiber_space : str, optional
         Function space for fibers of the form family_degree, by default "P_1"
     aha : bool, optional
@@ -462,7 +485,7 @@ def lv_ellipsoid(
 
     Returns
     -------
-    Geometry
+    cardiac_geometries.geometry.Geometry
         A Geometry with the mesh, markers, markers functions and fibers.
 
     """
@@ -569,8 +592,8 @@ def slab(
     lz: float = 3.0,
     dx: float = 1.0,
     create_fibers: bool = True,
-    fiber_angle_endo: float = -60,
-    fiber_angle_epi: float = +60,
+    fiber_angle_endo: float = 60,
+    fiber_angle_epi: float = -60,
     fiber_space: str = "P_1",
     verbose: bool = False,
 ) -> Geometry:
@@ -591,9 +614,9 @@ def slab(
     create_fibers : bool, optional
         If True create analytic fibers, by default True
     fiber_angle_endo : float, optional
-        Angle for the endocardium, by default -60
+        Angle for the endocardium, by default 60
     fiber_angle_epi : float, optional
-        Angle for the epicardium, by default +60
+        Angle for the epicardium, by default -60
     fiber_space : str, optional
         Function space for fibers of the form family_degree, by default "P_1"
     verbose : bool, optional
@@ -601,7 +624,7 @@ def slab(
 
     Returns
     -------
-    Geometry
+    cardiac_geometries.geometry.Geometry
         A Geometry with the mesh, markers, markers functions and fibers.
 
     """
@@ -701,7 +724,7 @@ def slab_in_bath(
 
     Returns
     -------
-    Geometry
+    cardiac_geometries.geometry.Geometry
         A Geometry with the mesh, markers, markers functions and fibers.
 
     """

cardiac_geometries/utils.py

@@ -1,4 +1,5 @@
 import tempfile
+import typing
 from enum import Enum
 from pathlib import Path
 from typing import Iterable, NamedTuple
@@ -13,6 +14,238 @@ from structlog import get_logger
 logger = get_logger()
 
 
+class GMshModel(NamedTuple):
+    mesh: dolfinx.mesh.Mesh
+    cell_tags: dolfinx.mesh.MeshTags
+    facet_tags: dolfinx.mesh.MeshTags
+    edge_tags: dolfinx.mesh.MeshTags
+    vertex_tags: dolfinx.mesh.MeshTags
+
+
+# copied from https://github.com/FEniCS/dolfinx/blob/main/python/dolfinx/io/gmshio.py
+def model_to_mesh(
+    model,
+    comm: MPI.Comm,
+    rank: int,
+    gdim: int = 3,
+    partitioner: typing.Optional[
+        typing.Callable[
+            [MPI.Comm, int, int, dolfinx.cpp.graph.AdjacencyList_int32],
+            dolfinx.cpp.graph.AdjacencyList_int32,
+        ]
+    ] = None,
+    dtype=dolfinx.default_real_type,
+) -> GMshModel:
+    """Create a Mesh from a Gmsh model.
+
+    Creates a :class:`dolfinx.mesh.Mesh` from the physical entities of
+    the highest topological dimension in the Gmsh model. In parallel,
+    the gmsh model is processed on one MPI rank, and the
+    :class:`dolfinx.mesh.Mesh` is distributed across ranks.
+
+    Args:
+        model: Gmsh model.
+        comm: MPI communicator to use for mesh creation.
+        rank: MPI rank that the Gmsh model is initialized on.
+        gdim: Geometrical dimension of the mesh.
+        partitioner: Function that computes the parallel
+            distribution of cells across MPI ranks.
+
+    Returns:
+        A tuple containing the :class:`dolfinx.mesh.Mesh` and
+        :class:`dolfinx.mesh.MeshTags` for cells, facets, edges and
+        vertices.
+
+
+    Note:
+        For performance, this function should only be called once for
+        large problems. For re-use, it is recommended to save the mesh
+        and corresponding tags using :class:`dolfinxio.XDMFFile` after
+        creation for efficient access.
+
+    """
+    if comm.rank == rank:
+        assert model is not None, "Gmsh model is None on rank responsible for mesh creation."
+        # Get mesh geometry and mesh topology for each element
+        x = dolfinx.io.gmshio.extract_geometry(model)
+        topologies = dolfinx.io.gmshio.extract_topology_and_markers(model)
+
+        # Extract Gmsh cell id, dimension of cell and number of nodes to
+        # cell for each
+        num_cell_types = len(topologies.keys())
+        cell_information = dict()
+        cell_dimensions = np.zeros(num_cell_types, dtype=np.int32)
+        for i, element in enumerate(topologies.keys()):
+            _, dim, _, num_nodes, _, _ = model.mesh.getElementProperties(element)
+            cell_information[i] = {"id": element, "dim": dim, "num_nodes": num_nodes}
+            cell_dimensions[i] = dim
+
+        # Sort elements by ascending dimension
+        perm_sort = np.argsort(cell_dimensions)
+
+        # Broadcast cell type data and geometric dimension
+        cell_id = cell_information[perm_sort[-1]]["id"]
+        tdim = cell_information[perm_sort[-1]]["dim"]
+        num_nodes = cell_information[perm_sort[-1]]["num_nodes"]
+        cell_id, num_nodes = comm.bcast([cell_id, num_nodes], root=rank)
+
+        # Check for facet data and broadcast relevant info if True
+        has_facet_data = False
+        if tdim - 1 in cell_dimensions:
+            has_facet_data = True
+        has_edge_data = False
+        if tdim - 2 in cell_dimensions:
+            has_edge_data = True
+        has_vertex_data = False
+        if tdim - 3 in cell_dimensions:
+            has_vertex_data = True
+
+        has_facet_data = comm.bcast(has_facet_data, root=rank)
+        if has_facet_data:
+            num_facet_nodes = comm.bcast(cell_information[perm_sort[-2]]["num_nodes"], root=rank)
+            gmsh_facet_id = cell_information[perm_sort[-2]]["id"]
+            marked_facets = np.asarray(topologies[gmsh_facet_id]["topology"], dtype=np.int64)
+            facet_values = np.asarray(topologies[gmsh_facet_id]["cell_data"], dtype=np.int32)
+
+        has_edge_data = comm.bcast(has_edge_data, root=rank)
+        if has_edge_data:
+            num_edge_nodes = comm.bcast(cell_information[perm_sort[-3]]["num_nodes"], root=rank)
+            gmsh_edge_id = cell_information[perm_sort[-3]]["id"]
+            marked_edges = np.asarray(topologies[gmsh_edge_id]["topology"], dtype=np.int64)
+            edge_values = np.asarray(topologies[gmsh_edge_id]["cell_data"], dtype=np.int32)
+
+        has_vertex_data = comm.bcast(has_vertex_data, root=rank)
+        if has_vertex_data:
+            num_vertex_nodes = comm.bcast(cell_information[perm_sort[-4]]["num_nodes"], root=rank)
+            gmsh_vertex_id = cell_information[perm_sort[-4]]["id"]
+            marked_vertices = np.asarray(topologies[gmsh_vertex_id]["topology"], dtype=np.int64)
+            vertex_values = np.asarray(topologies[gmsh_vertex_id]["cell_data"], dtype=np.int32)
+
+        cells = np.asarray(topologies[cell_id]["topology"], dtype=np.int64)
+        cell_values = np.asarray(topologies[cell_id]["cell_data"], dtype=np.int32)
+    else:
+        cell_id, num_nodes = comm.bcast([None, None], root=rank)
+        cells, x = np.empty([0, num_nodes], dtype=np.int32), np.empty([0, gdim], dtype=dtype)
+        cell_values = np.empty((0,), dtype=np.int32)
+
+        has_facet_data = comm.bcast(None, root=rank)
+        if has_facet_data:
+            num_facet_nodes = comm.bcast(None, root=rank)
+            marked_facets = np.empty((0, num_facet_nodes), dtype=np.int32)
+            facet_values = np.empty((0,), dtype=np.int32)
+
+        has_edge_data = comm.bcast(None, root=rank)
+        if has_edge_data:
+            num_edge_nodes = comm.bcast(None, root=rank)
+            marked_edges = np.empty((0, num_edge_nodes), dtype=np.int32)
+            edge_values = np.empty((0,), dtype=np.int32)
+
+        has_vertex_data = comm.bcast(None, root=rank)
+        if has_vertex_data:
+            num_vertex_nodes = comm.bcast(None, root=rank)
+            marked_vertices = np.empty((0, num_vertex_nodes), dtype=np.int32)
+            vertex_values = np.empty((0,), dtype=np.int32)
+
+    # Create distributed mesh
+    ufl_domain = dolfinx.io.gmshio.ufl_mesh(cell_id, gdim, dtype=dtype)
+    gmsh_cell_perm = dolfinx.io.gmshio.cell_perm_array(
+        dolfinx.cpp.mesh.to_type(str(ufl_domain.ufl_cell())), num_nodes
+    )
+    cells = cells[:, gmsh_cell_perm].copy()
+    mesh = dolfinx.mesh.create_mesh(
+        comm, cells, x[:, :gdim].astype(dtype, copy=False), ufl_domain, partitioner
+    )
+
+    # Create MeshTags for cells
+    local_entities, local_values = dolfinx.io.utils.distribute_entity_data(
+        mesh._cpp_object, mesh.topology.dim, cells, cell_values
+    )
+    mesh.topology.create_connectivity(mesh.topology.dim, 0)
+    adj = dolfinx.cpp.graph.AdjacencyList_int32(local_entities)
+    ct = dolfinx.mesh.meshtags_from_entities(
+        mesh, mesh.topology.dim, adj, local_values.astype(np.int32, copy=False)
+    )
+    ct.name = "Cell tags"
+
+    # Create MeshTags for facets
+    topology = mesh.topology
+    tdim = topology.dim
+    if has_facet_data:
+        # Permute facets from MSH to DOLFINx ordering
+        # FIXME: This does not work for prism meshes
+        if (
+            topology.cell_type == dolfinx.mesh.CellType.prism
+            or topology.cell_type == dolfinx.mesh.CellType.pyramid
+        ):
+            raise RuntimeError(f"Unsupported cell type {topology.cell_type}")
+
+        facet_type = dolfinx.cpp.mesh.cell_entity_type(
+            dolfinx.cpp.mesh.to_type(str(ufl_domain.ufl_cell())), tdim - 1, 0
+        )
+        gmsh_facet_perm = dolfinx.io.gmshio.cell_perm_array(facet_type, num_facet_nodes)
+        marked_facets = marked_facets[:, gmsh_facet_perm]
+
+        local_entities, local_values = dolfinx.io.utils.distribute_entity_data(
+            mesh._cpp_object, tdim - 1, marked_facets, facet_values
+        )
+        mesh.topology.create_connectivity(topology.dim - 1, tdim)
+        adj = dolfinx.cpp.graph.AdjacencyList_int32(local_entities)
+        ft = dolfinx.io.gmshio.meshtags_from_entities(
+            mesh, tdim - 1, adj, local_values.astype(np.int32, copy=False)
+        )
+        ft.name = "Facet tags"
+    else:
+        ft = dolfinx.mesh.meshtags(
+            mesh, tdim - 1, np.empty(0, dtype=np.int32), np.empty(0, dtype=np.int32)
+        )
+
+    if has_edge_data:
+        # Permute edges from MSH to DOLFINx ordering
+        edge_type = dolfinx.cpp.mesh.cell_entity_type(
+            dolfinx.cpp.mesh.to_type(str(ufl_domain.ufl_cell())), tdim - 2, 0
+        )
+        gmsh_edge_perm = dolfinx.io.gmshio.cell_perm_array(edge_type, num_edge_nodes)
+        marked_edges = marked_edges[:, gmsh_edge_perm]
+
+        local_entities, local_values = dolfinx.io.utils.distribute_entity_data(
+            mesh._cpp_object, tdim - 2, marked_edges, edge_values
+        )
+        mesh.topology.create_connectivity(topology.dim - 2, tdim)
+        adj = dolfinx.cpp.graph.AdjacencyList_int32(local_entities)
+        et = dolfinx.io.gmshio.meshtags_from_entities(
+            mesh, tdim - 2, adj, local_values.astype(np.int32, copy=False)
+        )
+        et.name = "Edge tags"
+    else:
+        et = dolfinx.mesh.meshtags(
+            mesh, tdim - 2, np.empty(0, dtype=np.int32), np.empty(0, dtype=np.int32)
+        )
+
+    if has_vertex_data:
+        # Permute vertices from MSH to DOLFINx ordering
+        vertex_type = dolfinx.cpp.mesh.cell_entity_type(
+            dolfinx.cpp.mesh.to_type(str(ufl_domain.ufl_cell())), tdim - 3, 0
+        )
+        gmsh_vertex_perm = dolfinx.io.gmshio.cell_perm_array(vertex_type, num_vertex_nodes)
+        marked_vertices = marked_vertices[:, gmsh_vertex_perm]
+
+        local_entities, local_values = dolfinx.io.utils.distribute_entity_data(
+            mesh._cpp_object, tdim - 3, marked_vertices, vertex_values
+        )
+        mesh.topology.create_connectivity(topology.dim - 3, tdim)
+        adj = dolfinx.cpp.graph.AdjacencyList_int32(local_entities)
+        vt = dolfinx.io.gmshio.meshtags_from_entities(
+            mesh, tdim - 3, adj, local_values.astype(np.int32, copy=False)
+        )
+        vt.name = "Vertex tags"
+    else:
+        vt = dolfinx.mesh.meshtags(
+            mesh, tdim - 3, np.empty(0, dtype=np.int32), np.empty(0, dtype=np.int32)
+        )
+
+    return GMshModel(mesh, ct, ft, et, vt)
+
+
 def element2array(el: basix.finite_element.FiniteElement) -> np.ndarray:
     return np.array(
         [int(el.family), int(el.cell_type), int(el.degree), int(el.discontinuous)],
@@ -69,13 +302,23 @@ class GMshGeometry(NamedTuple):
 
 def read_mesh(
     comm, filename: str | Path
-) -> tuple[dolfinx.mesh.Mesh, dolfinx.mesh.MeshTags | None, dolfinx.mesh.MeshTags | None]:
+) -> tuple[dolfinx.mesh.Mesh, dict[str, dolfinx.mesh.MeshTags]]:
+    tags = {}
     with dolfinx.io.XDMFFile(comm, filename, "r") as xdmf:
         mesh = xdmf.read_mesh(name="Mesh")
-        cfun = xdmf.read_meshtags(mesh, name="Cell tags")
-        mesh.topology.create_connectivity(2, 3)
-        ffun = xdmf.read_meshtags(mesh, name="Facet tags")
-    return mesh, cfun, ffun
+        for var, name, dim in [
+            ("cfun", "Cell tags", mesh.topology.dim),
+            ("ffun", "Facet tags", mesh.topology.dim - 1),
+            ("efun", "Edge tags", mesh.topology.dim - 2),
+            ("vfun", "Vertex tags", mesh.topology.dim - 3),
+        ]:
+            mesh.topology.create_connectivity(dim, mesh.topology.dim)
+            try:
+                tags[var] = xdmf.read_meshtags(mesh, name=name)
+            except RuntimeError:
+                continue
+
+    return mesh, tags
 
 
 def gmsh2dolfin(comm: MPI.Intracomm, msh_file, rank: int = 0) -> GMshGeometry:
@@ -90,33 +333,40 @@ def gmsh2dolfin(comm: MPI.Intracomm, msh_file, rank: int = 0) -> GMshGeometry:
         gmsh.initialize()
         gmsh.model.add("Mesh from file")
         gmsh.merge(str(msh_file))
-        mesh, ct, ft = dolfinx.io.gmshio.model_to_mesh(gmsh.model, comm, 0)
+        mesh, ct, ft, et, vt = model_to_mesh(gmsh.model, comm, 0)
         markers = {
             gmsh.model.getPhysicalName(*v): tuple(reversed(v))
             for v in gmsh.model.getPhysicalGroups()
         }
         gmsh.finalize()
     else:
-        mesh, ct, ft = dolfinx.io.gmshio.model_to_mesh(gmsh.model, comm, 0)
+        mesh, ct, ft, et, vt = model_to_mesh(gmsh.model, comm, 0)
         markers = {}
     mesh.name = "Mesh"
     ct.name = "Cell tags"
     ft.name = "Facet tags"
+    et.name = "Edge tags"
+    vt.name = "Vertex tags"
 
     markers = comm.bcast(markers, root=rank)
 
     # Save tags to xdmf
     with dolfinx.io.XDMFFile(comm, outdir / "mesh.xdmf", "w") as xdmf:
         xdmf.write_mesh(mesh)
-        mesh.topology.create_connectivity(2, 3)
         xdmf.write_meshtags(
             ct, mesh.geometry, geometry_xpath=f"/Xdmf/Domain/Grid[@Name='{mesh.name}']/Geometry"
         )
+        mesh.topology.create_connectivity(2, 3)
         xdmf.write_meshtags(
             ft, mesh.geometry, geometry_xpath=f"/Xdmf/Domain/Grid[@Name='{mesh.name}']/Geometry"
         )
+        mesh.topology.create_connectivity(1, 3)
+        xdmf.write_meshtags(
+            et, mesh.geometry, geometry_xpath=f"/Xdmf/Domain/Grid[@Name='{mesh.name}']/Geometry"
+        )
+        mesh.topology.create_connectivity(0, 3)
+        xdmf.write_meshtags(
+            vt, mesh.geometry, geometry_xpath=f"/Xdmf/Domain/Grid[@Name='{mesh.name}']/Geometry"
+        )
 
-    vfun = None
-    efun = None
-
-    return GMshGeometry(mesh, ct, ft, efun, vfun, markers)
+    return GMshGeometry(mesh, ct, ft, et, vt, markers)

cardiac_geometriesx-0.1.3.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Computational Physiology at Simula Research Laboratory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cardiac_geometriesx-0.1.3.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.1
+Name: cardiac-geometriesx
+Version: 0.1.3
+Summary: A python library for cardiac geometries
+Author-email: Henrik Finsberg <henriknf@simula.no>
+License: MIT
+Project-URL: Homepage, https://github.com/finsberg/cardiac-geometriesx
+Keywords: cardiac,geometry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fenics-dolfinx >=0.8.0
+Requires-Dist: structlog
+Requires-Dist: cardiac-geometries-core
+Requires-Dist: rich-click
+Requires-Dist: adios4dolfinx
+Provides-Extra: dev
+Requires-Dist: bump-my-version ; extra == 'dev'
+Requires-Dist: ipython ; extra == 'dev'
+Requires-Dist: pdbpp ; extra == 'dev'
+Requires-Dist: pre-commit ; extra == 'dev'
+Requires-Dist: twine ; extra == 'dev'
+Requires-Dist: wheel ; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: jupyter-book ; extra == 'docs'
+Requires-Dist: jupytext ; extra == 'docs'
+Requires-Dist: jupyter ; extra == 'docs'
+Requires-Dist: pyvista[all] >=0.43.0 ; extra == 'docs'
+Requires-Dist: trame-vuetify ; extra == 'docs'
+Requires-Dist: ipywidgets ; extra == 'docs'
+Requires-Dist: fenicsx-ldrb ; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: pre-commit ; extra == 'test'
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: pytest-cov ; extra == 'test'
+
+![_](docs/_static/logo.png)
+
+[![Create and publish a Docker image](https://github.com/ComputationalPhysiology/cardiac-geometriesx/actions/workflows/docker-image.yml/badge.svg)](https://github.com/ComputationalPhysiology/cardiac-geometriesx/actions/workflows/docker-image.yml)
+[![Test package](https://github.com/ComputationalPhysiology/cardiac-geometriesx/actions/workflows/test.yml/badge.svg)](https://github.com/ComputationalPhysiology/cardiac-geometriesx/actions/workflows/test.yml)
+[![Test package MPI](https://github.com/ComputationalPhysiology/cardiac-geometriesx/actions/workflows/test-mpi.yml/badge.svg)](https://github.com/ComputationalPhysiology/cardiac-geometriesx/actions/workflows/test-mpi.yml)
+[![Pre-commit](https://github.com/ComputationalPhysiology/cardiac-geometriesx/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/ComputationalPhysiology/cardiac-geometriesx/actions/workflows/pre-commit.yml)
+[![PyPI version](https://badge.fury.io/py/cardiac-geometriesx.svg)](https://badge.fury.io/py/cardiac-geometriesx)
+
+# Cardiac geometries
+
+Cardiac geometries is a software package built on top of [`cariac-geometries-core`](https://github.com/ComputationalPhysiology/cardiac-geometries-core) that adds support for creating idealized cardiac geometries for dolfinx.
+
+There are two ways you can use `cardiac-geomtries`, either using the command line interface, e.g
+```
+geox lv-ellipsoid --create-fibers lv-mesh --fiber-space P_2
+```
+
+or using the python API e.g
+```python
+geo =  cardiac_geometries.mesh.lv_ellipsoid(outdir="lv-mesh", create_fibers=True, fiber_space="P_2")
+```
+
+## Install
+
+To install the package you can use `pip`
+```
+python3 -m pip install cardiac-geometriesx
+```
+however, this assumes that you already have `dolfinx` pre-installed. You can also use the provided docker image e.g
+```
+docker pull ghcr.io/computationalphysiology/cardiac-geometriesx:latest
+```
+To start a new container interactive you can do
+```
+docker run --name geox -v $PWD:/home/shared -w /home/shared -it ghcr.io/computationalphysiology/cardiac-geometriesx:latest
+```
+or if you just want to create a mesh and exit you can run the command line interface directly e.g
+```
+docker run --rm -v $PWD:/home/shared -w /home/shared -it ghcr.io/computationalphysiology/cardiac-geometriesx:latest geox lv-ellipsoid --create-fibers lv-mesh --fiber-space P_2
+```
+
+## Authors
+Henrik Finsberg (henriknf@simula.no)
+
+## License
+MIT
+
+## Contributing

cardiac_geometriesx-0.1.3.dist-info/RECORD

@@ -0,0 +1,15 @@
+cardiac_geometries/__init__.py,sha256=2W_ywAeLjyRk5MqSPAodHa4UN2lOnW1h8tmGLQ3gaJ0,150
+cardiac_geometries/cli.py,sha256=hOv1muw33MY1GedXnIR1xvh488lWIzRDq29LajK6PY0,19394
+cardiac_geometries/geometry.py,sha256=UWOasa3l7BM1tdr3au5Bu0hPnOe1TyoP8KMMrwtJjyM,5650
+cardiac_geometries/mesh.py,sha256=JSm69BTS7WRUldwaQ9-Gnjq_KbX66FTnl2ouFKRtFhA,26825
+cardiac_geometries/utils.py,sha256=vO9Ov385JBfODH-3exVVgK9xKvAoNLThi_QyiM2w7iE,14312
+cardiac_geometries/fibers/__init__.py,sha256=WpRrn9Iakl-3m8IGtFkqP0LXGjw5EZHZ8Eg9JCnCdrg,137
+cardiac_geometries/fibers/lv_ellipsoid.py,sha256=jdRek3v_V2a9IQHqH7P-lK0JBwa1dUNpBBmABzKGje4,3690
+cardiac_geometries/fibers/slab.py,sha256=h_iVs_e1F9LJaXJOzam336f0LcTAXXBvApsFZGZSnZs,3861
+cardiac_geometries/fibers/utils.py,sha256=hMTAKy32ow10tpNE1-WuvCYk7PVXO1qL0dHPa3LjecQ,2434
+cardiac_geometriesx-0.1.3.dist-info/LICENSE,sha256=lo5K2rJPZOSv6luutGHbzzi3IpXNaB9E2UWq60qvNx0,1111
+cardiac_geometriesx-0.1.3.dist-info/METADATA,sha256=M9ntsIWoEz5VILHZa2nWKMDjvdM25_7QsV9kvvFDFWI,3871
+cardiac_geometriesx-0.1.3.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+cardiac_geometriesx-0.1.3.dist-info/entry_points.txt,sha256=xOBnlc6W-H9oCDYLNz3kpki26OmpfYSoFSrmi_4V-Ec,52
+cardiac_geometriesx-0.1.3.dist-info/top_level.txt,sha256=J0gQxkWR2my5Vf7Qt8buDY8ZOjYdVfIweVunCGXWKNE,19
+cardiac_geometriesx-0.1.3.dist-info/RECORD,,

{cardiac_geometriesx-0.1.1.dist-info → cardiac_geometriesx-0.1.3.dist-info}/WHEEL

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

cardiac_geometriesx-0.1.1.dist-info/METADATA

@@ -1,51 +0,0 @@
-Metadata-Version: 2.1
-Name: cardiac-geometriesx
-Version: 0.1.1
-Summary: A python library for cardiac geometries
-Author-email: Henrik Finsberg <henriknf@simula.no>
-License: MIT
-Project-URL: Homepage, https://github.com/finsberg/cardiac-geometriesx
-Keywords: cardiac,geometry
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: fenics-dolfinx >=0.8.0
-Requires-Dist: structlog
-Requires-Dist: cardiac-geometries-core
-Requires-Dist: rich-click
-Requires-Dist: adios4dolfinx
-Provides-Extra: dev
-Requires-Dist: bump-my-version ; extra == 'dev'
-Requires-Dist: ipython ; extra == 'dev'
-Requires-Dist: pdbpp ; extra == 'dev'
-Requires-Dist: pre-commit ; extra == 'dev'
-Requires-Dist: twine ; extra == 'dev'
-Requires-Dist: wheel ; extra == 'dev'
-Provides-Extra: docs
-Provides-Extra: test
-Requires-Dist: pre-commit ; extra == 'test'
-Requires-Dist: pytest ; extra == 'test'
-Requires-Dist: pytest-cov ; extra == 'test'
-
-
-# Cardiac geometries
-
-Cardiac geometries for `dolfinx` (targeting v0.8).
-
-Install
-```
-python3 -m pip install cardiac-geometriesx
-```
-
-Example usage
-```
-geox lv-ellipsoid --create-fibers lv-mesh
-```
-
-## Authors
-Henrik Finsberg (henriknf@simula.no)
-
-## License
-MIT

cardiac_geometriesx-0.1.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-cardiac_geometries/__init__.py,sha256=2W_ywAeLjyRk5MqSPAodHa4UN2lOnW1h8tmGLQ3gaJ0,150
-cardiac_geometries/cli.py,sha256=2-99xmcBltdotzxp4aDZLrh46gyA5U_PZc6lHen7LIM,19323
-cardiac_geometries/geometry.py,sha256=rhtq219q06ta1ZS_WIyqfjr00rN1L099bfX_Fwhe29g,4656
-cardiac_geometries/mesh.py,sha256=cJAcwdDaYmO8MlfocaxvV6pkBcfEWybMSBAaycr6q3s,25987
-cardiac_geometries/utils.py,sha256=-fH13vimCYrirDZubQdxRpX-7I9iCFsOJ8Xo1NL5Nvc,3596
-cardiac_geometries/fibers/__init__.py,sha256=WpRrn9Iakl-3m8IGtFkqP0LXGjw5EZHZ8Eg9JCnCdrg,137
-cardiac_geometries/fibers/lv_ellipsoid.py,sha256=zcCTcst08-xcG5c2j8rPLFp0cgNjXt1Q0mVGhs5r5Ps,3695
-cardiac_geometries/fibers/slab.py,sha256=-EWG4cHjtFYo4VyoFfVnsbHhfdf8qKWphYimJ1jB56o,3867
-cardiac_geometries/fibers/utils.py,sha256=K_C_G1az_SnwBAeKvvvZN4V4M_6z0DAAqOsV7M3T5aI,2428
-cardiac_geometriesx-0.1.1.dist-info/METADATA,sha256=w_cEg_5ZBV2Ptl9OxH2VN4Psll0wjlLU0WTR4GIaB8o,1349
-cardiac_geometriesx-0.1.1.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-cardiac_geometriesx-0.1.1.dist-info/entry_points.txt,sha256=xOBnlc6W-H9oCDYLNz3kpki26OmpfYSoFSrmi_4V-Ec,52
-cardiac_geometriesx-0.1.1.dist-info/top_level.txt,sha256=J0gQxkWR2my5Vf7Qt8buDY8ZOjYdVfIweVunCGXWKNE,19
-cardiac_geometriesx-0.1.1.dist-info/RECORD,,