cardiac-geometriesx 0.0.1__py3-none-any.whl

cardiac_geometries/fibers/__init__.py

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

cardiac_geometries/fibers/lv_ellipsoid.py

@@ -0,0 +1,150 @@
+from pathlib import Path
+import dolfinx
+import numpy as np
+import basix
+
+
+from . import utils
+
+
+def compute_system(
+    t_func: dolfinx.fem.Function,
+    r_short_endo=0.025,
+    r_short_epi=0.035,
+    r_long_endo=0.09,
+    r_long_epi=0.097,
+    alpha_endo: float = -60,
+    alpha_epi: float = 60,
+    **kwargs,
+) -> utils.Microstructure:
+    V = t_func.function_space
+    element = V.ufl_element()
+    mesh = V.mesh
+
+    dof_coordinates = V.tabulate_dof_coordinates()
+
+    alpha = lambda x: (alpha_endo + (alpha_epi - alpha_endo) * x) * (np.pi / 180)
+    r_long = lambda x: r_long_endo + (r_long_epi - r_long_endo) * x
+    r_short = lambda x: r_short_endo + (r_short_epi - r_short_endo) * x
+
+    drl_dt = r_long_epi - r_long_endo
+    drs_dt = r_short_epi - r_short_endo
+
+    t = t_func.x.array
+
+    rl = r_long(t)
+    rs = r_short(t)
+    al = alpha(t)
+
+    x = dof_coordinates[:, 0]
+    y = dof_coordinates[:, 1]
+    z = dof_coordinates[:, 2]
+
+    a = np.sqrt(y**2 + z**2) / rs
+    b = x / rl
+    mu = np.arctan2(a, b)
+    theta = np.pi - np.arctan2(z, -y)
+    theta[mu < 1e-7] = 0.0
+
+    e_t = np.array(
+        [
+            drl_dt * np.cos(mu),
+            drs_dt * np.sin(mu) * np.cos(theta),
+            drs_dt * np.sin(mu) * np.sin(theta),
+        ],
+    )
+    e_t = utils.normalize(e_t)
+
+    e_mu = np.array(
+        [
+            -rl * np.sin(mu),
+            rs * np.cos(mu) * np.cos(theta),
+            rs * np.cos(mu) * np.sin(theta),
+        ],
+    )
+    e_mu = utils.normalize(e_mu)
+
+    e_theta = np.array(
+        [
+            np.zeros_like(t),
+            -rs * np.sin(mu) * np.sin(theta),
+            rs * np.sin(mu) * np.cos(theta),
+        ],
+    )
+    e_theta = utils.normalize(e_theta)
+
+    f0 = np.sin(al) * e_mu + np.cos(al) * e_theta
+    f0 = utils.normalize(f0)
+
+    n0 = np.cross(e_mu, e_theta, axis=0)
+    n0 = utils.normalize(n0)
+
+    s0 = np.cross(f0, n0, axis=0)
+    s0 = utils.normalize(s0)
+
+    el = basix.ufl.element(
+        element.family_name,
+        mesh.ufl_cell().cellname(),
+        degree=element.degree,
+        discontinuous=element.discontinuous,
+        shape=(mesh.geometry.dim,),
+    )
+    Vv = dolfinx.fem.functionspace(mesh, el)
+
+    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,
+    ffun,
+    markers,
+    function_space="P_1",
+    r_short_endo=0.025,
+    r_short_epi=0.035,
+    r_long_endo=0.09,
+    r_long_epi=0.097,
+    alpha_endo: float = -60,
+    alpha_epi: float = 60,
+    outdir: str | Path | None = None,
+):
+    endo_marker = markers["ENDO"][0]
+    epi_marker = markers["EPI"][0]
+    t = utils.laplace(
+        mesh,
+        ffun,
+        endo_marker=endo_marker,
+        epi_marker=epi_marker,
+        function_space=function_space,
+    )
+
+    if outdir is not None:
+        with dolfinx.io.XDMFFile(mesh.comm, Path(outdir) / "laplace.xdmf", "w") as file:
+            file.write_mesh(mesh)
+            file.write_function(t)
+    system = compute_system(
+        t,
+        function_space=function_space,
+        r_short_endo=r_short_endo,
+        r_short_epi=r_short_epi,
+        r_long_endo=r_long_endo,
+        r_long_epi=r_long_epi,
+        alpha_endo=alpha_endo,
+        alpha_epi=alpha_epi,
+    )
+    if outdir is not None:
+        utils.save_microstructure(mesh, system, outdir)
+
+    return system

cardiac_geometries/fibers/slab.py

@@ -0,0 +1,150 @@
+from pathlib import Path
+
+import dolfinx
+import numpy as np
+import basix
+
+from . import utils
+
+
+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
+
+    Parameters
+    ----------
+    t_func : dolfin.Function
+        Solution to laplace equation with 0 on endo
+        and 1 on epi
+    alpha_endo : float, optional
+        Angle on endocardium, by default -60
+    alpha_epi : float, optional
+        Angle on epicardium, by default 60
+
+    Returns
+    -------
+    Microstructure
+        Tuple with fiber, sheet and sheet normal
+    """
+
+    V = t_func.function_space
+    element = V.ufl_element()
+    mesh = V.mesh
+
+    alpha = lambda x: (alpha_endo + (alpha_epi - alpha_endo) * x) * (np.pi / 180)
+
+    t = t_func.x.array
+
+    f0 = np.array(
+        [
+            np.cos(alpha(t)),
+            np.zeros_like(t),
+            np.sin(alpha(t)),
+        ],
+    )
+
+    s0 = np.array(
+        [
+            np.zeros_like(t),
+            np.ones_like(t),
+            np.zeros_like(t),
+        ],
+    )
+
+    n0 = np.cross(f0, s0, axis=0)
+    n0 = utils.normalize(n0)
+
+    el = basix.ufl.element(
+        element.family_name,
+        mesh.ufl_cell().cellname(),
+        degree=element.degree,
+        discontinuous=element.discontinuous,
+        shape=(mesh.geometry.dim,),
+    )
+    Vv = dolfinx.fem.functionspace(mesh, el)
+
+    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,
+    ffun: dolfinx.mesh.MeshTags,
+    markers: dict[str, tuple[int, int]],
+    alpha_endo: float,
+    alpha_epi: float,
+    function_space: str = "P_1",
+    outdir: str | Path | None = None,
+) -> utils.Microstructure:
+    """Generate microstructure for slab using LDRB algorithm
+
+    Parameters
+    ----------
+    mesh : dolfinx.mesh.Mesh
+        A slab mesh
+    ffun : dolfinx.mesh.MeshTags
+        Facet function defining the boundaries
+    markers: Dict[str, Tuple[int, int]]
+        Markers with keys Y0 and Y1 representing the endo and
+        epi planes respectively. The values should be a tuple
+        whose first value is the value of the marker (corresponding
+        to ffun) and the second value is the dimension
+    alpha_endo : float
+        Angle on the endocardium
+    alpha_epi : float
+        Angle on the epicardium
+    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
+    """
+
+    endo_marker = markers["Y0"][0]
+    epi_marker = markers["Y1"][0]
+
+    t = utils.laplace(
+        mesh,
+        ffun,
+        endo_marker=endo_marker,
+        epi_marker=epi_marker,
+        function_space=function_space,
+    )
+    if outdir is not None:
+        with dolfinx.io.XDMFFile(mesh.comm, Path(outdir) / "laplace.xdmf", "w") as file:
+            file.write_mesh(mesh)
+            file.write_function(t)
+
+    system = compute_system(
+        t,
+        alpha_endo=alpha_endo,
+        alpha_epi=alpha_epi,
+    )
+
+    if outdir is not None:
+        utils.save_microstructure(mesh, system, outdir)
+
+    return system

cardiac_geometries/fibers/utils.py

@@ -0,0 +1,84 @@
+from typing import NamedTuple
+from pathlib import Path
+
+import dolfinx
+from dolfinx.fem.petsc import LinearProblem
+import ufl
+import numpy as np
+import adios4dolfinx
+
+
+class Microstructure(NamedTuple):
+    f0: dolfinx.fem.Function
+    s0: dolfinx.fem.Function
+    n0: dolfinx.fem.Function
+
+
+def save_microstructure(
+    mesh: dolfinx.mesh.Mesh, system: Microstructure, outdir: str | Path
+) -> None:
+    from ..utils import element2array
+
+    # Save for paraview visualization
+    with dolfinx.io.XDMFFile(mesh.comm, Path(outdir) / "microstructure.xdmf", "w") as file:
+        file.write_mesh(mesh)
+        file.write_function(system.f0)
+        file.write_function(system.s0)
+        file.write_function(system.n0)
+
+    # Save with proper function space
+    filename = Path(outdir) / "microstructure.bp"
+    adios4dolfinx.write_function(u=system.f0, filename=filename)
+    adios4dolfinx.write_function(u=system.s0, filename=filename)
+    adios4dolfinx.write_function(u=system.n0, filename=filename)
+    arr = element2array(system.f0.ufl_element().basix_element)
+    adios4dolfinx.write_attributes(
+        comm=mesh.comm,
+        filename=filename,
+        name="function_space",
+        attributes={k: arr for k in ("f0", "s0", "n0")},
+    )
+
+
+def normalize(u):
+    return u / np.linalg.norm(u, axis=0)
+
+
+def laplace(
+    mesh: dolfinx.mesh.Mesh,
+    ffun: dolfinx.mesh.MeshTags,
+    endo_marker: int,
+    epi_marker: int,
+    function_space: str,
+):
+    V = dolfinx.fem.functionspace(mesh, ("Lagrange", 1))
+
+    u = ufl.TrialFunction(V)
+    v = ufl.TestFunction(V)
+    a = ufl.dot(ufl.grad(u), ufl.grad(v)) * ufl.dx
+    L = v * dolfinx.fem.Constant(mesh, dolfinx.default_scalar_type(0.0)) * ufl.dx
+
+    endo_facets = ffun.find(endo_marker)
+    endo_dofs = dolfinx.fem.locate_dofs_topological(V, 2, endo_facets)
+    epi_facets = ffun.find(epi_marker)
+    epi_dofs = dolfinx.fem.locate_dofs_topological(V, 2, epi_facets)
+    zero = dolfinx.fem.Constant(mesh, dolfinx.default_scalar_type(0.0))
+    one = dolfinx.fem.Constant(mesh, dolfinx.default_scalar_type(1.0))
+
+    endo_bc = dolfinx.fem.dirichletbc(zero, endo_dofs, V)
+    epi_bc = dolfinx.fem.dirichletbc(one, epi_dofs, V)
+
+    bcs = [endo_bc, epi_bc]
+
+    problem = LinearProblem(a, L, bcs=bcs, petsc_options={"ksp_type": "preonly", "pc_type": "lu"})
+    uh = problem.solve()
+
+    if function_space != "P_1":
+        family, degree = function_space.split("_")
+        W = dolfinx.fem.functionspace(mesh, (family, int(degree)))
+        t = dolfinx.fem.Function(W)
+        t.interpolate(uh)
+    else:
+        t = uh
+
+    return t

cardiac_geometries/geometry.py

@@ -0,0 +1,126 @@
+from dataclasses import dataclass, field
+import json
+from pathlib import Path
+import dolfinx
+from mpi4py import MPI
+import shutil
+import adios4dolfinx
+import numpy as np
+
+from . import utils
+
+
+@dataclass(frozen=True, slots=True)
+class Geometry:
+    mesh: dolfinx.mesh.Mesh
+    markers: dict[str, tuple[str, str]] = field(default_factory=dict)
+    ffun: dolfinx.mesh.MeshTags | None = None
+    cfun: dolfinx.mesh.MeshTags | None = None
+    f0: dolfinx.fem.Function | None = None
+    s0: dolfinx.fem.Function | None = None
+    n0: dolfinx.fem.Function | None = None
+
+    def save(self, path: str | Path) -> None:
+        path = Path(path)
+
+        if path.exists() and self.mesh.comm.rank == 0:
+            shutil.rmtree(path)
+        self.mesh.comm.barrier()
+        adios4dolfinx.write_mesh(mesh=self.mesh, filename=path)
+
+        adios4dolfinx.write_attributes(
+            comm=self.mesh.comm,
+            filename=path,
+            name="markers",
+            attributes={k: np.array(v, dtype=np.uint8) for k, v in self.markers.items()},
+        )
+
+        if self.ffun is not None:
+            adios4dolfinx.write_meshtags(
+                meshtags=self.ffun,
+                mesh=self.mesh,
+                filename=path,
+            )
+
+        if self.f0 is not None:
+            el = self.f0.ufl_element().basix_element
+            arr = utils.element2array(el)
+
+            adios4dolfinx.write_attributes(
+                comm=self.mesh.comm,
+                filename=path,
+                name="function_space",
+                attributes={k: arr for k in ("f0", "s0", "n0")},
+            )
+            adios4dolfinx.write_function(u=self.f0, filename=path, name="f0")
+        if self.s0 is not None:
+            adios4dolfinx.write_function(u=self.s0, filename=path, name="s0")
+        if self.n0 is not None:
+            adios4dolfinx.write_function(u=self.n0, filename=path, name="n0")
+
+    @classmethod
+    def from_file(cls, comm: MPI.Intracomm, path: str | Path) -> "Geometry":
+        path = Path(path)
+        mesh = adios4dolfinx.read_mesh(comm=comm, filename=path)
+        markers = adios4dolfinx.read_attributes(comm=comm, filename=path, name="markers")
+        ffun = adios4dolfinx.read_meshtags(mesh=mesh, meshtag_name="Facet tags", filename=path)
+        function_space = adios4dolfinx.read_attributes(
+            comm=comm, filename=path, name="function_space"
+        )
+        element = utils.array2element(function_space["f0"])
+        # Assume same function space for all functions
+        V = dolfinx.fem.functionspace(mesh, element)
+        f0 = dolfinx.fem.Function(V, name="f0")
+        s0 = dolfinx.fem.Function(V, name="s0")
+        n0 = dolfinx.fem.Function(V, name="n0")
+
+        adios4dolfinx.read_function(u=f0, filename=path, name="f0")
+        adios4dolfinx.read_function(u=s0, filename=path, name="s0")
+        adios4dolfinx.read_function(u=n0, filename=path, name="n0")
+        return cls(mesh=mesh, markers=markers, ffun=ffun, f0=f0, s0=s0, n0=n0)
+
+    @classmethod
+    def from_folder(cls, comm: MPI.Intracomm, folder: str | Path) -> "Geometry":
+        folder = Path(folder)
+
+        # Read mesh
+        if (folder / "mesh.xdmf").exists():
+            mesh, cfun = utils.read_mesh(comm=comm, filename=folder / "mesh.xdmf")
+        else:
+            raise ValueError("No mesh file found")
+
+        # Read meshtags
+        if (folder / "triangle_mesh.xdmf").exists():
+            ffun = utils.read_ffun(mesh=mesh, filename=folder / "triangle_mesh.xdmf")
+        else:
+            ffun = None
+
+        # Read markers
+        if (folder / "markers.json").exists():
+            if comm.rank == 0:
+                markers = json.loads((folder / "markers.json").read_text())
+            else:
+                markers = {}
+            markers = comm.bcast(markers, root=0)
+        else:
+            markers = {}
+
+        microstructure_path = folder / "microstructure.bp"
+        if microstructure_path.exists():
+            function_space = adios4dolfinx.read_attributes(
+                comm=MPI.COMM_WORLD, filename=microstructure_path, name="function_space"
+            )
+            # Assume same function space for all functions
+            element = utils.array2element(function_space["f0"])
+            V = dolfinx.fem.functionspace(mesh, element)
+            f0 = dolfinx.fem.Function(V, name="f0")
+            s0 = dolfinx.fem.Function(V, name="s0")
+            n0 = dolfinx.fem.Function(V, name="n0")
+
+            adios4dolfinx.read_function(u=f0, filename=microstructure_path, name="f0")
+            adios4dolfinx.read_function(u=s0, filename=microstructure_path, name="s0")
+            adios4dolfinx.read_function(u=n0, filename=microstructure_path, name="n0")
+        else:
+            f0 = s0 = n0 = None
+
+        return cls(mesh=mesh, ffun=ffun, cfun=cfun, markers=markers, f0=f0, s0=s0, n0=n0)