cardiac-geometriesx 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

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
@@ -12,13 +13,307 @@ from structlog import get_logger
 
 logger = get_logger()
 
+quads = ("Quadrature", "Q", "Quad", "quadrature", "q", "quad")
+QUADNR = 42
 
-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)],
-        dtype=np.uint8,
+
+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 parse_element(space_string: str, mesh: dolfinx.mesh.Mesh, dim: int) -> basix.ufl._ElementBase:
+    """
+    Parse a string representation of a basix element family
+    """
+
+    family_str, degree_str = space_string.split("_")
+    kwargs = {"degree": int(degree_str), "cell": mesh.ufl_cell().cellname()}
+    if dim > 1:
+        if family_str in quads:
+            kwargs["value_shape"] = (dim,)
+        else:
+            kwargs["shape"] = (dim,)
+
+    if family_str in ["Lagrange", "P", "CG"]:
+        el = basix.ufl.element(family=basix.ElementFamily.P, discontinuous=False, **kwargs)
+    elif family_str in ["Discontinuous Lagrange", "DG", "dP"]:
+        el = basix.ufl.element(family=basix.ElementFamily.P, discontinuous=True, **kwargs)
+
+    elif family_str in quads:
+        el = basix.ufl.quadrature_element(scheme="default", **kwargs)
+    else:
+        families = list(basix.ElementFamily.__members__.keys())
+        msg = f"Unknown element family: {family_str!r}, available families: {families}"
+        raise ValueError(msg)
+    return el
+
+
+def space_from_string(
+    space_string: str, mesh: dolfinx.mesh.Mesh, dim: int
+) -> dolfinx.fem.functionspace:
+    """
+    Constructed a finite elements space from a string
+    representation of the space
+
+    Arguments
+    ---------
+    space_string : str
+        A string on the form {family}_{degree} which
+        determines the space. Example 'Lagrange_1'.
+    mesh : df.Mesh
+        The mesh
+    dim : int
+        1 for scalar space, 3 for vector space.
+    """
+    el = parse_element(space_string, mesh, dim)
+    return dolfinx.fem.functionspace(mesh, el)
+
+
+def element2array(el: basix.ufl._BlockedElement) -> np.ndarray:
+    if el.family_name in quads:
+        return np.array(
+            [QUADNR, int(el.cell_type), int(el.degree), 0],
+            dtype=np.uint8,
+        )
+    else:
+        return np.array(
+            [
+                int(el.basix_element.family),
+                int(el.cell_type),
+                int(el.degree),
+                int(el.basix_element.discontinuous),
+            ],
+            dtype=np.uint8,
+        )
+
 
 def number2Enum(num: int, enum: Iterable) -> Enum:
     for e in enum:
@@ -28,18 +323,24 @@ def number2Enum(num: int, enum: Iterable) -> Enum:
 
 
 def array2element(arr: np.ndarray) -> basix.finite_element.FiniteElement:
-    family = number2Enum(arr[0], basix.ElementFamily)
     cell_type = number2Enum(arr[1], basix.CellType)
     degree = int(arr[2])
     discontinuous = bool(arr[3])
-    # TODO: Shape is hardcoded to (3,) for now, but this should also be stored
-    return basix.ufl.element(
-        family=family,
-        cell=cell_type,
-        degree=degree,
-        discontinuous=discontinuous,
-        shape=(3,),
-    )
+    if arr[0] == QUADNR:
+        return basix.ufl.quadrature_element(
+            scheme="default", degree=degree, value_shape=(3,), cell=cell_type
+        )
+    else:
+        family = number2Enum(arr[0], basix.ElementFamily)
+
+        # TODO: Shape is hardcoded to (3,) for now, but this should also be stored
+        return basix.ufl.element(
+            family=family,
+            cell=cell_type,
+            degree=degree,
+            discontinuous=discontinuous,
+            shape=(3,),
+        )
 
 
 def handle_mesh_name(mesh_name: str = "") -> Path:
@@ -69,13 +370,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 +401,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.2.0.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.