cardiac-geometriesx 0.4.4__tar.gz → 0.4.6__tar.gz

{cardiac_geometriesx-0.4.4/src/cardiac_geometriesx.egg-info → cardiac_geometriesx-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: cardiac-geometriesx
-Version: 0.4.4
+Version: 0.4.6
 Summary: A python library for cardiac geometries
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT
@@ -33,10 +33,13 @@ 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"
+Requires-Dist: ukb-atlas; extra == "docs"
 Provides-Extra: test
 Requires-Dist: pre-commit; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: ukb-atlas; extra == "test"
+Requires-Dist: fenicsx-ldrb; extra == "test"
 Provides-Extra: gui
 Requires-Dist: streamlit; extra == "gui"
 Requires-Dist: stpyvista; extra == "gui"

{cardiac_geometriesx-0.4.4 → cardiac_geometriesx-0.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cardiac-geometriesx"
-version = "0.4.4"
+version = "0.4.6"
 description = "A python library for cardiac geometries"
 authors = [{name = "Henrik Finsberg", email = "henriknf@simula.no"}]
 license = {text = "MIT"}
@@ -46,11 +46,14 @@ docs = [
     "trame-vuetify",
     "ipywidgets",
     "fenicsx-ldrb",
+    "ukb-atlas",
 ]
 test = [
     "pre-commit",
     "pytest",
     "pytest-cov",
+    "ukb-atlas",
+    "fenicsx-ldrb",
 ]
 gui = [
     "streamlit",
@@ -174,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.4"
+current_version = "0.4.6"
 
 
 [[tool.bumpversion.files]]

{cardiac_geometriesx-0.4.4 → cardiac_geometriesx-0.4.6}/src/cardiac_geometries/cli.py

@@ -24,6 +24,102 @@ def app():
     pass
 
 
+@click.command(help="Create UK Biobank geometry")
+@click.argument(
+    "outdir",
+    required=True,
+    type=click.Path(
+        file_okay=False,
+        dir_okay=True,
+        writable=True,
+        readable=True,
+        resolve_path=True,
+    ),
+)
+@click.option(
+    "--mode",
+    default=-1,
+    type=int,
+    help="Mode of the geometry",
+    show_default=True,
+)
+@click.option(
+    "--std",
+    default=1.5,
+    type=float,
+    help="Standard deviation of the geometry",
+    show_default=True,
+)
+@click.option(
+    "--case",
+    default="ED",
+    type=str,
+    help="Case of the geometry",
+    show_default=True,
+)
+@click.option(
+    "--char-length-max",
+    default=2.0,
+    type=float,
+    help="Maximum characteristic length of the mesh",
+    show_default=True,
+)
+@click.option(
+    "--char-length-min",
+    default=2.0,
+    type=float,
+    help="Minimum characteristic length of the mesh",
+    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 ukb(
+    outdir: Path | str,
+    mode: int = -1,
+    std: float = 1.5,
+    case: str = "ED",
+    char_length_max: float = 2.0,
+    char_length_min: float = 2.0,
+    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.ukb(
+        outdir=outdir,
+        mode=mode,
+        std=std,
+        case=case,
+        char_length_max=char_length_max,
+        char_length_min=char_length_min,
+        fiber_angle_endo=fiber_angle_endo,
+        fiber_angle_epi=fiber_angle_epi,
+        fiber_space=fiber_space,
+    )
+    geo.save(outdir / "ukb.bp")
+
+
 @click.command(help="Create LV ellipsoidal geometry")
 @click.argument(
     "outdir",
@@ -382,6 +478,7 @@ def biv_ellipsoid(
     geo = mesh.biv_ellipsoid(
         outdir=outdir,
         char_length=char_length,
+        center_lv_x=center_lv_x,
         center_lv_y=center_lv_y,
         center_lv_z=center_lv_z,
         a_endo_lv=a_endo_lv,
@@ -390,6 +487,7 @@ def biv_ellipsoid(
         a_epi_lv=a_epi_lv,
         b_epi_lv=b_epi_lv,
         c_epi_lv=c_epi_lv,
+        center_rv_x=center_rv_x,
         center_rv_y=center_rv_y,
         center_rv_z=center_rv_z,
         a_endo_rv=a_endo_rv,
@@ -457,7 +555,7 @@ def biv_ellipsoid(
     default=math.pi / 6,
     type=float,
     help=(
-        "Angle to rotate the torso in order to object realistic" " position of the heart in a torso"
+        "Angle to rotate the torso in order to object realistic position of the heart in a torso"
     ),
     show_default=True,
 )
@@ -886,3 +984,4 @@ app.add_command(biv_ellipsoid_torso)
 app.add_command(slab)
 app.add_command(slab_in_bath)
 app.add_command(gui)
+app.add_command(ukb)

{cardiac_geometriesx-0.4.4 → cardiac_geometriesx-0.4.6}/src/cardiac_geometries/fibers/utils.py

@@ -7,9 +7,12 @@ import dolfinx
 import numpy as np
 import ufl
 from dolfinx.fem.petsc import LinearProblem
+from packaging.version import Version
 
 from ..utils import space_from_string
 
+_dolfinx_version = Version(dolfinx.__version__)
+
 
 class Microstructure(NamedTuple):
     f0: dolfinx.fem.Function
@@ -101,7 +104,12 @@ def laplace(
     if function_space != "P_1":
         W = space_from_string(function_space, mesh, dim=1)
         t = dolfinx.fem.Function(W)
-        expr = dolfinx.fem.Expression(uh, W.element.interpolation_points())
+        if _dolfinx_version >= Version("0.10"):
+            points = W.element.interpolation_points
+        else:
+            points = W.element.interpolation_points()
+
+        expr = dolfinx.fem.Expression(uh, points)
         t.interpolate(expr)
     else:
         t = uh

{cardiac_geometriesx-0.4.4 → cardiac_geometriesx-0.4.6}/src/cardiac_geometries/geometry.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import shutil
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -13,6 +14,8 @@ from packaging.version import Version
 
 from . import utils
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass  # (frozen=True, slots=True)
 class Geometry:
@@ -139,15 +142,17 @@ class Geometry:
     @classmethod
     def from_folder(cls, comm: MPI.Intracomm, folder: str | Path) -> "Geometry":
         folder = Path(folder)
-
+        logger.info(f"Reading geometry from {folder}")
         # Read mesh
         if (folder / "mesh.xdmf").exists():
+            logger.debug("Reading mesh")
             mesh, tags = utils.read_mesh(comm=comm, filename=folder / "mesh.xdmf")
         else:
             raise ValueError("No mesh file found")
 
         # Read markers
         if (folder / "markers.json").exists():
+            logger.debug("Reading markers")
             if comm.rank == 0:
                 markers = json.loads((folder / "markers.json").read_text())
             else:
@@ -168,10 +173,12 @@ class Geometry:
         functions = {}
         microstructure_path = folder / "microstructure.bp"
         if microstructure_path.exists():
+            logger.debug("Reading microstructure")
             # function_space = adios4dolfinx.read_attributes(
             #     comm=MPI.COMM_WORLD, filename=microstructure_path, name="function_space"
             # )
             for name, el in microstructure.items():
+                logger.debug(f"Reading {name}")
                 element = utils.array2element(el)
                 V = dolfinx.fem.functionspace(mesh, element)
                 f = dolfinx.fem.Function(V, name=name)

{cardiac_geometriesx-0.4.4 → cardiac_geometriesx-0.4.6}/src/cardiac_geometries/mesh.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import datetime
 import json
 import math
@@ -7,9 +9,11 @@ from pathlib import Path
 from mpi4py import MPI
 
 import cardiac_geometries_core as cgc
+import dolfinx
 from structlog import get_logger
 
 from . import utils
+from .fibers.utils import save_microstructure
 from .geometry import Geometry
 
 meta = metadata("cardiac-geometriesx")
@@ -18,6 +22,132 @@ __version__ = meta["Version"]
 logger = get_logger()
 
 
+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,
+    fiber_angle_endo: float = 60,
+    fiber_angle_epi: float = -60,
+    fiber_space: str = "P_1",
+    comm: MPI.Comm = MPI.COMM_WORLD,
+) -> Geometry:
+    try:
+        import ukb.cli
+    except ImportError as e:
+        msg = (
+            "To create the UKB mesh you need to install the ukb package "
+            "which you can install with pip install ukb-atlas"
+        )
+        raise ImportError(msg) from e
+
+    if comm.rank == 0:
+        print(comm.rank)
+        ukb.cli.main(
+            [
+                str(outdir),
+                "--mode",
+                str(mode),
+                "--std",
+                str(std),
+                "--case",
+                case,
+                "--mesh",
+                "--char_length_max",
+                str(char_length_max),
+                "--char_length_min",
+                str(char_length_min),
+            ]
+        )
+    comm.barrier()
+    outdir = Path(outdir)
+    mesh_name = outdir / f"{case}.msh"
+
+    geometry = utils.gmsh2dolfin(comm=comm, msh_file=mesh_name)
+
+    if comm.rank == 0:
+        (outdir / "markers.json").write_text(
+            json.dumps(geometry.markers, default=utils.json_serial)
+        )
+        (outdir / "info.json").write_text(
+            json.dumps(
+                {
+                    "mode": mode,
+                    "std": std,
+                    "case": case,
+                    "char_length_max": char_length_max,
+                    "char_length_min": char_length_min,
+                    "fiber_angle_endo": fiber_angle_endo,
+                    "fiber_angle_epi": fiber_angle_epi,
+                    "fiber_space": fiber_space,
+                    "cardiac_geometry_version": __version__,
+                    "type": "ukb",
+                    "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)
+
+    # base_marker = 3
+    # indices = []
+    # for k in ["PV", "TV", "AV", "MV"]:
+    #     indices.append(geometry.ffun.find(geometry.markers[k][0]))
+    # indices = np.hstack(comm.allreduce(indices, op=MPI.SUM))
+    # values = np.full(len(indices), base_marker, dtype=np.int32)
+
+    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,
+    )
+
+    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
+
+        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
+
+
 def biv_ellipsoid(
     outdir: str | Path,
     char_length: float = 0.5,
@@ -199,10 +329,11 @@ def biv_ellipsoid(
             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
+            mesh=geometry.mesh,
+            functions=(system.f0, system.s0, system.n0),
+            outdir=outdir,
         )
 
     geo = Geometry.from_folder(comm=comm, folder=outdir)

{cardiac_geometriesx-0.4.4 → cardiac_geometriesx-0.4.6}/src/cardiac_geometries/utils.py

@@ -10,6 +10,7 @@ from mpi4py import MPI
 import basix
 import dolfinx
 import numpy as np
+from dolfinx.graph import adjacencylist
 from packaging.version import Version
 from structlog import get_logger
 
@@ -184,7 +185,8 @@ def model_to_mesh(
     )
 
     mesh.topology.create_connectivity(mesh.topology.dim, 0)
-    adj = dolfinx.cpp.graph.AdjacencyList_int32(local_entities)
+    # adj = dolfinx.cpp.graph.AdjacencyList_int32(local_entities)
+    adj = adjacencylist(local_entities)
     ct = dolfinx.mesh.meshtags_from_entities(
         mesh, mesh.topology.dim, adj, local_values.astype(np.int32, copy=False)
     )
@@ -213,7 +215,7 @@ def model_to_mesh(
         )
 
         mesh.topology.create_connectivity(topology.dim - 1, tdim)
-        adj = dolfinx.cpp.graph.AdjacencyList_int32(local_entities)
+        adj = adjacencylist(local_entities)
 
         ft = dolfinx.io.gmshio.meshtags_from_entities(
             mesh, tdim - 1, adj, local_values.astype(np.int32, copy=False)
@@ -236,7 +238,7 @@ def model_to_mesh(
             mesh, tdim - 2, marked_edges, edge_values
         )
         mesh.topology.create_connectivity(topology.dim - 2, tdim)
-        adj = dolfinx.cpp.graph.AdjacencyList_int32(local_entities)
+        adj = adjacencylist(local_entities)
         et = dolfinx.io.gmshio.meshtags_from_entities(
             mesh, tdim - 2, adj, local_values.astype(np.int32, copy=False)
         )
@@ -258,7 +260,7 @@ def model_to_mesh(
             mesh, tdim - 3, marked_vertices, vertex_values
         )
         mesh.topology.create_connectivity(topology.dim - 3, tdim)
-        adj = dolfinx.cpp.graph.AdjacencyList_int32(local_entities)
+        adj = adjacencylist(local_entities)
         vt = dolfinx.io.gmshio.meshtags_from_entities(
             mesh, tdim - 3, adj, local_values.astype(np.int32, copy=False)
         )
@@ -420,49 +422,89 @@ def read_mesh(
 def gmsh2dolfin(comm: MPI.Intracomm, msh_file, rank: int = 0) -> GMshGeometry:
     logger.debug(f"Convert file {msh_file} to dolfin")
     outdir = Path(msh_file).parent
+    outdir.mkdir(parents=True, exist_ok=True)
+
+    if Version(dolfinx.__version__) >= Version("0.10.0"):
+        mesh_data = dolfinx.io.gmshio.read_from_msh(comm=comm, filename=msh_file)
+        mesh = mesh_data.mesh
+        markers_ = mesh_data.physical_groups
+        ct = mesh_data.cell_tags
+        tdim = mesh.topology.dim
+        if ct is None:
+            ct = dolfinx.mesh.meshtags(
+                mesh, tdim, np.empty(0, dtype=np.int32), np.empty(0, dtype=np.int32)
+            )
+
+        ft = mesh_data.facet_tags
+        if ft is None:
+            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 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 vt is None:
+            vt = dolfinx.mesh.meshtags(
+                mesh, tdim - 3, np.empty(0, dtype=np.int32), np.empty(0, dtype=np.int32)
+            )
+
+        markers = {k: tuple(reversed(v)) for k, v in markers_.items()}
 
-    import gmsh
+    else:
+        import gmsh
+
+        # We could make this work in parallel in the future
+
+        if comm.rank == rank:
+            gmsh.initialize()
+            gmsh.model.add("Mesh from file")
+            gmsh.merge(str(msh_file))
+            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, et, vt = model_to_mesh(gmsh.model, comm, 0)
+            markers = {}
 
-    # We could make this work in parallel in the future
+        markers = comm.bcast(markers, root=rank)
 
-    if comm.rank == rank:
-        gmsh.initialize()
-        gmsh.model.add("Mesh from file")
-        gmsh.merge(str(msh_file))
-        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, 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)
         xdmf.write_meshtags(
-            ct, mesh.geometry, geometry_xpath=f"/Xdmf/Domain/Grid[@Name='{mesh.name}']/Geometry"
+            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"
+            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"
+            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"
+            vt,
+            mesh.geometry,
+            geometry_xpath=f"/Xdmf/Domain/Grid[@Name='{mesh.name}']/Geometry",
         )
 
     return GMshGeometry(mesh, ct, ft, et, vt, markers)

{cardiac_geometriesx-0.4.4 → cardiac_geometriesx-0.4.6/src/cardiac_geometriesx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: cardiac-geometriesx
-Version: 0.4.4
+Version: 0.4.6
 Summary: A python library for cardiac geometries
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT
@@ -33,10 +33,13 @@ 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"
+Requires-Dist: ukb-atlas; extra == "docs"
 Provides-Extra: test
 Requires-Dist: pre-commit; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: ukb-atlas; extra == "test"
+Requires-Dist: fenicsx-ldrb; extra == "test"
 Provides-Extra: gui
 Requires-Dist: streamlit; extra == "gui"
 Requires-Dist: stpyvista; extra == "gui"

{cardiac_geometriesx-0.4.4 → cardiac_geometriesx-0.4.6}/src/cardiac_geometriesx.egg-info/requires.txt

@@ -21,6 +21,7 @@ pyvista[all]>=0.43.0
 trame-vuetify
 ipywidgets
 fenicsx-ldrb
+ukb-atlas
 
 [gui]
 streamlit
@@ -34,3 +35,5 @@ fenicsx-ldrb
 pre-commit
 pytest
 pytest-cov
+ukb-atlas
+fenicsx-ldrb

{cardiac_geometriesx-0.4.4 → cardiac_geometriesx-0.4.6}/tests/test_cli.py

@@ -58,3 +58,31 @@ def test_script_no_fibers(script, tmp_path: Path):
 
     geo = Geometry.from_folder(comm=comm, folder=path)
     assert geo.mesh.geometry.dim == 3
+
+
+@pytest.mark.parametrize("case", ["ED", "ES"])
+def test_ukb(tmp_path: Path, case: str):
+    runner = CliRunner()
+
+    comm = MPI.COMM_WORLD
+    path = comm.bcast(tmp_path, root=0)
+
+    res = runner.invoke(
+        cli.ukb,
+        [
+            path.as_posix(),
+            "--case",
+            case,
+            "--char-length-max",
+            "10.0",
+            "--char-length-min",
+            "10.0",
+        ],
+    )
+    assert res.exit_code == 0
+    assert path.is_dir()
+
+    assert (path / "mesh.xdmf").exists()
+    assert (path / f"{case}.msh").exists()
+    geo = Geometry.from_folder(comm=comm, folder=path)
+    assert geo.mesh.geometry.dim == 3