circulation 0.1.0__py3-none-any.whl

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/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/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/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)

circulation/lv_only_reg.py

@@ -0,0 +1,166 @@
+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"])
+
+        ############ Valves
+        valves = self.parameters["valves"]
+
+        if self._add_units:
+            unit_R = 1 * mmHg * s / mL
+            unit_p = 1 * mmHg
+        else:
+            unit_R = 1
+            unit_p = 1
+
+        self.R_AV = self._R(
+            valves["AV"]["Rmin"], valves["AV"]["Rmax"], unit_R=unit_R, unit_p=unit_p
+        )
+        self.R_MV = self._R(
+            valves["MV"]["Rmin"], valves["MV"]["Rmax"], unit_R=unit_R, unit_p=unit_p
+        )
+
+        ############ PV relationships
+        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.08 * mmHg / mL,
+                    "TC": 0.34 * s,
+                    "TR": 0.17 * s,
+                    "tC": 0.00 * s,
+                    "V0": 5.0 * mL,
+                },
+            },
+            "valves": {
+                "MV": {
+                    "Rmin": 0.0075 * mmHg * s / mL,
+                    "Rmax": 75006.2 * mmHg * s / mL,
+                },
+                "AV": {
+                    "Rmin": 0.0075 * mmHg * s / mL,
+                    "Rmax": 75006.2 * mmHg * s / mL,
+                },
+            },
+            "circulation": {
+                "SYS": {
+                    "R_AR": 0.8 * mmHg * s / mL,
+                    "C_AR": 1.2 * mL / mmHg,
+                    "R_VEN": 0.26 * mmHg * s / mL,
+                    "C_VEN": 60.0 * mL / mmHg,
+                    "L_AR": 5e-3 * mmHg * s**2 / mL,
+                    "L_VEN": 5e-4 * mmHg * s**2 / mL,
+                },
+            },
+        }
+
+    @staticmethod
+    def default_initial_conditions() -> dict[str, float]:
+        return {
+            "V_LA": 65.0 * mL,
+            "V_LV": 120.0 * mL,
+            "V_RA": 65.0 * mL,
+            "V_RV": 145.0 * mL,
+            "p_AR_SYS": 80.0 * mmHg,
+            "p_VEN_SYS": 30.0 * mmHg,
+            "p_AR_PUL": 35.0 * mmHg,
+            "p_VEN_PUL": 24.0 * mmHg,
+            "Q_AR_SYS": 0.0 * mL / s,
+            "Q_VEN_SYS": 0.0 * mL / s,
+            "Q_AR_PUL": 0.0 * mL / s,
+            "Q_VEN_PUL": 0.0 * mL / s,
+        }
+
+    def update_static_variables(self, t):
+        self.var["p_LV"] = self.p_LV_func(self.state["V_LV"], t)
+        self.var["Q_AV"] = self.flux_through_valve(
+            self.var["p_LV"], self.state["p_AR_SYS"], self.R_AV
+        )
+        self.var["Q_MV"] = self.flux_through_valve(
+            self.state["p_VEN_SYS"], self.var["p_LV"], self.R_MV
+        )
+
+    def step(self, t, dt):
+        self.update_static_variables(t)
+
+        Q_VEN_SYS = self.state["Q_VEN_SYS"]
+        Q_AR_SYS = self.state["Q_AR_SYS"]
+        Q_AV = self.var["Q_AV"]
+        Q_MV = self.var["Q_MV"]
+
+        p_LV = self.var["p_LV"]
+        p_AR_SYS = self.state["p_AR_SYS"]
+        p_VEN_SYS = self.state["p_VEN_SYS"]
+
+        C_VEN_SYS = self.parameters["circulation"]["SYS"]["C_VEN"]
+        C_AR_SYS = self.parameters["circulation"]["SYS"]["C_AR"]
+        R_AR_SYS = self.parameters["circulation"]["SYS"]["R_AR"]
+        R_VEN_SYS = self.parameters["circulation"]["SYS"]["R_VEN"]
+        L_AR_SYS = self.parameters["circulation"]["SYS"]["L_AR"]
+        L_VEN_SYS = self.parameters["circulation"]["SYS"]["L_VEN"]
+
+        self.state["V_LV"] += dt * (Q_MV - Q_AV)
+
+        self.state["p_AR_SYS"] += dt * (Q_AV - Q_AR_SYS) / C_AR_SYS
+        self.state["p_VEN_SYS"] += dt * (Q_AR_SYS - Q_VEN_SYS) / C_VEN_SYS
+        self.state["Q_AR_SYS"] += (
+            -dt * (R_AR_SYS * Q_AR_SYS + p_VEN_SYS - p_AR_SYS) / L_AR_SYS
+        )
+        self.state["Q_VEN_SYS"] += (
+            -dt * (R_VEN_SYS * Q_VEN_SYS + p_LV - p_VEN_SYS) / L_VEN_SYS
+        )
+
+    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)