cardiac-geometriesx 0.5.1__tar.gz → 0.5.2__tar.gz

{cardiac_geometriesx-0.5.1/src/cardiac_geometriesx.egg-info → cardiac_geometriesx-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cardiac-geometriesx
-Version: 0.5.1
+Version: 0.5.2
 Summary: A python library for cardiac geometries
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT
@@ -77,7 +77,11 @@ 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
+however, this assumes that you already have `dolfinx` pre-installed. You can also use `conda`
+```
+conda install -c conda-forge cardiac-geometriesx
+```
+or the provided docker image
 ```
 docker pull ghcr.io/computationalphysiology/cardiac-geometriesx:latest
 ```

{cardiac_geometriesx-0.5.1 → cardiac_geometriesx-0.5.2}/README.md

@@ -26,7 +26,11 @@ 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
+however, this assumes that you already have `dolfinx` pre-installed. You can also use `conda`
+```
+conda install -c conda-forge cardiac-geometriesx
+```
+or the provided docker image
 ```
 docker pull ghcr.io/computationalphysiology/cardiac-geometriesx:latest
 ```

{cardiac_geometriesx-0.5.1 → cardiac_geometriesx-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cardiac-geometriesx"
-version = "0.5.1"
+version = "0.5.2"
 description = "A python library for cardiac geometries"
 authors = [{name = "Henrik Finsberg", email = "henriknf@simula.no"}]
 license = {text = "MIT"}
@@ -177,7 +177,7 @@ tag = true
 sign_tags = false
 tag_name = "v{new_version}"
 tag_message = "Bump version: {current_version} → {new_version}"
-current_version = "0.5.1"
+current_version = "0.5.2"
 
 
 [[tool.bumpversion.files]]

cardiac_geometriesx-0.5.2/src/cardiac_geometries/fibers/__init__.py

@@ -0,0 +1,66 @@
+import logging
+
+import dolfinx
+
+from . import cylinder, lv_ellipsoid, slab, utils
+from .utils import Microstructure
+
+__all__ = ["lv_ellipsoid", "slab", "cylinder", "utils", "Microstructure"]
+
+logger = logging.getLogger(__name__)
+
+
+supported_mesh_types = ("slab", "cylinder", "lv_ellipsoid", "biv_ellipsoid", "ukb", "lv", "biv")
+
+
+def generate_fibers(mesh_type: str, mesh: dolfinx.mesh.Mesh, **kwargs) -> Microstructure:
+    """Generate fibers based on the mesh type."""
+
+    kwargs = kwargs.copy()
+
+    # Map fiber_angle_endo and fiber_angle_epi to alpha_endo and alpha_epi
+    if "fiber_angle_endo" in kwargs:
+        kwargs["alpha_endo"] = kwargs.pop("fiber_angle_endo")
+    if "fiber_angle_epi" in kwargs:
+        kwargs["alpha_epi"] = kwargs.pop("fiber_angle_epi")
+    if "fiber_space" in kwargs:
+        kwargs["function_space"] = kwargs.pop("fiber_space")
+
+    if mesh_type == "slab":
+        return slab.create_microstructure(mesh, **kwargs)
+    elif mesh_type == "cylinder":
+        return cylinder.create_microstructure(mesh, **kwargs)
+    elif mesh_type == "lv_ellipsoid":
+        return lv_ellipsoid.create_microstructure(mesh, **kwargs)
+    else:
+        if mesh_type not in supported_mesh_types:
+            logger.warning(
+                f"Mesh type {mesh_type!r} is not recognized. "
+                f"Supported mesh types are: {supported_mesh_types!r}. "
+                "Lets try with LDRB algorithm to generate fibers.",
+            )
+
+        # Try with LDRB
+        try:
+            import ldrb
+        except ImportError as ex:
+            msg = (
+                "To create fibers you need to install the ldrb package "
+                "which you can install with pip install fenicsx-ldrb"
+            )
+            raise ImportError(msg) from ex
+
+        markers = kwargs.pop("markers", None)
+        clipped = kwargs.pop("clipped", False)
+
+        if mesh_type == "ukb" and markers is not None:
+            from ..mesh import transform_markers
+
+            markers = transform_markers(markers, clipped=clipped)
+
+        system = ldrb.dolfinx_ldrb(mesh=mesh, markers=markers, **kwargs)
+        return Microstructure(
+            f0=system.f0,
+            s0=system.s0,
+            n0=system.n0,
+        )

{cardiac_geometriesx-0.5.1 → cardiac_geometriesx-0.5.2}/src/cardiac_geometries/fibers/cylinder.py

@@ -81,6 +81,7 @@ def create_microstructure(
     r_outer: float,
     function_space: str = "P_1",
     outdir: str | Path | None = None,
+    **kwargs,
 ) -> utils.Microstructure:
     """Generate microstructure for cylinder
 

{cardiac_geometriesx-0.5.1 → cardiac_geometriesx-0.5.2}/src/cardiac_geometries/fibers/lv_ellipsoid.py

@@ -203,6 +203,7 @@ def create_microstructure(
     alpha_epi: float = 60,
     long_axis: int = 0,
     outdir: str | Path | None = None,
+    **kwargs,
 ):
     endo_marker = markers["ENDO"][0]
     epi_marker = markers["EPI"][0]

{cardiac_geometriesx-0.5.1 → cardiac_geometriesx-0.5.2}/src/cardiac_geometries/fibers/slab.py

@@ -11,7 +11,6 @@ def compute_system(
     t_func: dolfinx.fem.Function,
     alpha_endo: float = -60,
     alpha_epi: float = 60,
-    **kwargs,
 ) -> utils.Microstructure:
     """Compute ldrb system for slab, assuming linear
     angle between endo and epi
@@ -90,6 +89,7 @@ def create_microstructure(
     alpha_epi: float,
     function_space: str = "P_1",
     outdir: str | Path | None = None,
+    **kwargs: dict,
 ) -> utils.Microstructure:
     """Generate microstructure for slab using LDRB algorithm
 

{cardiac_geometriesx-0.5.1 → cardiac_geometriesx-0.5.2}/src/cardiac_geometries/geometry.py

@@ -3,6 +3,7 @@ import logging
 import shutil
 from dataclasses import dataclass, field
 from pathlib import Path
+from typing import Any
 
 from mpi4py import MPI
 
@@ -10,6 +11,7 @@ import adios2
 import adios4dolfinx
 import dolfinx
 import numpy as np
+import ufl
 from packaging.version import Version
 
 from . import utils
@@ -17,7 +19,7 @@ from . import utils
 logger = logging.getLogger(__name__)
 
 
-@dataclass  # (frozen=True, slots=True)
+@dataclass
 class Geometry:
     mesh: dolfinx.mesh.Mesh
     markers: dict[str, tuple[int, int]] = field(default_factory=dict)
@@ -28,8 +30,17 @@ class Geometry:
     f0: dolfinx.fem.Function | None = None
     s0: dolfinx.fem.Function | None = None
     n0: dolfinx.fem.Function | None = None
+    info: dict[str, Any] = field(default_factory=dict)
 
     def save(self, path: str | Path) -> None:
+        """Save the geometry to a file using adios4dolfinx.
+
+        Parameters
+        ----------
+        path : str | Path
+            The path to the file where the geometry will be saved.
+            The file will be created if it does not exist, or overwritten if it does.
+        """
         path = Path(path)
 
         shutil.rmtree(path, ignore_errors=True)
@@ -97,6 +108,123 @@ class Geometry:
 
         self.mesh.comm.barrier()
 
+    @property
+    def dx(self):
+        """Volume measure for the mesh using
+        the cell function `cfun` if it exists as subdomain data.
+        """
+        return ufl.Measure("dx", domain=self.mesh, subdomain_data=self.cfun)
+
+    @property
+    def ds(self):
+        """Surface measure for the mesh using
+        the facet function `ffun` if it exists as subdomain data.
+        """
+        return ufl.Measure("ds", domain=self.mesh, subdomain_data=self.ffun)
+
+    @property
+    def facet_normal(self) -> ufl.FacetNormal:
+        """Facet normal vector for the mesh."""
+        return ufl.FacetNormal(self.mesh)
+
+    def refine(self, n=1, outdir: Path | None = None) -> "Geometry":
+        """
+        Refine the mesh and transfer the meshtags to new geometry.
+        Also regenerate fibers if `self.info` is found.
+        If `self.info` is not found, it currently raises a
+        NotImplementedError, however fiber could be interpolated
+        from the old mesh to the new mesh but this will result in a
+        loss of information about the fiber orientation.
+
+        Parameters
+        ----------
+        n : int, optional
+            Number of times to refine the mesh, by default 1
+        outdir : Path | None, optional
+            Output directory to save the refined mesh and meshtags,
+            by default None in which case the mesh is not saved.
+
+        Returns
+        -------
+        Geometry
+            A new Geometry object with the refined mesh and updated meshtags.
+
+        Raises
+        ------
+        NotImplementedError
+            If `self.info` is not found, indicating that fiber
+            interpolation after refinement is not implemented yet.
+        """
+        mesh = self.mesh
+        cfun = self.cfun
+        ffun = self.ffun
+
+        for _ in range(n):
+            new_mesh, parent_cell, parent_facet = dolfinx.mesh.refine(
+                mesh,
+                partitioner=None,
+                option=dolfinx.mesh.RefinementOption.parent_cell_and_facet,
+            )
+            new_mesh.name = mesh.name
+            mesh = new_mesh
+            new_mesh.topology.create_entities(1)
+            new_mesh.topology.create_connectivity(2, 3)
+            if cfun is not None:
+                new_cfun = dolfinx.mesh.transfer_meshtag(cfun, new_mesh, parent_cell, parent_facet)
+                new_cfun.name = cfun.name
+                cfun = new_cfun
+            else:
+                new_cfun = None
+            if ffun is not None:
+                new_ffun = dolfinx.mesh.transfer_meshtag(ffun, new_mesh, parent_cell, parent_facet)
+                new_ffun.name = ffun.name
+                ffun = new_ffun
+            else:
+                new_ffun = None
+
+        if outdir is not None:
+            outdir = Path(outdir)
+            outdir.mkdir(parents=True, exist_ok=True)
+            with dolfinx.io.XDMFFile(new_mesh.comm, outdir / "mesh.xdmf", "w") as xdmf:
+                xdmf.write_mesh(new_mesh)
+                xdmf.write_meshtags(
+                    cfun,
+                    new_mesh.geometry,
+                    geometry_xpath=f"/Xdmf/Domain/Grid[@Name='{new_mesh.name}']/Geometry",
+                )
+                mesh.topology.create_connectivity(2, 3)
+                xdmf.write_meshtags(
+                    ffun,
+                    new_mesh.geometry,
+                    geometry_xpath=f"/Xdmf/Domain/Grid[@Name='{new_mesh.name}']/Geometry",
+                )
+
+        if self.info is not None:
+            info = self.info.copy()
+            info["refinement"] = n
+            info.pop("outdir", None)
+            if outdir is not None:
+                info["outdir"] = str(outdir)
+            from .fibers import generate_fibers
+
+            f0, s0, n0 = generate_fibers(mesh=new_mesh, ffun=new_ffun, markers=self.markers, **info)
+        else:
+            info = None
+            # Interpolate fibers
+            raise NotImplementedError(
+                "Interpolating fibers after refinement is not implemented yet."
+            )
+
+        return Geometry(
+            mesh=new_mesh,
+            markers=self.markers,
+            cfun=new_cfun,
+            ffun=new_ffun,
+            f0=f0,
+            s0=s0,
+            n0=n0,
+        )
+
     @classmethod
     def from_file(
         cls,
@@ -104,6 +232,24 @@ class Geometry:
         path: str | Path,
         function_space_data: dict[str, np.ndarray] | None = None,
     ) -> "Geometry":
+        """Read geometry from a file using adios4dolfinx.
+
+        Parameters
+        ----------
+        comm : MPI.Intracomm
+            The MPI communicator to use for reading the mesh.
+        path : str | Path
+            The path to the file containing the geometry data.
+        function_space_data : dict[str, np.ndarray] | None, optional
+            A dictionary containing function space data for the functions to be read.
+            If None, it will be read from the file.
+
+        Returns
+        -------
+        Geometry
+            An instance of the Geometry class containing the mesh, markers, and functions.
+        """
+
         path = Path(path)
 
         mesh = adios4dolfinx.read_mesh(comm=comm, filename=path)
@@ -148,6 +294,31 @@ class Geometry:
 
     @classmethod
     def from_folder(cls, comm: MPI.Intracomm, folder: str | Path) -> "Geometry":
+        """Read geometry from a folder containing mesh and markers files.
+
+        Parameters
+        ----------
+        comm : MPI.Intracomm
+            The MPI communicator to use for reading the mesh and markers.
+        folder : str | Path
+            The path to the folder containing the geometry data.
+            The folder should contain the following files:
+            - mesh.xdmf: The mesh file in XDMF format.
+            - markers.json: A JSON file containing markers.
+            - microstructure.json: A JSON file containing microstructure data (optional).
+            - microstructure.bp: A BP file containing microstructure functions (optional).
+            - info.json: A JSON file containing additional information (optional).
+
+        Returns
+        -------
+        Geometry
+            An instance of the Geometry class containing the mesh, markers, and functions.
+
+        Raises
+        ------
+        ValueError
+            If the required mesh file is not found in the specified folder.
+        """
         folder = Path(folder)
         logger.info(f"Reading geometry from {folder}")
         # Read mesh
@@ -196,9 +367,20 @@ class Geometry:
                 else:
                     functions[name] = f
 
+        if (folder / "info.json").exists():
+            logger.debug("Reading info")
+            if comm.rank == 0:
+                info = json.loads((folder / "info.json").read_text())
+            else:
+                info = {}
+            info = comm.bcast(info, root=0)
+        else:
+            info = {}
+
         return cls(
             mesh=mesh,
             markers=markers,
+            info=info,
             **functions,
             **tags,
         )

{cardiac_geometriesx-0.5.1 → cardiac_geometriesx-0.5.2}/src/cardiac_geometries/mesh.py

@@ -10,6 +10,7 @@ from mpi4py import MPI
 
 import cardiac_geometries_core as cgc
 import dolfinx
+import numpy as np
 from structlog import get_logger
 
 from . import utils
@@ -22,19 +23,80 @@ __version__ = meta["Version"]
 logger = get_logger()
 
 
+def transform_markers(
+    markers: dict[str, tuple[int, int]], clipped: bool = False
+) -> dict[str, list[int]]:
+    if clipped:
+        return {
+            "lv": [markers["LV"][0]],
+            "rv": [markers["RV"][0]],
+            "epi": [markers["EPI"][0]],
+            "base": [markers["BASE"][0]],
+        }
+    else:
+        return {
+            "lv": [markers["LV"][0]],
+            "rv": [markers["RV"][0]],
+            "epi": [markers["EPI"][0]],
+            "base": [
+                markers["PV"][0],
+                markers["TV"][0],
+                markers["AV"][0],
+                markers["MV"][0],
+            ],
+        }
+
+
 def ukb(
     outdir: str | Path,
     mode: int = -1,
     std: float = 1.5,
     case: str = "ED",
-    char_length_max: float = 2.0,
-    char_length_min: float = 2.0,
+    char_length_max: float = 5.0,
+    char_length_min: float = 5.0,
     fiber_angle_endo: float = 60,
     fiber_angle_epi: float = -60,
+    create_fibers: bool = True,
     fiber_space: str = "P_1",
     clipped: bool = False,
     comm: MPI.Comm = MPI.COMM_WORLD,
 ) -> Geometry:
+    """Create a mesh from the UK-Biobank atlas using
+    the ukb-atlas package.
+
+    Parameters
+    ----------
+    outdir : str | Path
+        Directory where to save the results.
+    mode : int, optional
+        Mode for the UKB mesh, by default -1
+    std : float, optional
+        Standard deviation for the UKB mesh, by default 1.5
+    case : str, optional
+        Case for the UKB mesh (either "ED" or "ES"), by default "ED"
+    char_length_max : float, optional
+        Maximum characteristic length of the mesh, by default 2.0
+    char_length_min : float, optional
+        Minimum characteristic length of the mesh, by default 2.0
+    fiber_angle_endo : float, optional
+        Fiber angle for the endocardium, by default 60
+    fiber_angle_epi : float, optional
+        Fiber angle for the epicardium, by default -60
+    create_fibers : bool, optional
+        If True create rule-based fibers, by default True
+    fiber_space : str, optional
+        Function space for fibers of the form family_degree, by default "P_1"
+    clipped : bool, optional
+        If True create a clipped mesh, by default False
+    comm : MPI.Comm, optional
+        MPI communicator, by default MPI.COMM_WORLD
+
+    Returns
+    -------
+    cardiac_geometries.geometry.Geometry
+        A Geometry with the mesh, markers, markers functions and fibers.
+
+    """
     try:
         import ukb.cli
     except ImportError as e:
@@ -87,67 +149,51 @@ def ukb(
                     "fiber_angle_epi": fiber_angle_epi,
                     "fiber_space": fiber_space,
                     "cardiac_geometry_version": __version__,
-                    "type": "ukb",
+                    "mesh_type": "ukb",
+                    "clipped": clipped,
                     "timestamp": datetime.datetime.now().isoformat(),
                 }
             )
         )
 
-    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)
+    if create_fibers:
+        try:
+            import ldrb
+        except ImportError as ex:
+            msg = (
+                "To create fibers you need to install the ldrb package "
+                "which you can install with pip install fenicsx-ldrb"
+            )
+            raise ImportError(msg) from ex
 
-    if clipped:
-        markers = {
-            "lv": [geometry.markers["LV"][0]],
-            "rv": [geometry.markers["RV"][0]],
-            "epi": [geometry.markers["EPI"][0]],
-            "base": [geometry.markers["BASE"][0]],
-        }
-    else:
-        markers = {
-            "lv": [geometry.markers["LV"][0]],
-            "rv": [geometry.markers["RV"][0]],
-            "epi": [geometry.markers["EPI"][0]],
-            "base": [
-                geometry.markers["PV"][0],
-                geometry.markers["TV"][0],
-                geometry.markers["AV"][0],
-                geometry.markers["MV"][0],
-            ],
-        }
-    system = ldrb.dolfinx_ldrb(
-        mesh=geometry.mesh,
-        ffun=geometry.ffun,
-        markers=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,
-    )
+        markers = transform_markers(geometry.markers, clipped=clipped)
+        system = ldrb.dolfinx_ldrb(
+            mesh=geometry.mesh,
+            ffun=geometry.ffun,
+            markers=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,
+        )
 
-    save_microstructure(
-        mesh=geometry.mesh,
-        functions=(system.f0, system.s0, system.n0),
-        outdir=outdir,
-    )
+        save_microstructure(
+            mesh=geometry.mesh,
+            functions=(system.f0, system.s0, system.n0),
+            outdir=outdir,
+        )
 
-    for k, v in system._asdict().items():
-        if v is None:
-            continue
-        if fiber_space.startswith("Q"):
-            # Cannot visualize Quadrature spaces yet
-            continue
+        for k, v in system._asdict().items():
+            if v is None:
+                continue
+            if fiber_space.startswith("Q"):
+                # Cannot visualize Quadrature spaces yet
+                continue
 
-        logger.debug(f"Write {k}: {v}")
-        with dolfinx.io.VTXWriter(comm, outdir / f"{k}-viz.bp", [v], engine="BP4") as vtx:
-            vtx.write(0.0)
+            logger.debug(f"Write {k}: {v}")
+            with dolfinx.io.VTXWriter(comm, outdir / f"{k}-viz.bp", [v], engine="BP4") as vtx:
+                vtx.write(0.0)
 
     geo = Geometry.from_folder(comm=comm, folder=outdir)
     return geo
@@ -272,10 +318,10 @@ def biv_ellipsoid(
                     "b_epi_rv": b_epi_rv,
                     "c_epi_rv": c_epi_rv,
                     "create_fibers": create_fibers,
-                    "fibers_angle_endo": fiber_angle_endo,
-                    "fibers_angle_epi": fiber_angle_epi,
+                    "fiber_angle_endo": fiber_angle_endo,
+                    "fiber_angle_epi": fiber_angle_epi,
                     "fiber_space": fiber_space,
-                    # "mesh_type": MeshTypes.biv_ellipsoid.value,
+                    "mesh_type": "biv_ellipsoid",
                     "cardiac_geometry_version": __version__,
                     "timestamp": datetime.datetime.now().isoformat(),
                 },
@@ -486,10 +532,10 @@ def biv_ellipsoid_torso(
                     "b_epi_rv": b_epi_rv,
                     "c_epi_rv": c_epi_rv,
                     "create_fibers": create_fibers,
-                    "fibers_angle_endo": fiber_angle_endo,
-                    "fibers_angle_epi": fiber_angle_epi,
+                    "fiber_angle_endo": fiber_angle_endo,
+                    "fiber_angle_epi": fiber_angle_epi,
                     "fiber_space": fiber_space,
-                    # "mesh_type": MeshTypes.biv_ellipsoid.value,
+                    "mesh_type": "biv",
                     "cardiac_geometry_version": __version__,
                     "timestamp": datetime.datetime.now().isoformat(),
                 },
@@ -640,11 +686,11 @@ def lv_ellipsoid(
                     "mu_apex_epi": mu_apex_epi,
                     "mu_base_epi": mu_base_epi,
                     "create_fibers": create_fibers,
-                    "fibers_angle_endo": fiber_angle_endo,
-                    "fibers_angle_epi": fiber_angle_epi,
+                    "fiber_angle_endo": fiber_angle_endo,
+                    "fiber_angle_epi": fiber_angle_epi,
                     "fiber_space": fiber_space,
                     "aha": aha,
-                    # "mesh_type": MeshTypes.lv_ellipsoid.value,
+                    "mesh_type": "lv_ellipsoid",
                     "cardiac_geometry_version": __version__,
                     "timestamp": datetime.datetime.now().isoformat(),
                 },
@@ -717,6 +763,70 @@ def lv_ellipsoid(
     return geo
 
 
+def slab_dolfinx(
+    comm, outdir: Path, lx: float = 20.0, ly: float = 7.0, lz: float = 3.0, dx: float = 1.0
+) -> utils.GMshGeometry:
+    mesh = dolfinx.mesh.create_box(
+        comm,
+        [[0.0, 0.0, 0.0], [lx, ly, lz]],
+        [int(lx / dx), int(ly / dx), int(lz / dx)],
+        dolfinx.mesh.CellType.tetrahedron,
+        ghost_mode=dolfinx.mesh.GhostMode.none,
+    )
+    mesh.name = "Mesh"
+    fdim = mesh.topology.dim - 1
+    x0_facets = dolfinx.mesh.locate_entities_boundary(mesh, fdim, lambda x: np.isclose(x[0], 0))
+    x1_facets = dolfinx.mesh.locate_entities_boundary(mesh, fdim, lambda x: np.isclose(x[0], lx))
+    y0_facets = dolfinx.mesh.locate_entities_boundary(mesh, fdim, lambda x: np.isclose(x[1], 0))
+    y1_facets = dolfinx.mesh.locate_entities_boundary(mesh, fdim, lambda x: np.isclose(x[1], ly))
+    z0_facets = dolfinx.mesh.locate_entities_boundary(mesh, fdim, lambda x: np.isclose(x[2], 0))
+    z1_facets = dolfinx.mesh.locate_entities_boundary(mesh, fdim, lambda x: np.isclose(x[2], lz))
+
+    # Concatenate and sort the arrays based on facet indices.
+    # Left facets marked with 1, right facets with two
+    marked_facets = np.hstack([x0_facets, x1_facets, y0_facets, y1_facets, z0_facets, z1_facets])
+
+    marked_values = np.hstack(
+        [
+            np.full_like(x0_facets, 1),
+            np.full_like(x1_facets, 2),
+            np.full_like(y0_facets, 3),
+            np.full_like(y1_facets, 4),
+            np.full_like(z0_facets, 5),
+            np.full_like(z1_facets, 6),
+        ],
+    )
+    sorted_facets = np.argsort(marked_facets)
+    ft = dolfinx.mesh.meshtags(
+        mesh,
+        fdim,
+        marked_facets[sorted_facets],
+        marked_values[sorted_facets],
+    )
+    ft.name = "Facet tags"
+    markers = {
+        "X0": (1, 2),
+        "X1": (2, 2),
+        "Y0": (3, 2),
+        "Y1": (4, 2),
+        "Z0": (5, 2),
+        "Z1": (6, 2),
+    }
+
+    with dolfinx.io.XDMFFile(comm, outdir / "mesh.xdmf", "w") as xdmf:
+        xdmf.write_mesh(mesh)
+        xdmf.write_meshtags(ft, mesh.geometry)
+
+    return utils.GMshGeometry(
+        mesh=mesh,
+        markers=markers,
+        cfun=None,
+        ffun=ft.indices,
+        efun=None,
+        vfun=None,
+    )
+
+
 def slab(
     outdir: Path | str,
     lx: float = 20.0,
@@ -728,6 +838,7 @@ def slab(
     fiber_angle_epi: float = -60,
     fiber_space: str = "P_1",
     verbose: bool = False,
+    use_dolfinx: bool = False,
     comm: MPI.Comm = MPI.COMM_WORLD,
 ) -> Geometry:
     """Create slab geometry
@@ -754,6 +865,8 @@ def slab(
         Function space for fibers of the form family_degree, by default "P_1"
     verbose : bool, optional
         If True print information from gmsh, by default False
+    use_dolfinx : bool, optional
+        If True use dolfinx to create the mesh, by default False (gmsh)
     comm : MPI.Comm, optional
         MPI communicator, by default MPI.COMM_WORLD
 
@@ -771,15 +884,15 @@ def slab(
         with open(outdir / "info.json", "w") as f:
             json.dump(
                 {
-                    "lx": lx,
-                    "ly": ly,
-                    "lz": lz,
+                    "Lx": lx,
+                    "Ly": ly,
+                    "Lz": lz,
                     "dx": dx,
                     "create_fibers": create_fibers,
-                    "fibers_angle_endo": fiber_angle_endo,
-                    "fibers_angle_epi": fiber_angle_epi,
+                    "fiber_angle_endo": fiber_angle_endo,
+                    "fiber_angle_epi": fiber_angle_epi,
                     "fiber_space": fiber_space,
-                    # "mesh_type": MeshTypes.slab.value,
+                    "mesh_type": "slab",
                     "cardiac_geometry_version": __version__,
                     "timestamp": datetime.datetime.now().isoformat(),
                 },
@@ -788,17 +901,29 @@ def slab(
                 default=utils.json_serial,
             )
 
-        cgc.slab(
-            mesh_name=mesh_name.as_posix(),
+        if not use_dolfinx:
+            cgc.slab(
+                mesh_name=mesh_name.as_posix(),
+                lx=lx,
+                ly=ly,
+                lz=lz,
+                dx=dx,
+                verbose=verbose,
+            )
+    comm.barrier()
+
+    if use_dolfinx:
+        geometry = slab_dolfinx(
+            comm=comm,
+            outdir=outdir,
             lx=lx,
             ly=ly,
             lz=lz,
             dx=dx,
-            verbose=verbose,
         )
-    comm.barrier()
 
-    geometry = utils.gmsh2dolfin(comm=comm, msh_file=mesh_name)
+    else:
+        geometry = utils.gmsh2dolfin(comm=comm, msh_file=mesh_name)
 
     if comm.rank == 0:
         with open(outdir / "markers.json", "w") as f:
@@ -880,7 +1005,7 @@ def slab_in_bath(
                     "by": by,
                     "bz": bz,
                     "dx": dx,
-                    # "mesh_type": MeshTypes.slab.value,
+                    "mesh_type": "slab-bath",
                     "cardiac_geometry_version": __version__,
                     "timestamp": datetime.datetime.now().isoformat(),
                 },
@@ -975,11 +1100,11 @@ def cylinder(
                     "height": height,
                     "char_length": char_length,
                     "create_fibers": create_fibers,
-                    "fibers_angle_endo": fiber_angle_endo,
-                    "fibers_angle_epi": fiber_angle_epi,
+                    "fiber_angle_endo": fiber_angle_endo,
+                    "fiber_angle_epi": fiber_angle_epi,
                     "fiber_space": fiber_space,
                     "aha": aha,
-                    # "mesh_type": MeshTypes.lv_ellipsoid.value,
+                    "mesh_type": "cylinder",
                     "cardiac_geometry_version": __version__,
                     "timestamp": datetime.datetime.now().isoformat(),
                 },

{cardiac_geometriesx-0.5.1 → cardiac_geometriesx-0.5.2}/src/cardiac_geometries/utils.py

@@ -403,7 +403,7 @@ def read_mesh(
 ) -> 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")
+        mesh = xdmf.read_mesh(name="Mesh", ghost_mode=dolfinx.mesh.GhostMode.none)
         for var, name, dim in [
             ("cfun", "Cell tags", mesh.topology.dim),
             ("ffun", "Facet tags", mesh.topology.dim - 1),

{cardiac_geometriesx-0.5.1 → cardiac_geometriesx-0.5.2/src/cardiac_geometriesx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cardiac-geometriesx
-Version: 0.5.1
+Version: 0.5.2
 Summary: A python library for cardiac geometries
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT
@@ -77,7 +77,11 @@ 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
+however, this assumes that you already have `dolfinx` pre-installed. You can also use `conda`
+```
+conda install -c conda-forge cardiac-geometriesx
+```
+or the provided docker image
 ```
 docker pull ghcr.io/computationalphysiology/cardiac-geometriesx:latest
 ```

{cardiac_geometriesx-0.5.1 → cardiac_geometriesx-0.5.2}/src/cardiac_geometriesx.egg-info/SOURCES.txt

@@ -20,4 +20,5 @@ src/cardiac_geometriesx.egg-info/not-zip-safe
 src/cardiac_geometriesx.egg-info/requires.txt
 src/cardiac_geometriesx.egg-info/top_level.txt
 tests/test_cli.py
+tests/test_refinement.py
 tests/test_save_load.py

{cardiac_geometriesx-0.5.1 → cardiac_geometriesx-0.5.2}/tests/test_cli.py

@@ -21,6 +21,8 @@ try:
 except ImportError:
     HAS_UKB = False
 
+MPI_SIZE = MPI.COMM_WORLD.size
+
 
 @pytest.mark.parametrize(
     "script",
@@ -60,7 +62,8 @@ def test_biv_fibers(tmp_path: Path):
     path = comm.bcast(tmp_path, root=0)
 
     res = runner.invoke(
-        cli.biv_ellipsoid, [path.as_posix()], "--create-fibers", "--fiber-space", "P_1"
+        cli.biv_ellipsoid,
+        [path.as_posix(), "--create-fibers", "--fiber-space", "P_1"],
     )
     assert res.exit_code == 0
     assert path.is_dir()
@@ -95,6 +98,7 @@ def test_script_no_fibers(script, tmp_path: Path):
 @pytest.mark.parametrize("clipped", [True, False])
 @pytest.mark.parametrize("case", ["ED", "ES"])
 @pytest.mark.skipif(not HAS_UKB, reason="UKB atlas is not installed")
+@pytest.mark.skipif(MPI.COMM_WORLD.size > 1, reason="Pyvista operations is not parallelized yet")
 def test_ukb(tmp_path: Path, case: str, clipped: bool):
     runner = CliRunner()
 

cardiac_geometriesx-0.5.2/tests/test_refinement.py

@@ -0,0 +1,96 @@
+from pathlib import Path
+
+from mpi4py import MPI
+
+import pytest
+
+import cardiac_geometries as cg
+
+try:
+    import ldrb  # noqa: F401
+
+    HAS_LDRB = True
+except ImportError:
+    HAS_LDRB = False
+
+try:
+    import ukb.cli  # noqa: F401
+
+    HAS_UKB = True
+except ImportError:
+    HAS_UKB = False
+
+MPI_SIZE = MPI.COMM_WORLD.size
+
+
+@pytest.mark.parametrize(
+    "script",
+    [
+        cg.mesh.slab,
+        cg.mesh.lv_ellipsoid,
+        cg.mesh.cylinder,
+    ],
+    ids=["slab", "lv_ellipsoid", "cylinder"],
+)
+def test_refine_analytic_fibers(script, tmp_path: Path):
+    comm = MPI.COMM_WORLD
+    path = comm.bcast(tmp_path, root=0)
+    outdir = path / "mesh"
+    script(outdir=outdir, create_fibers=True, comm=comm)
+    geo = cg.Geometry.from_folder(comm=comm, folder=outdir)
+    assert (outdir / "mesh.xdmf").is_file()
+    assert geo.f0 is not None
+    # assert geo.mesh.geometry.dim == 3
+    refined_outdir = path / "refined"
+    refined = geo.refine(outdir=refined_outdir, n=1)
+    assert refined.f0 is not None
+    assert (refined_outdir / "mesh.xdmf").is_file()
+    assert (
+        refined.f0.function_space.dofmap.index_map.size_global
+        > geo.f0.function_space.dofmap.index_map.size_global
+    )
+    assert refined.mesh.geometry.index_map().size_global > geo.mesh.geometry.index_map().size_global
+
+
+@pytest.mark.skipif(not HAS_LDRB, reason="LDRB atlas is not installed")
+def test_refine_biv(tmp_path: Path):
+    comm = MPI.COMM_WORLD
+    path = comm.bcast(tmp_path, root=0)
+    outdir = path / "mesh"
+    cg.mesh.biv_ellipsoid(outdir=outdir, create_fibers=True, comm=comm)
+    geo = cg.Geometry.from_folder(comm=comm, folder=outdir)
+    assert geo.f0 is not None
+    assert (outdir / "mesh.xdmf").is_file()
+    # assert geo.mesh.geometry.dim == 3
+    refined_outdir = path / "refined"
+    refined = geo.refine(outdir=refined_outdir, n=1)
+    assert refined.f0 is not None
+    assert (refined_outdir / "mesh.xdmf").is_file()
+    assert (
+        refined.f0.function_space.dofmap.index_map.size_global
+        > geo.f0.function_space.dofmap.index_map.size_global
+    )
+    assert refined.mesh.geometry.index_map().size_global > geo.mesh.geometry.index_map().size_global
+
+
+@pytest.mark.skipif(not HAS_LDRB, reason="LDRB atlas is not installed")
+@pytest.mark.skipif(not HAS_UKB, reason="UKB atlas is not installed")
+@pytest.mark.skipif(MPI.COMM_WORLD.size > 1, reason="Pyvista operations is not parallelized yet")
+def test_refine_ukb(tmp_path: Path):
+    comm = MPI.COMM_WORLD
+    path = comm.bcast(tmp_path, root=0)
+    outdir = path / "mesh"
+    cg.mesh.ukb(outdir=outdir, create_fibers=True, comm=comm)
+    geo = cg.Geometry.from_folder(comm=comm, folder=outdir)
+    assert geo.f0 is not None
+    assert (outdir / "mesh.xdmf").is_file()
+    # assert geo.mesh.geometry.dim == 3
+    refined_outdir = path / "refined"
+    refined = geo.refine(outdir=refined_outdir, n=1)
+    assert refined.f0 is not None
+    assert (refined_outdir / "mesh.xdmf").is_file()
+    assert (
+        refined.f0.function_space.dofmap.index_map.size_global
+        > geo.f0.function_space.dofmap.index_map.size_global
+    )
+    assert refined.mesh.geometry.index_map().size_global > geo.mesh.geometry.index_map().size_global

cardiac_geometriesx-0.5.1/src/cardiac_geometries/fibers/__init__.py

@@ -1,4 +0,0 @@
-from . import cylinder, lv_ellipsoid, slab, utils
-from .utils import Microstructure
-
-__all__ = ["lv_ellipsoid", "slab", "cylinder", "utils", "Microstructure"]