circulation 0.1.0__tar.gz

circulation-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2024 Henrik Finsberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

circulation-0.1.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.1
+Name: circulation
+Version: 0.1.0
+Summary: Closed loop blood circulation model in FEniCS
+Author-email: Henrik Finsberg <henriknf@simula.no>
+License: Copyright 2024 Henrik Finsberg
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pint
+Requires-Dist: rich
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Provides-Extra: demos
+Requires-Dist: matplotlib; extra == "demos"
+Provides-Extra: docs
+Requires-Dist: jupyter-book; extra == "docs"
+Requires-Dist: jupytext; extra == "docs"
+Requires-Dist: circulation[demos]; extra == "docs"
+Provides-Extra: all
+Requires-Dist: circulation[test]; extra == "all"
+Requires-Dist: circulation[plot]; extra == "all"
+Requires-Dist: circulation[docs]; extra == "all"
+Requires-Dist: circulation[dev]; extra == "all"
+
+# Cardiac circulation models
+
+TBW
+
+
+## Install
+
+```
+python -m pip install circulation
+```

circulation-0.1.0/README.md

@@ -0,0 +1,10 @@
+# Cardiac circulation models
+
+TBW
+
+
+## Install
+
+```
+python -m pip install circulation
+```

circulation-0.1.0/pyproject.toml

@@ -0,0 +1,118 @@
+[build-system] # Require setuptool version due to https://github.com/pypa/setuptools/issues/2938
+requires = ["setuptools>=61.0.0", "wheel"]
+
+[project]
+name = "circulation"
+version = "0.1.0"
+description = "Closed loop blood circulation model in FEniCS"
+authors = [{ name = "Henrik Finsberg", email = "henriknf@simula.no" }]
+license = { file = "LICENSE" }
+readme = "README.md"
+dependencies = [
+    "numpy",
+    "pint",
+    "rich"
+]
+
+
+[project.optional-dependencies]
+test = ["pytest", "pytest-cov"]
+demos = ["matplotlib"]
+docs = ["jupyter-book", "jupytext", "circulation[demos]"]
+all = [
+    "circulation[test]",
+    "circulation[plot]",
+    "circulation[docs]",
+    "circulation[dev]",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+
+[tool.pytest.ini_options]
+addopts = [
+    "--cov=circulation",
+    "--cov-report=html",
+    "--cov-report=term-missing",
+    "-v",
+]
+
+testpaths = ["tests"]
+
+[tool.mypy]
+files = ["src/circulation", "tests"]
+ignore_missing_imports = true
+exclude = [
+    "docs",
+    "examples",
+]
+
+
+
+[tool.ruff]
+
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    "examples",
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+]
+
+# Same as Black.
+line-length = 100
+
+# Assume Python 3.10.
+target-version = "py310"
+
+[tool.ruff.lint]
+# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
+select = ["E", "F"]
+ignore = ["E402", "E741", "E743", "E731"]
+
+# Allow autofix for all enabled rules (when `--fix`) is provided.
+fixable = ["A", "B", "C", "D", "E", "F"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+
+[tool.ruff.lint.mccabe]
+# Unlike Flake8, default to a complexity level of 10.
+max-complexity = 10
+
+
+[tool.bumpversion]
+allow_dirty = false
+commit = true
+message = "Bump version: {current_version} → {new_version}"
+tag = true
+sign_tags = false
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+current_version = "1.1.2"
+
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = 'version = "{current_version}"'
+replace = 'version = "{new_version}"'

circulation-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

circulation-0.1.0/src/circulation/__init__.py

@@ -0,0 +1,3 @@
+from . import base, log, regazzoni2020, zenkur, units, time_varying_elastance
+
+__all__ = ["base", "log", "regazzoni2020", "zenkur", "units", "time_varying_elastance"]

circulation-0.1.0/src/circulation/base.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+from typing import Callable, Any
+from abc import ABC, abstractmethod
+import json
+from collections import defaultdict
+import numpy as np
+import time
+import logging
+from rich.table import Table
+
+from . import units
+from . import time_varying_elastance
+from . import log
+
+
+logger = logging.getLogger(__name__)
+
+
+def smooth_heavyside(x):
+    return np.arctan(np.pi / 2 * x * 200) * 1 / np.pi + 0.5
+
+
+def remove_units(parameters: dict[str, Any]) -> dict[str, Any]:
+    d = {}
+    for k, v in parameters.items():
+        if isinstance(v, units.pint.Quantity):
+            d[k] = v.magnitude
+        elif isinstance(v, dict):
+            d[k] = remove_units(v)
+        else:
+            d[k] = v
+    return d
+
+
+class CirculationModel(ABC):
+    def __init__(
+        self,
+        parameters: dict[str, Any] | None = None,
+        add_units: bool = False,
+        callback: Callable[[float], None] | None = None,
+        verbose: bool = False,
+    ):
+        self.parameters = type(self).default_parameters()
+        if parameters is not None:
+            self.parameters.update(parameters)
+        if not add_units:
+            self.parameters = remove_units(self.parameters)
+        self._add_units = add_units
+
+        if callback is not None:
+            assert callable(callback), "callback must be callable"
+
+            self.callback = callback
+        else:
+            self.callback = lambda t: None
+        self._verbose = verbose
+
+    def _initialize(self):
+        self.var = {}
+        self.state = type(self).default_initial_conditions()
+        self.update_state()
+        self.update_static_variables(0.0)
+
+    @property
+    def THB(self):
+        if self._add_units:
+            return (1 / self.parameters["BPM"]).to(units.ureg("s"))
+
+        return 60.0 / self.parameters["BPM"]
+
+    @staticmethod
+    @abstractmethod
+    def default_parameters() -> dict[str, Any]: ...
+
+    @abstractmethod
+    def update_static_variables(self, t: float):
+        pass
+
+    def update_state(self, state: dict[str, float] | None = None):
+        if state is not None:
+            self.state.update(state)
+
+        if not self._add_units:
+            self.state = remove_units(self.state)
+
+    @staticmethod
+    @abstractmethod
+    def default_initial_conditions() -> dict[str, float]: ...
+
+    def time_varying_elastance(self, EA, EB, tC, TC, TR, **kwargs):
+        return time_varying_elastance.blanco_ventricle(
+            EA=EA,
+            EB=EB,
+            tC=tC,
+            TC=TC,
+            TR=TR,
+            THB=self.THB,
+        )
+
+    def flux_through_valve(self, p1, p2, R):
+        return (p1 - p2) / R(p1, p2)
+
+    def _R(
+        self,
+        Rmin: float,
+        Rmax: float,
+        unit_R: float = 1.0,
+        unit_p: float = 1.0,
+    ) -> Callable[[float, float], float]:
+        return lambda w, v: unit_R * 10.0 ** (
+            np.log10(Rmin / unit_R)
+            + (np.log10(Rmax / unit_R) - np.log10(Rmin / unit_R))
+            * smooth_heavyside((v - w) / unit_p)
+        )
+
+    @abstractmethod
+    def step(self, t: float, dt: float) -> None: ...
+
+    def solve(
+        self,
+        T: float | None = None,
+        num_cycles: int | None = None,
+        initial_state: dict[str, float] | None = None,
+        dt: float = 1e-3,
+        dt_eval: float | None = None,
+    ):
+        logger.info("Running circulation model")
+        if T is None:
+            assert num_cycles is not None, "Please provide num_cycles or T"
+            T = self.THB * num_cycles
+
+        initial_state = initial_state or dict()
+
+        if dt_eval is None:
+            output_every_n_steps = 1
+        else:
+            output_every_n_steps = np.round(dt_eval / dt)
+
+        self.update_state(state=initial_state)
+        self.initialize_output()
+        t = 0.0
+        if self._add_units:
+            t *= units.ureg("s")
+            dt *= units.ureg("s")
+
+        self.store(t)
+
+        time_start = time.time()
+
+        i = 0
+        while t < T:
+            self.callback(t)
+            self.step(t, dt)
+            if i % output_every_n_steps == 0:
+                self.store(t)
+            if self._verbose:
+                self.print_info()
+            t += dt
+            i += 1
+
+        duration = time.time() - time_start
+
+        logger.info("Done running circulation model in elapsed time %1.4f s" % duration)
+        return self.results
+
+    def initialize_output(self):
+        self.results = defaultdict(list)
+
+    def store(self, t):
+        get = lambda x: x if not self._add_units else x.magnitude
+
+        self.results["time"].append(get(t))
+        for k, v in self.state.items():
+            self.results[k].append(get(v))
+        for k, v in self.var.items():
+            self.results[k].append(get(v))
+
+    def save_state(self, filename):
+        with open(filename, mode="w", newline="") as outfile:
+            json.dump(self.state, outfile, indent=2)
+
+    @property
+    def volumes(self) -> dict[str, float]:
+        return {}
+
+    @property
+    def pressures(self) -> dict[str, float]:
+        return {}
+
+    @property
+    def flows(self) -> dict[str, float]:
+        return {}
+
+    def print_info(self):
+        msg = []
+        for attr, title in [
+            (self.volumes, "Volumes"),
+            (self.pressures, "Pressures"),
+            (self.flows, "Flows"),
+        ]:
+            table = Table(title=title)
+            row = []
+            for k, v in attr.items():
+                table.add_column(k)
+                row.append(f"{v:.3f}")
+            table.add_row(*row)
+            msg.append(f"\n{log.log_table(table)}")
+        logger.info("".join(msg))

circulation-0.1.0/src/circulation/log.py

@@ -0,0 +1,24 @@
+import logging
+from rich.logging import RichHandler
+from rich.console import Console
+from rich.text import Text
+
+
+def log_table(rich_table):
+    """Generate an ascii formatted presentation of a Rich table
+    Eliminates any column styling
+    """
+    console = Console(width=150)
+    with console.capture() as capture:
+        console.print(rich_table)
+    return Text.from_ansi(capture.get())
+
+
+def setup_logging(level=logging.DEBUG, comm=None):
+    handlers = [RichHandler(console=Console(width=200))]
+    if comm is not None:
+        handlers[0].addFilter(lambda record: 1 if comm.rank == 0 else 0)
+    logging.basicConfig(
+        level=level,
+        handlers=handlers,
+    )

circulation-0.1.0/src/circulation/lv_only.py

@@ -0,0 +1,115 @@
+import numpy as np
+import json
+import time
+from collections import defaultdict
+# from scipy.integrate import RK45, solve_ivp
+
+
+from . import base
+from . import units
+
+mL = units.ureg("mL")
+mmHg = units.ureg("mmHg")
+s = units.ureg("s")
+
+
+class LVOnly(base.CirculationModel):
+    """
+    0D model of the left ventricle only.
+
+    """
+
+    def __init__(self, parameters: dict[str, float] | None = None, add_units=False):
+        super().__init__(parameters, add_units=add_units)
+
+        ############ Chambers
+        chambers = self.parameters["chambers"]
+
+        self.E_LV = self.time_varying_elastance(**chambers["LV"])
+        self.p_LV_func = lambda V, t: self.E_LV(t) * (V - chambers["LV"]["V0"])
+        self.var = {}
+
+    @staticmethod
+    def default_parameters() -> base.CirculcationModelParams:
+        return {
+            "BPM": 75.0 * units.ureg("1/minutes"),
+            "chambers": {
+                "LV": {
+                    "EA": 2.75 * mmHg / mL,
+                    "EB": 0.008 * mmHg / mL,
+                    "TC": 0.34 * s,
+                    "TR": 0.17 * s,
+                    "tC": 0.00 * s,
+                    "V0": -9.0 * mL,
+                },
+            },
+            "circulation": {
+                "SYS": {
+                    "Rao": 0.5 * mmHg * s / mL,
+                    "R_sys": 2.5 * mmHg * s / mL,
+                    "p_dia": 10.0 * mmHg,
+                    "C_sys": 0.1 * mL / mmHg,
+                    "Pp": 4.5 * mmHg,
+                },
+            },
+        }
+
+    @staticmethod
+    def default_initial_conditions() -> dict[str, float]:
+        return {
+            "V_LV": 100.0 * mL,
+            "p_ao": 70.0 * mmHg,
+            "dp_ao_dt": 0.0 * mmHg / s,
+        }
+
+    def update_static_variables(self, t):
+        self.var["p_LV"] = self.p_LV_func(self.state["V_LV"], t)
+
+    def step(self, t, dt):
+        self.update_static_variables(t)
+
+        p_ao = self.state["p_ao"]
+        dp_ao_dt = self.state["dp_ao_dt"]
+        p_LV = self.var["p_LV"]
+
+        C_sys = self.parameters["circulation"]["SYS"]["C_sys"]
+        R_ao = self.parameters["circulation"]["SYS"]["Rao"]
+        R_sys = self.parameters["circulation"]["SYS"]["R_sys"]
+        p_dia = self.parameters["circulation"]["SYS"]["p_dia"]
+
+        Q = (p_LV - p_ao) / R_ao
+        Q_R = (p_ao - p_dia) / R_sys
+        Q_C = C_sys * dp_ao_dt
+
+        dQ_C_dt = (Q - Q_R - Q_C) / C_sys
+        d2p_ao_dt2 = dQ_C_dt
+
+        self.state["p_ao"] += dt * dp_ao_dt
+        self.state["dp_ao_dt"] += dt * d2p_ao_dt2
+        if p_LV > p_ao:
+            self.state["V_LV"] += -dt * Q
+
+    def print_info(self):
+        C_VEN_SYS = self.parameters["circulation"]["SYS"]["C_VEN"]
+        C_AR_SYS = self.parameters["circulation"]["SYS"]["C_AR"]
+
+        print("V_LV      = %4.2f mL" % self.state["V_LV"])
+        print("V_AR_SYS  = %4.2f mL" % (C_AR_SYS * self.state["p_AR_SYS"]))
+        print("V_VEN_SYS = %4.2f mL" % (C_VEN_SYS * self.state["p_VEN_SYS"]))
+
+        V_tot_heart = (
+            self.state["V_LA"]
+            + self.state["V_LV"]
+            + self.state["V_RA"]
+            + self.state["V_RV"]
+        )
+        V_tot_SYS = (
+            C_AR_SYS * self.state["p_AR_SYS"] + C_VEN_SYS * self.state["p_VEN_SYS"]
+        )
+
+        V_tot = V_tot_heart + V_tot_SYS
+        print("======================")
+        print("V (heart) = %4.2f mL" % V_tot_heart)
+        print("V (SYS)   = %4.2f mL" % V_tot_SYS)
+        print("======================")
+        print("V         = %4.2f mL" % V_tot)