cardiac-geometriesx 0.1.3__tar.gz → 0.3.0__tar.gz

{cardiac_geometriesx-0.1.3/src/cardiac_geometriesx.egg-info → cardiac_geometriesx-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cardiac-geometriesx
-Version: 0.1.3
+Version: 0.3.0
 Summary: A python library for cardiac geometries
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT
@@ -36,6 +36,13 @@ Provides-Extra: test
 Requires-Dist: pre-commit; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
+Provides-Extra: gui
+Requires-Dist: streamlit; extra == "gui"
+Requires-Dist: stpyvista; extra == "gui"
+Requires-Dist: pyvista[all]>=0.43.0; extra == "gui"
+Requires-Dist: trame-vuetify; extra == "gui"
+Requires-Dist: ipywidgets; extra == "gui"
+Requires-Dist: fenicsx-ldrb; extra == "gui"
 
 ![_](docs/_static/logo.png)
 

{cardiac_geometriesx-0.1.3 → cardiac_geometriesx-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cardiac-geometriesx"
-version = "0.1.3"
+version = "0.3.0"
 description = "A python library for cardiac geometries"
 authors = [{name = "Henrik Finsberg", email = "henriknf@simula.no"}]
 license = {text = "MIT"}
@@ -51,6 +51,15 @@ test = [
     "pytest",
     "pytest-cov",
 ]
+gui = [
+    "streamlit",
+    "stpyvista",
+    "pyvista[all]>=0.43.0",
+    "trame-vuetify",
+    "ipywidgets",
+    "fenicsx-ldrb",
+
+]
 
 [project.scripts]
 geox = "cardiac_geometries.cli:app"
@@ -164,7 +173,7 @@ tag = true
 sign_tags = false
 tag_name = "v{new_version}"
 tag_message = "Bump version: {current_version} → {new_version}"
-current_version = "0.1.3"
+current_version = "0.3.0"
 
 
 [[tool.bumpversion.files]]

{cardiac_geometriesx-0.1.3 → cardiac_geometriesx-0.3.0}/src/cardiac_geometries/cli.py

@@ -869,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_geometriesx-0.1.3 → cardiac_geometriesx-0.3.0}/src/cardiac_geometries/fibers/lv_ellipsoid.py

@@ -1,12 +1,64 @@
 from pathlib import Path
 
-import basix
 import dolfinx
 import numpy as np
 
+from ..utils import space_from_string
 from . import utils
 
 
+def mu_theta(
+    x: np.ndarray, y: np.ndarray, z: np.ndarray, long_axis: int = 0
+) -> tuple[np.ndarray, np.ndarray, list[int]]:
+    """Get the angles mu and theta from the coordinates x, y, z
+    given the long axis.
+
+    Parameters
+    ----------
+    x : np.ndarray
+        The x-coordinates
+    y : np.ndarray
+        The y-coordinates
+    z : np.ndarray
+        The z-coordinates
+    long_axis : int, optional
+        The long axis, by default 0 (x-axis)
+
+    Returns
+    -------
+    tuple[np.ndarray, np.ndarray, list[int]]
+        The angles mu and theta and the permutation of the axes
+
+    Raises
+    ------
+    ValueError
+        If the long axis is not 0, 1 or 2
+    """
+    if long_axis == 0:
+        a = np.sqrt(y**2 + z**2)
+        b = x
+        theta = np.pi - np.arctan2(z, -y)
+        perm = [0, 1, 2]
+    elif long_axis == 1:
+        a = np.sqrt(x**2 + z**2)
+        b = y
+        theta = np.pi - np.arctan2(z, -x)
+        perm = [1, 0, 2]
+    elif long_axis == 2:
+        a = np.sqrt(x**2 + y**2)
+        b = z
+        theta = np.pi - np.arctan2(x, -y)
+        perm = [2, 1, 0]
+    else:
+        raise ValueError("Invalid long_axis")
+
+    mu = np.arctan2(a, b)
+
+    theta[mu < 1e-7] = 0.0
+
+    return mu, theta, perm
+
+
 def compute_system(
     t_func: dolfinx.fem.Function,
     r_short_endo=0.025,
@@ -15,8 +67,36 @@ def compute_system(
     r_long_epi=0.097,
     alpha_endo: float = -60,
     alpha_epi: float = 60,
+    long_axis: int = 0,
     **kwargs,
 ) -> utils.Microstructure:
+    """Compute the microstructure for the given time function.
+
+    Parameters
+    ----------
+    t_func : dolfinx.fem.Function
+        Solution of the Laplace equation
+    r_short_endo : float, optional
+        Short radius at the endocardium, by default 0.025
+    r_short_epi : float, optional
+        Short radius at the epicardium, by default 0.035
+    r_long_endo : float, optional
+        Long radius at the endocardium, by default 0.09
+    r_long_epi : float, optional
+        Long radius at the epicardium, by default 0.097
+    alpha_endo : float, optional
+        Angle at the endocardium, by default -60
+    alpha_epi : float, optional
+        Angle at the epicardium, by default 60
+    long_axis : int, optional
+        Long axis, by default 0 (x-axis)
+
+    Returns
+    -------
+    utils.Microstructure
+        The microstructure
+    """
+
     V = t_func.function_space
     element = V.ufl_element()
     mesh = V.mesh
@@ -40,11 +120,7 @@ def compute_system(
     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
+    mu, theta, perm = mu_theta(x, y, z, long_axis=long_axis)
 
     e_t = np.array(
         [
@@ -52,7 +128,7 @@ def compute_system(
             drs_dt * np.sin(mu) * np.cos(theta),
             drs_dt * np.sin(mu) * np.sin(theta),
         ],
-    )
+    )[perm]
     e_t = utils.normalize(e_t)
 
     e_mu = np.array(
@@ -61,7 +137,7 @@ def compute_system(
             rs * np.cos(mu) * np.cos(theta),
             rs * np.cos(mu) * np.sin(theta),
         ],
-    )
+    )[perm]
     e_mu = utils.normalize(e_mu)
 
     e_theta = np.array(
@@ -70,7 +146,7 @@ def compute_system(
             -rs * np.sin(mu) * np.sin(theta),
             rs * np.sin(mu) * np.cos(theta),
         ],
-    )
+    )[perm]
     e_theta = utils.normalize(e_theta)
 
     f0 = np.sin(al) * e_mu + np.cos(al) * e_theta
@@ -82,14 +158,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)
@@ -118,6 +189,7 @@ def create_microstructure(
     r_long_epi=0.097,
     alpha_endo: float = -60,
     alpha_epi: float = 60,
+    long_axis: int = 0,
     outdir: str | Path | None = None,
 ):
     endo_marker = markers["ENDO"][0]
@@ -131,10 +203,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,
@@ -145,6 +220,7 @@ def create_microstructure(
         r_long_epi=r_long_epi,
         alpha_endo=alpha_endo,
         alpha_epi=alpha_epi,
+        long_axis=long_axis,
     )
     if outdir is not None:
         utils.save_microstructure(mesh, system, outdir)

{cardiac_geometriesx-0.1.3 → cardiac_geometriesx-0.3.0}/src/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_geometriesx-0.1.3 → cardiac_geometriesx-0.3.0}/src/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_geometriesx-0.1.3 → cardiac_geometriesx-0.3.0}/src/cardiac_geometries/geometry.py

@@ -68,7 +68,7 @@ class Geometry:
             )
 
         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(

cardiac_geometriesx-0.3.0/src/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
+""",
+)

{cardiac_geometriesx-0.1.3 → cardiac_geometriesx-0.3.0}/src/cardiac_geometries/utils.py

@@ -13,6 +13,9 @@ from structlog import get_logger
 
 logger = get_logger()
 
+quads = ("Quadrature", "Q", "Quad", "quadrature", "q", "quad")
+QUADNR = 42
+
 
 class GMshModel(NamedTuple):
     mesh: dolfinx.mesh.Mesh
@@ -246,11 +249,70 @@ def model_to_mesh(
     return GMshModel(mesh, ct, ft, et, vt)
 
 
-def element2array(el: basix.finite_element.FiniteElement) -> np.ndarray:
-    return np.array(
-        [int(el.family), int(el.cell_type), int(el.degree), int(el.discontinuous)],
-        dtype=np.uint8,
-    )
+def parse_element(space_string: str, mesh: dolfinx.mesh.Mesh, dim: int) -> basix.ufl._ElementBase:
+    """
+    Parse a string representation of a basix element family
+    """
+
+    family_str, degree_str = space_string.split("_")
+    kwargs = {"degree": int(degree_str), "cell": mesh.ufl_cell().cellname()}
+    if dim > 1:
+        if family_str in quads:
+            kwargs["value_shape"] = (dim,)
+        else:
+            kwargs["shape"] = (dim,)
+
+    if family_str in ["Lagrange", "P", "CG"]:
+        el = basix.ufl.element(family=basix.ElementFamily.P, discontinuous=False, **kwargs)
+    elif family_str in ["Discontinuous Lagrange", "DG", "dP"]:
+        el = basix.ufl.element(family=basix.ElementFamily.P, discontinuous=True, **kwargs)
+
+    elif family_str in quads:
+        el = basix.ufl.quadrature_element(scheme="default", **kwargs)
+    else:
+        families = list(basix.ElementFamily.__members__.keys())
+        msg = f"Unknown element family: {family_str!r}, available families: {families}"
+        raise ValueError(msg)
+    return el
+
+
+def space_from_string(
+    space_string: str, mesh: dolfinx.mesh.Mesh, dim: int
+) -> dolfinx.fem.functionspace:
+    """
+    Constructed a finite elements space from a string
+    representation of the space
+
+    Arguments
+    ---------
+    space_string : str
+        A string on the form {family}_{degree} which
+        determines the space. Example 'Lagrange_1'.
+    mesh : df.Mesh
+        The mesh
+    dim : int
+        1 for scalar space, 3 for vector space.
+    """
+    el = parse_element(space_string, mesh, dim)
+    return dolfinx.fem.functionspace(mesh, el)
+
+
+def element2array(el: basix.ufl._BlockedElement) -> np.ndarray:
+    if el.family_name in quads:
+        return np.array(
+            [QUADNR, int(el.cell_type), int(el.degree), 0],
+            dtype=np.uint8,
+        )
+    else:
+        return np.array(
+            [
+                int(el.basix_element.family),
+                int(el.cell_type),
+                int(el.degree),
+                int(el.basix_element.discontinuous),
+            ],
+            dtype=np.uint8,
+        )
 
 
 def number2Enum(num: int, enum: Iterable) -> Enum:
@@ -261,18 +323,24 @@ def number2Enum(num: int, enum: Iterable) -> Enum:
 
 
 def array2element(arr: np.ndarray) -> basix.finite_element.FiniteElement:
-    family = number2Enum(arr[0], basix.ElementFamily)
     cell_type = number2Enum(arr[1], basix.CellType)
     degree = int(arr[2])
     discontinuous = bool(arr[3])
-    # TODO: Shape is hardcoded to (3,) for now, but this should also be stored
-    return basix.ufl.element(
-        family=family,
-        cell=cell_type,
-        degree=degree,
-        discontinuous=discontinuous,
-        shape=(3,),
-    )
+    if arr[0] == QUADNR:
+        return basix.ufl.quadrature_element(
+            scheme="default", degree=degree, value_shape=(3,), cell=cell_type
+        )
+    else:
+        family = number2Enum(arr[0], basix.ElementFamily)
+
+        # TODO: Shape is hardcoded to (3,) for now, but this should also be stored
+        return basix.ufl.element(
+            family=family,
+            cell=cell_type,
+            degree=degree,
+            discontinuous=discontinuous,
+            shape=(3,),
+        )
 
 
 def handle_mesh_name(mesh_name: str = "") -> Path:

{cardiac_geometriesx-0.1.3 → cardiac_geometriesx-0.3.0/src/cardiac_geometriesx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cardiac-geometriesx
-Version: 0.1.3
+Version: 0.3.0
 Summary: A python library for cardiac geometries
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT
@@ -36,6 +36,13 @@ Provides-Extra: test
 Requires-Dist: pre-commit; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
+Provides-Extra: gui
+Requires-Dist: streamlit; extra == "gui"
+Requires-Dist: stpyvista; extra == "gui"
+Requires-Dist: pyvista[all]>=0.43.0; extra == "gui"
+Requires-Dist: trame-vuetify; extra == "gui"
+Requires-Dist: ipywidgets; extra == "gui"
+Requires-Dist: fenicsx-ldrb; extra == "gui"
 
 ![_](docs/_static/logo.png)
 

{cardiac_geometriesx-0.1.3 → cardiac_geometriesx-0.3.0}/src/cardiac_geometriesx.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 src/cardiac_geometries/__init__.py
 src/cardiac_geometries/cli.py
 src/cardiac_geometries/geometry.py
+src/cardiac_geometries/gui.py
 src/cardiac_geometries/mesh.py
 src/cardiac_geometries/utils.py
 src/cardiac_geometries/fibers/__init__.py

{cardiac_geometriesx-0.1.3 → cardiac_geometriesx-0.3.0}/src/cardiac_geometriesx.egg-info/requires.txt

@@ -21,6 +21,14 @@ trame-vuetify
 ipywidgets
 fenicsx-ldrb
 
+[gui]
+streamlit
+stpyvista
+pyvista[all]>=0.43.0
+trame-vuetify
+ipywidgets
+fenicsx-ldrb
+
 [test]
 pre-commit
 pytest

{cardiac_geometriesx-0.1.3 → cardiac_geometriesx-0.3.0}/tests/test_cli.py

@@ -16,7 +16,7 @@ from cardiac_geometries import Geometry, cli
     ],
     ids=["slab", "lv_ellipsoid"],
 )
-@pytest.mark.parametrize("fiber_space", [None, "P_1", "P_2"])
+@pytest.mark.parametrize("fiber_space", [None, "P_1", "P_2", "Quadrature_2"])
 def test_script(fiber_space, script, tmp_path: Path):
     runner = CliRunner()