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

cardiac_geometries/cli.py

@@ -8,8 +8,10 @@ from . import mesh
 
 meta = metadata("cardiac-geometriesx")
 __version__ = meta["Version"]
-__author__ = meta["Author"]
+__author__ = meta["Author-email"]
 __license__ = meta["License"]
+__email__ = meta["Author-email"]
+__program_name__ = meta["Name"]
 
 
 @click.group()
@@ -867,8 +869,20 @@ def slab_in_bath(
     geo.save(outdir / "slab_in_bath.bp")
 
 
+@click.command("gui")
+def gui():
+    # Make sure we can import the required packages
+    from . import gui  # noqa: F401
+
+    gui_path = Path(__file__).parent.joinpath("gui.py")
+    import subprocess as sp
+
+    sp.run(["streamlit", "run", gui_path.as_posix()])
+
+
 app.add_command(lv_ellipsoid)
 app.add_command(biv_ellipsoid)
 app.add_command(biv_ellipsoid_torso)
 app.add_command(slab)
 app.add_command(slab_in_bath)
+app.add_command(gui)

cardiac_geometries/fibers/lv_ellipsoid.py

@@ -1,9 +1,9 @@
 from pathlib import Path
 
-import basix
 import dolfinx
 import numpy as np
 
+from ..utils import space_from_string
 from . import utils
 
 
@@ -82,14 +82,9 @@ def compute_system(
     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 = space_from_string(
+        space_string=f"{element.family_name}_{element.degree}", mesh=mesh, dim=mesh.geometry.dim
     )
-    Vv = dolfinx.fem.functionspace(mesh, el)
 
     fiber = dolfinx.fem.Function(Vv)
     norm_f = np.linalg.norm(f0, axis=0)
@@ -131,10 +126,13 @@ def create_microstructure(
     )
 
     if outdir is not None:
-        with dolfinx.io.VTXWriter(
-            mesh.comm, Path(outdir) / "laplace.bp", [t], engine="BP4"
-        ) as file:
-            file.write(0.0)
+        try:
+            with dolfinx.io.VTXWriter(
+                mesh.comm, Path(outdir) / "laplace.bp", [t], engine="BP4"
+            ) as file:
+                file.write(0.0)
+        except RuntimeError:
+            pass
 
     system = compute_system(
         t,

cardiac_geometries/fibers/slab.py

@@ -1,9 +1,9 @@
 from pathlib import Path
 
-import basix
 import dolfinx
 import numpy as np
 
+from ..utils import space_from_string
 from . import utils
 
 
@@ -59,14 +59,9 @@ def compute_system(
     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 = space_from_string(
+        space_string=f"{element.family_name}_{element.degree}", mesh=mesh, dim=mesh.geometry.dim
     )
-    Vv = dolfinx.fem.functionspace(mesh, el)
 
     fiber = dolfinx.fem.Function(Vv)
     norm_f = np.linalg.norm(f0, axis=0)
@@ -134,10 +129,13 @@ def create_microstructure(
         function_space=function_space,
     )
     if outdir is not None:
-        with dolfinx.io.VTXWriter(
-            mesh.comm, Path(outdir) / "laplace.bp", [t], engine="BP4"
-        ) as file:
-            file.write(0.0)
+        try:
+            with dolfinx.io.VTXWriter(
+                mesh.comm, Path(outdir) / "laplace.bp", [t], engine="BP4"
+            ) as file:
+                file.write(0.0)
+        except RuntimeError:
+            pass
 
     system = compute_system(
         t,

cardiac_geometries/fibers/utils.py

@@ -7,6 +7,8 @@ import numpy as np
 import ufl
 from dolfinx.fem.petsc import LinearProblem
 
+from ..utils import space_from_string
+
 
 class Microstructure(NamedTuple):
     f0: dolfinx.fem.Function
@@ -20,17 +22,20 @@ def save_microstructure(
     from ..utils import element2array
 
     # Save for paraview visualization
-    with dolfinx.io.VTXWriter(
-        mesh.comm, Path(outdir) / "microstructure-viz.bp", functions, engine="BP4"
-    ) as file:
-        file.write(0.0)
+    try:
+        with dolfinx.io.VTXWriter(
+            mesh.comm, Path(outdir) / "microstructure-viz.bp", functions, engine="BP4"
+        ) as file:
+            file.write(0.0)
+    except RuntimeError:
+        pass
 
     # Save with proper function space
     filename = Path(outdir) / "microstructure.bp"
     for function in functions:
         adios4dolfinx.write_function(u=function, filename=filename)
 
-    attributes = {f.name: element2array(f.ufl_element().basix_element) for f in functions}
+    attributes = {f.name: element2array(f.ufl_element()) for f in functions}
     adios4dolfinx.write_attributes(
         comm=mesh.comm,
         filename=filename,
@@ -73,10 +78,10 @@ def laplace(
     uh = problem.solve()
 
     if function_space != "P_1":
-        family, degree = function_space.split("_")
-        W = dolfinx.fem.functionspace(mesh, (family, int(degree)))
+        W = space_from_string(function_space, mesh, dim=1)
         t = dolfinx.fem.Function(W)
-        t.interpolate(uh)
+        expr = dolfinx.fem.Expression(uh, W.element.interpolation_points())
+        t.interpolate(expr)
     else:
         t = uh
 

cardiac_geometries/geometry.py

@@ -15,9 +15,11 @@ 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
+    markers: dict[str, tuple[int, int]] = field(default_factory=dict)
     cfun: dolfinx.mesh.MeshTags | None = None
+    ffun: dolfinx.mesh.MeshTags | None = None
+    efun: dolfinx.mesh.MeshTags | None = None
+    vfun: dolfinx.mesh.MeshTags | None = None
     f0: dolfinx.fem.Function | None = None
     s0: dolfinx.fem.Function | None = None
     n0: dolfinx.fem.Function | None = None
@@ -25,8 +27,7 @@ class Geometry:
     def save(self, path: str | Path) -> None:
         path = Path(path)
 
-        if path.exists() and self.mesh.comm.rank == 0:
-            shutil.rmtree(path)
+        shutil.rmtree(path, ignore_errors=True)
         self.mesh.comm.barrier()
         adios4dolfinx.write_mesh(mesh=self.mesh, filename=path)
 
@@ -37,15 +38,37 @@ class Geometry:
             attributes={k: np.array(v, dtype=np.uint8) for k, v in self.markers.items()},
         )
 
+        if self.cfun is not None:
+            adios4dolfinx.write_meshtags(
+                meshtags=self.cfun,
+                mesh=self.mesh,
+                filename=path,
+                meshtag_name="Cell tags",
+            )
         if self.ffun is not None:
             adios4dolfinx.write_meshtags(
                 meshtags=self.ffun,
                 mesh=self.mesh,
                 filename=path,
+                meshtag_name="Facet tags",
+            )
+        if self.efun is not None:
+            adios4dolfinx.write_meshtags(
+                meshtags=self.efun,
+                mesh=self.mesh,
+                filename=path,
+                meshtag_name="Edge tags",
+            )
+        if self.vfun is not None:
+            adios4dolfinx.write_meshtags(
+                meshtags=self.vfun,
+                mesh=self.mesh,
+                filename=path,
+                meshtag_name="Vertex tags",
             )
 
         if self.f0 is not None:
-            el = self.f0.ufl_element().basix_element
+            el = self.f0.ufl_element()
             arr = utils.element2array(el)
 
             adios4dolfinx.write_attributes(
@@ -60,26 +83,49 @@ class Geometry:
         if self.n0 is not None:
             adios4dolfinx.write_function(u=self.n0, filename=path, name="n0")
 
+        self.mesh.comm.barrier()
+
     @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)
+        tags = {}
+        for name, meshtag_name in (
+            ("cfun", "Cell tags"),
+            ("ffun", "Facet tags"),
+            ("efun", "Edge tags"),
+            ("vfun", "Vertex tags"),
+        ):
+            try:
+                tags[name] = adios4dolfinx.read_meshtags(
+                    mesh=mesh, meshtag_name=meshtag_name, filename=path
+                )
+            except KeyError:
+                tags[name] = None
+
+        functions = {}
         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)
+        for name, el in function_space.items():
+            element = utils.array2element(el)
+            V = dolfinx.fem.functionspace(mesh, element)
+            f = dolfinx.fem.Function(V, name=name)
+            try:
+                adios4dolfinx.read_function(u=f, filename=path, name=name)
+            except KeyError:
+                continue
+            else:
+                functions[name] = f
+
+        return cls(
+            mesh=mesh,
+            markers=markers,
+            **functions,
+            **tags,
+        )
 
     @classmethod
     def from_folder(cls, comm: MPI.Intracomm, folder: str | Path) -> "Geometry":
@@ -87,7 +133,7 @@ class Geometry:
 
         # Read mesh
         if (folder / "mesh.xdmf").exists():
-            mesh, cfun, ffun = utils.read_mesh(comm=comm, filename=folder / "mesh.xdmf")
+            mesh, tags = utils.read_mesh(comm=comm, filename=folder / "mesh.xdmf")
         else:
             raise ValueError("No mesh file found")
 
@@ -101,22 +147,26 @@ class Geometry:
         else:
             markers = {}
 
+        functions = {}
         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)
+            for name, el in function_space.items():
+                element = utils.array2element(el)
+                V = dolfinx.fem.functionspace(mesh, element)
+                f = dolfinx.fem.Function(V, name=name)
+                try:
+                    adios4dolfinx.read_function(u=f, filename=microstructure_path, name=name)
+                except KeyError:
+                    continue
+                else:
+                    functions[name] = f
+
+        return cls(
+            mesh=mesh,
+            markers=markers,
+            **functions,
+            **tags,
+        )

cardiac_geometries/gui.py

@@ -0,0 +1,272 @@
+try:
+    import streamlit as st
+except ImportError:
+    print("Please install streamlit - python3 -m pip install streamlit")
+    exit(1)
+
+try:
+    import pyvista as pv
+except ImportError:
+    msg = (
+        "Please install pyvista - python3 -m pip install pyvista. "
+        "Note if you using ARM Mac, then check out the following link "
+        "on how to install vtk: https://github.com/KitwareMedical/VTKPythonPackage/issues/42"
+    )
+    print(msg)
+    exit(1)
+
+try:
+    from stpyvista import stpyvista
+except ImportError:
+    print("Please install stpyvista - python3 -m pip install stpyvista")
+    exit(1)
+
+import os
+
+os.environ["GMSH_INTERRUPTIBLE"] = "0"
+
+import math
+from pathlib import Path
+
+import mpi4py
+
+import dolfinx
+
+import cardiac_geometries
+
+
+def return_none(*args, **kwargs):
+    return None
+
+
+def load_geometry(folder: str):
+    comm = mpi4py.MPI.COMM_WORLD
+    try:
+        return cardiac_geometries.geometry.Geometry.from_folder(comm, folder)
+    except Exception as e:
+        st.error(f"Error loading geometry: {e}")
+        return None
+
+
+def plot_geometry(geo):
+    V = dolfinx.fem.functionspace(geo.mesh, ("Lagrange", 1))
+
+    pv.start_xvfb()
+
+    # Plot the mesh with cell tags
+    mesh_plotter = pv.Plotter()
+    mesh_plotter.background_color = "white"
+    mesh_plotter.window_size = [600, 400]
+
+    topology, cell_types, geometry = dolfinx.plot.vtk_mesh(V)
+
+    grid = pv.UnstructuredGrid(topology, cell_types, geometry)
+    if geo.cfun is not None:
+        grid.cell_data["Cell tags"] = geo.cfun.values
+        grid.set_active_scalars("Cell tags")
+    mesh_plotter.add_mesh(grid, show_edges=True)
+
+    mesh_plotter.view_isometric()
+    st.header("Mesh and cell tags")
+    stpyvista(mesh_plotter)
+
+    if geo.ffun is not None:
+        vtk_bmesh = dolfinx.plot.vtk_mesh(geo.mesh, geo.ffun.dim, geo.ffun.indices)
+        bgrid = pv.UnstructuredGrid(*vtk_bmesh)
+        bgrid.cell_data["Facet tags"] = geo.ffun.values
+        bgrid.set_active_scalars("Facet tags")
+        facet_plotter = pv.Plotter()
+        facet_plotter.background_color = "white"
+        facet_plotter.window_size = [600, 400]
+        facet_plotter.add_mesh(bgrid, show_edges=True)
+        facet_plotter.view_isometric()
+        st.header("Facet tags")
+        stpyvista(facet_plotter)
+
+    if geo.f0 is not None:
+        st.header("Fibers")
+        size_arrows_fibers = st.slider(
+            "Arrow size fibers", min_value=0.1, max_value=10.0, value=2.0
+        )
+        topology, cell_types, geometry = dolfinx.plot.vtk_mesh(geo.f0.function_space)
+        values = geo.f0.x.array.real.reshape((geometry.shape[0], len(geo.f0)))
+        function_grid = pv.UnstructuredGrid(topology, cell_types, geometry)
+        function_grid["u"] = values
+        glyphs = function_grid.glyph(orient="u", factor=size_arrows_fibers)
+        fiber_plotter = pv.Plotter()
+        fiber_plotter.background_color = "white"
+        fiber_plotter.window_size = [600, 400]
+        fiber_plotter.add_mesh(glyphs, show_edges=True)
+        fiber_plotter.view_isometric()
+        stpyvista(fiber_plotter)
+
+    if geo.s0 is not None:
+        st.header("Sheets")
+        size_arrows_sheets = st.slider(
+            "Arrow size sheets", min_value=0.1, max_value=10.0, value=2.0
+        )
+        topology, cell_types, geometry = dolfinx.plot.vtk_mesh(geo.s0.function_space)
+        values = geo.s0.x.array.real.reshape((geometry.shape[0], len(geo.s0)))
+        function_grid = pv.UnstructuredGrid(topology, cell_types, geometry)
+        function_grid["u"] = values
+        glyphs = function_grid.glyph(orient="u", factor=size_arrows_sheets)
+        sheet_plotter = pv.Plotter()
+        sheet_plotter.background_color = "white"
+        sheet_plotter.window_size = [600, 400]
+        sheet_plotter.add_mesh(glyphs, show_edges=True)
+        sheet_plotter.view_isometric()
+        stpyvista(sheet_plotter)
+
+    if geo.n0 is not None:
+        st.header("Sheet Normal")
+        size_arrows_normal = st.slider(
+            "Arrow size sheet normal", min_value=0.1, max_value=10.0, value=2.0
+        )
+        topology, cell_types, geometry = dolfinx.plot.vtk_mesh(geo.n0.function_space)
+        values = geo.n0.x.array.real.reshape((geometry.shape[0], len(geo.n0)))
+        function_grid = pv.UnstructuredGrid(topology, cell_types, geometry)
+        function_grid["u"] = values
+        glyphs = function_grid.glyph(orient="u", factor=size_arrows_normal)
+        normal_plotter = pv.Plotter()
+        normal_plotter.background_color = "white"
+        normal_plotter.window_size = [600, 400]
+        normal_plotter.add_mesh(glyphs, show_edges=True)
+        normal_plotter.view_isometric()
+        stpyvista(normal_plotter)
+
+
+def load():
+    st.title("Load existing geometries")
+
+    cwd = Path.cwd()
+    folders = [f.name for f in cwd.iterdir() if f.is_dir()]
+    # Select a folder
+
+    folder = st.selectbox("Select a folder", folders)
+    geo = load_geometry(folder)
+
+    if geo is not None:
+        plot_geometry(geo)
+
+    return
+
+
+def create_lv():
+    st.title("Create lv geometry")
+
+    outdir = st.text_input("Output directory", value="lv_ellipsoid")
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.header("Radius")
+        r_short_endo = st.number_input("r_short_endo", value=7.0)
+        r_short_epi = st.number_input("r_short_epi", value=10.0)
+        r_long_endo = st.number_input("r_long_endo", value=17.0)
+        r_long_epi = st.number_input("r_long_epi", value=20.0)
+        p_size_ref = st.number_input("p_size_ref", value=3.0)
+
+    with col2:
+        st.header("Angles")
+        mu_apex_endo = st.number_input("mu_apex_endo", value=-math.pi)
+        mu_base_endo = st.number_input("mu_base_endo", value=-math.acos(5 / 17))
+        mu_apex_epi = st.number_input("mu_apex_epi", value=-math.pi)
+        mu_base_epi = st.number_input("mu_base_epi", value=-math.acos(5 / 20))
+
+    with col3:
+        st.header("Fibers")
+        create_fibers = st.checkbox("Create fibers", value=True)
+        if create_fibers:
+            fiber_space = st.selectbox("Fiber space", ["P_1", "P_2"])
+            fiber_angle_endo = st.number_input("fiber_angle_endo", value=60)
+            fiber_angle_epi = st.number_input("fiber_angle_epi", value=-60)
+
+    if st.button("Create"):
+        args = [
+            "geox",
+            "lv-ellipsoid",
+            "--r-short-endo",
+            str(r_short_endo),
+            "--r-short-epi",
+            str(r_short_epi),
+            "--r-long-endo",
+            str(r_long_endo),
+            "--r-long-epi",
+            str(r_long_epi),
+            "--mu-apex-endo",
+            str(mu_apex_endo),
+            "--mu-base-endo",
+            str(mu_base_endo),
+            "--mu-apex-epi",
+            str(mu_apex_epi),
+            "--mu-base-epi",
+            str(mu_base_epi),
+            "--psize-ref",
+            str(p_size_ref),
+        ]
+
+        if create_fibers:
+            args.extend(
+                [
+                    "--create-fibers",
+                    "--fiber-space",
+                    fiber_space,
+                    "--fiber-angle-endo",
+                    str(fiber_angle_endo),
+                    "--fiber-angle-epi",
+                    str(fiber_angle_epi),
+                ]
+            )
+
+        args.append(str(outdir))
+        st.markdown(f"```{' '.join(args)}```")
+
+        if Path(outdir).exists():
+            st.warning(f"Folder {outdir} already exists. Overwriting...")
+            import shutil
+
+            shutil.rmtree(outdir)
+
+        import subprocess as sp
+
+        ret = sp.run(
+            args,
+            capture_output=True,
+        )
+
+        st.markdown(f"```{ret.stdout.decode()}```")
+
+    if st.button("Visualize folder"):
+        geo = load_geometry(outdir)
+
+        if geo is not None:
+            plot_geometry(geo)
+
+    return
+
+
+# Page settings
+st.set_page_config(page_title="simcardems")
+
+# Sidebar settings
+pages = {
+    "Load": load,
+    "Create LV geometry": create_lv,
+}
+
+st.sidebar.title("Cardiac geometries")
+
+# Radio buttons to select desired option
+page = st.sidebar.radio("Pages", tuple(pages.keys()))
+
+pages[page]()
+
+# About
+st.sidebar.markdown(
+    """
+- [Source code](https://github.com/ComputationalPhysiology/cardiac-geometriesx)
+- [Documentation](http://computationalphysiology.github.io/cardiac-geometriesx)
+
+
+Copyright © 2024 Henrik Finsberg @ Simula Research Laboratory
+""",
+)