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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cardiac-geometriesx
-Version: 0.4.8
+Version: 0.5.1
 Summary: A python library for cardiac geometries
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cardiac-geometriesx"
-version = "0.4.8"
+version = "0.5.1"
 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.4.8"
+current_version = "0.5.1"
 
 
 [[tool.bumpversion.files]]

{cardiac_geometriesx-0.4.8 → cardiac_geometriesx-0.5.1}/src/cardiac_geometries/cli.py

@@ -973,6 +973,102 @@ def slab_in_bath(
     geo.save(outdir / "slab_in_bath.bp")
 
 
+@click.command(help="Create BiV ellipsoidal geometry")
+@click.argument(
+    "outdir",
+    required=True,
+    type=click.Path(
+        file_okay=False,
+        dir_okay=True,
+        writable=True,
+        readable=True,
+        resolve_path=True,
+    ),
+)
+@click.option(
+    "--char-length",
+    default=10.0,
+    type=float,
+    help="Characteristic length of mesh",
+    show_default=True,
+)
+@click.option(
+    "--r-inner",
+    default=10.0,
+    type=float,
+    help="Inner radius of the cylinder",
+    show_default=True,
+)
+@click.option(
+    "--r-outer",
+    default=20.0,
+    type=float,
+    help="Outer radius of the cylinder",
+    show_default=True,
+)
+@click.option(
+    "--height",
+    default=40.0,
+    type=float,
+    help="Height of the cylinder",
+    show_default=True,
+)
+@click.option(
+    "--create-fibers",
+    default=False,
+    is_flag=True,
+    help="If True create analytic fibers",
+    show_default=True,
+)
+@click.option(
+    "--fiber-angle-endo",
+    default=-60,
+    type=float,
+    help="Angle for the endocardium",
+    show_default=True,
+)
+@click.option(
+    "--fiber-angle-epi",
+    default=+60,
+    type=float,
+    help="Angle for the epicardium",
+    show_default=True,
+)
+@click.option(
+    "--fiber-space",
+    default="P_1",
+    type=str,
+    help="Function space for fibers of the form family_degree",
+    show_default=True,
+)
+def cylinder(
+    outdir: Path,
+    char_length: float = 10.0,
+    r_inner: float = 10.0,
+    r_outer: float = 20.0,
+    height: float = 40.0,
+    create_fibers: bool = False,
+    fiber_angle_endo: float = -60,
+    fiber_angle_epi: float = +60,
+    fiber_space: str = "P_1",
+):
+    outdir = Path(outdir)
+    outdir.mkdir(exist_ok=True)
+
+    geo = mesh.cylinder(
+        outdir=outdir,
+        r_inner=r_inner,
+        r_outer=r_outer,
+        height=height,
+        char_length=char_length,
+        create_fibers=create_fibers,
+        fiber_angle_endo=fiber_angle_endo,
+        fiber_angle_epi=fiber_angle_epi,
+        fiber_space=fiber_space,
+    )
+    geo.save(outdir / "cylinder.bp")
+
+
 @click.command("gui")
 def gui():
     # Make sure we can import the required packages
@@ -991,3 +1087,4 @@ app.add_command(slab)
 app.add_command(slab_in_bath)
 app.add_command(gui)
 app.add_command(ukb)
+app.add_command(cylinder)

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

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

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

@@ -0,0 +1,124 @@
+from pathlib import Path
+
+import dolfinx
+import numpy as np
+
+from ..utils import space_from_string
+from . import utils
+
+
+def compute_system(
+    mesh: dolfinx.mesh.Mesh,
+    alpha_endo: float = -60,
+    alpha_epi: float = 60,
+    r_inner: float = 10.0,
+    r_outer: float = 20.0,
+    function_space: str = "P_1",
+    **kwargs,
+) -> utils.Microstructure:
+    """Compute ldrb system for cylinder, assuming linear
+    angle between endo and epi
+
+    Parameters
+    ----------
+    mesh : dolfinx.mesh.Mesh
+        A cylinder mesh
+    alpha_endo : float, optional
+        Angle on endocardium, by default -60
+    alpha_epi : float, optional
+        Angle on epicardium, by default 60
+    r_inner : float, optional
+        Inner radius, by default 10.0
+    r_outer : float, optional
+        Outer radius, by default 20.0
+    function_space : str, optional
+        Function space to interpolate the fibers, by default "P_1"
+    Returns
+    -------
+    Microstructure
+        Tuple with fiber, sheet and sheet normal
+    """
+
+    Vv = space_from_string(function_space, mesh, dim=3)
+
+    x, y, z = Vv.tabulate_dof_coordinates().T
+    r = np.sqrt(x**2 + y**2)
+
+    # Circumferential direction
+    e_r = np.array([x / r, y / r, np.zeros_like(r)])
+    e_theta = np.array([-y / r, x / r, np.zeros_like(r)])
+    e_z = np.array([np.zeros_like(r), np.zeros_like(r), np.ones_like(r)])
+
+    n0 = e_r
+    alpha = (alpha_endo + (alpha_epi - alpha_endo) * (r - r_inner) / (r_outer - r_inner)) * (
+        np.pi / 180
+    )
+
+    f0 = e_theta * np.cos(alpha) - e_z * np.sin(alpha)
+    s0 = e_theta * np.sin(alpha) + e_z * np.cos(alpha)
+
+    fiber = dolfinx.fem.Function(Vv)
+    norm_f = np.linalg.norm(f0, axis=0)
+    fiber.x.array[:] = (f0 / norm_f).T.reshape(-1)
+    fiber.name = "f0"
+
+    sheet = dolfinx.fem.Function(Vv)
+    sheet.x.array[:] = s0.T.reshape(-1)
+    sheet.name = "s0"
+
+    sheet_normal = dolfinx.fem.Function(Vv)
+    sheet_normal.x.array[:] = n0.T.reshape(-1)
+    sheet_normal.name = "n0"
+
+    return utils.Microstructure(f0=fiber, s0=sheet, n0=sheet_normal)
+
+
+def create_microstructure(
+    mesh: dolfinx.mesh.Mesh,
+    alpha_endo: float,
+    alpha_epi: float,
+    r_inner: float,
+    r_outer: float,
+    function_space: str = "P_1",
+    outdir: str | Path | None = None,
+) -> utils.Microstructure:
+    """Generate microstructure for cylinder
+
+    Parameters
+    ----------
+    mesh : dolfinx.mesh.Mesh
+        A cylinder mesh
+    alpha_endo : float
+        Angle on the endocardium
+    alpha_epi : float
+        Angle on the epicardium
+    r_inner : float
+        Inner radius
+    r_outer : float
+        Outer radius
+    function_space : str
+        Function space to interpolate the fibers, by default P_1
+    outdir : Optional[Union[str, Path]], optional
+        Output directory to store the results, by default None.
+        If no output directory is specified the results will not be stored,
+        but only returned.
+
+    Returns
+    -------
+    Microstructure
+        Tuple with fiber, sheet and sheet normal
+    """
+
+    system = compute_system(
+        mesh=mesh,
+        function_space=function_space,
+        r_inner=r_inner,
+        r_outer=r_outer,
+        alpha_endo=alpha_endo,
+        alpha_epi=alpha_epi,
+    )
+
+    if outdir is not None:
+        utils.save_microstructure(mesh, system, outdir)
+
+    return system

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

@@ -1,4 +1,5 @@
 import json
+import shutil
 from pathlib import Path
 from typing import NamedTuple, Sequence
 
@@ -32,20 +33,25 @@ def save_microstructure(
     if functions[0].function_space.ufl_element().family_name == "quadrature":
         from scifem.xdmf import XDMFFile
 
-        with XDMFFile(Path(outdir) / "microstructure-viz.xdmf", functions) as xdmf:
+        fname = Path(outdir) / "microstructure-viz.xdmf"
+        fname.unlink(missing_ok=True)
+        fname.with_suffix(".h5").unlink(missing_ok=True)
+        with XDMFFile(fname, functions) as xdmf:
             xdmf.write(0.0)
 
     else:
+        fname = Path(outdir) / "microstructure-viz.bp"
+        shutil.rmtree(fname, ignore_errors=True)
         try:
-            with dolfinx.io.VTXWriter(
-                mesh.comm, Path(outdir) / "microstructure-viz.bp", functions, engine="BP4"
-            ) as file:
+            with dolfinx.io.VTXWriter(mesh.comm, fname, functions, engine="BP4") as file:
                 file.write(0.0)
         except RuntimeError as ex:
             print(f"Failed to write microstructure: {ex}")
 
     # Save with proper function space
+
     filename = Path(outdir) / "microstructure.bp"
+    shutil.rmtree(filename, ignore_errors=True)
     for function in functions:
         adios4dolfinx.write_function(u=function, filename=filename)
 

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

@@ -910,3 +910,113 @@ def slab_in_bath(
     geo = Geometry.from_folder(comm=comm, folder=outdir)
 
     return geo
+
+
+def cylinder(
+    outdir: Path | str,
+    r_inner: float = 10.0,
+    r_outer: float = 20.0,
+    height: float = 40.0,
+    char_length: float = 10.0,
+    create_fibers: bool = False,
+    fiber_angle_endo: float = 60,
+    fiber_angle_epi: float = -60,
+    fiber_space: str = "P_1",
+    aha: bool = True,
+    verbose: bool = False,
+    comm: MPI.Comm = MPI.COMM_WORLD,
+) -> Geometry:
+    """Create an LV ellipsoidal geometry
+
+    Parameters
+    ----------
+    outdir : Optional[Path], optional
+        Directory where to save the results.
+    r_inner : float, optional
+        Radius on the endocardium layer, by default 10.0
+    r_outer : float, optional
+       Radius on the epicardium layer, by default 20.0
+    height : float, optional
+        Longest radius on the endocardium layer, by default 10.0
+    char_length : float, optional
+        Characteristic length of mesh, by default 10.0
+    create_fibers : bool, optional
+        If True create analytic fibers, by default False
+    fiber_angle_endo : float, optional
+        Angle for the endocardium, by default 60
+    fiber_angle_epi : float, optional
+        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
+        If True create 17-segment AHA regions
+    verbose : bool, optional
+        If True print information from gmsh, 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.
+
+    """
+
+    outdir = Path(outdir)
+    mesh_name = outdir / "cylinder.msh"
+    if comm.rank == 0:
+        outdir.mkdir(exist_ok=True, parents=True)
+
+        with open(outdir / "info.json", "w") as f:
+            json.dump(
+                {
+                    "r_inner": r_inner,
+                    "r_outer": r_outer,
+                    "height": height,
+                    "char_length": char_length,
+                    "create_fibers": create_fibers,
+                    "fibers_angle_endo": fiber_angle_endo,
+                    "fibers_angle_epi": fiber_angle_epi,
+                    "fiber_space": fiber_space,
+                    "aha": aha,
+                    # "mesh_type": MeshTypes.lv_ellipsoid.value,
+                    "cardiac_geometry_version": __version__,
+                    "timestamp": datetime.datetime.now().isoformat(),
+                },
+                f,
+                indent=2,
+                default=utils.json_serial,
+            )
+
+        cgc.cylinder(
+            inner_radius=r_inner,
+            outer_radius=r_outer,
+            height=height,
+            mesh_name=mesh_name.as_posix(),
+            char_length=char_length,
+            verbose=verbose,
+        )
+    comm.barrier()
+
+    geometry = utils.gmsh2dolfin(comm=comm, msh_file=mesh_name)
+
+    if comm.rank == 0:
+        with open(outdir / "markers.json", "w") as f:
+            json.dump(geometry.markers, f, default=utils.json_serial)
+
+    if create_fibers:
+        from .fibers.cylinder import create_microstructure
+
+        create_microstructure(
+            mesh=geometry.mesh,
+            function_space=fiber_space,
+            r_inner=r_inner,
+            r_outer=r_outer,
+            alpha_endo=fiber_angle_endo,
+            alpha_epi=fiber_angle_epi,
+            outdir=outdir,
+        )
+
+    geo = Geometry.from_folder(comm=comm, folder=outdir)
+
+    return geo

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

@@ -440,12 +440,19 @@ def gmsh2dolfin(comm: MPI.Intracomm, msh_file, rank: int = 0) -> GMshGeometry:
             ft = dolfinx.mesh.meshtags(
                 mesh, tdim - 1, np.empty(0, dtype=np.int32), np.empty(0, dtype=np.int32)
             )
-        et = mesh_data.edge_tags
+
+        if hasattr(mesh_data, "edge_tags"):
+            et = mesh_data.edge_tags
+        else:
+            et = mesh_data.ridge_tags
         if et is None:
             et = dolfinx.mesh.meshtags(
                 mesh, tdim - 2, np.empty(0, dtype=np.int32), np.empty(0, dtype=np.int32)
             )
-        vt = mesh_data.vertex_tags
+        if hasattr(mesh_data, "vertex_tags"):
+            vt = mesh_data.vertex_tags
+        else:
+            vt = mesh_data.peak_tags
         if vt is None:
             vt = dolfinx.mesh.meshtags(
                 mesh, tdim - 3, np.empty(0, dtype=np.int32), np.empty(0, dtype=np.int32)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cardiac-geometriesx
-Version: 0.4.8
+Version: 0.5.1
 Summary: A python library for cardiac geometries
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT

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

@@ -8,6 +8,7 @@ src/cardiac_geometries/gui.py
 src/cardiac_geometries/mesh.py
 src/cardiac_geometries/utils.py
 src/cardiac_geometries/fibers/__init__.py
+src/cardiac_geometries/fibers/cylinder.py
 src/cardiac_geometries/fibers/lv_ellipsoid.py
 src/cardiac_geometries/fibers/slab.py
 src/cardiac_geometries/fibers/utils.py

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

@@ -7,14 +7,29 @@ from click.testing import CliRunner
 
 from cardiac_geometries import Geometry, cli
 
+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
+
 
 @pytest.mark.parametrize(
     "script",
     [
         cli.slab,
         cli.lv_ellipsoid,
+        cli.cylinder,
     ],
-    ids=["slab", "lv_ellipsoid"],
+    ids=["slab", "lv_ellipsoid", "cylinder"],
 )
 @pytest.mark.parametrize("fiber_space", [None, "P_1", "P_2", "Quadrature_2", "DG_1"])
 def test_script(fiber_space, script, tmp_path: Path):
@@ -37,6 +52,23 @@ def test_script(fiber_space, script, tmp_path: Path):
         assert geo.f0 is not None
 
 
+@pytest.mark.skipif(not HAS_LDRB, reason="LDRB atlas is not installed")
+def test_biv_fibers(tmp_path: Path):
+    runner = CliRunner()
+
+    comm = MPI.COMM_WORLD
+    path = comm.bcast(tmp_path, root=0)
+
+    res = runner.invoke(
+        cli.biv_ellipsoid, [path.as_posix()], "--create-fibers", "--fiber-space", "P_1"
+    )
+    assert res.exit_code == 0
+    assert path.is_dir()
+
+    geo = Geometry.from_folder(comm=comm, folder=path)
+    assert geo.mesh.geometry.dim == 3
+
+
 @pytest.mark.parametrize(
     "script",
     [
@@ -62,6 +94,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")
 def test_ukb(tmp_path: Path, case: str, clipped: bool):
     runner = CliRunner()
 

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

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