physioblocks 1.0.0__py3-none-any.whl

physioblocks/library/model_components/rheology.py

@@ -0,0 +1,160 @@
+# SPDX-FileCopyrightText: Copyright INRIA
+#
+# SPDX-License-Identifier: LGPL-3.0-only
+#
+# Copyright INRIA
+#
+# This file is part of PhysioBlocks, a library mostly developed by the
+# [Ananke project-team](https://team.inria.fr/ananke) at INRIA.
+#
+# Authors:
+# - Colin Drieu
+# - Dominique Chapelle
+# - François Kimmig
+# - Philippe Moireau
+#
+# PhysioBlocks is free software: you can redistribute it and/or modify it under the
+# terms of the GNU Lesser General Public License as published by the Free Software
+# Foundation, version 3 of the License.
+#
+# PhysioBlocks is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License along with
+# PhysioBlocks. If not, see <https://www.gnu.org/licenses/>.
+
+"""
+Describes rheology models
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+from physioblocks.computing import Expression, ModelComponent, Quantity, diff, mid_point
+from physioblocks.registers import register_type
+from physioblocks.simulation import Time
+
+# Constant for the rheology model type id
+RHEOLOGY_FIBER_ADDITIVE_TYPE_ID = "rheology_fiber_additive"
+
+
+@register_type(RHEOLOGY_FIBER_ADDITIVE_TYPE_ID)
+@dataclass
+class RheologyFiberAdditiveModelComponent(ModelComponent):
+    r"""
+    Describes a Fiber Additive Rheology model implementation.
+
+    **Internal Equation:**
+
+    .. math::
+
+        \dot{e}_c + T_c - k_s \Bigl( \frac{y}{R_0}-e_c \Bigr) = 0
+
+
+    **Discretised:**
+
+    .. math::
+
+        \mu \frac{e_c^{n+1}-e_c^n}{\Delta t^n}
+        - k_s \Bigl( \frac{y^{n + \frac{1}{2}}}{R_0}-e_c^{n + \frac{1}{2}} \Bigr)
+        + T_c^{{n + \frac{1}{2}}\sharp} = 0
+
+    """
+
+    fib_deform: Quantity[np.float64]
+    """:math:`e_c` the fiber deformation"""
+
+    disp: Quantity[np.float64]
+    """:math:`y` the displacement"""
+
+    active_tension_discr: Quantity[np.float64]
+    """:math:`T_c^{{n + \frac{1}{2}}\\sharp}` the active tension discretisation"""
+
+    radius: Quantity[np.float64]
+    """:math:`R_0` sphere initial radius"""
+
+    damping_parallel: Quantity[np.float64]
+    """:math:`\\mu` the damping parallel"""
+
+    series_stiffness: Quantity[np.float64]
+    """:math:`k_s` the series stiffness"""
+
+    time: Time
+    """:math:`t` the simulation time"""
+
+    def initialize(self) -> None:
+        """
+        Initialize model's radius inverse
+        """
+        self._inv_radius = 1 / self.radius.current
+
+    def fib_deform_equation(self) -> Any:
+        """
+        Compute the equation representing the fiber deformation.
+
+        :return: the relation value
+        :rtype: np.float64
+        """
+
+        disp_mid_pt = mid_point(self.disp)
+        fib_deform_mid_pt = mid_point(self.fib_deform)
+
+        return (
+            self.active_tension_discr.new
+            + (self.damping_parallel.current * self.time.inv_dt * diff(self.fib_deform))
+            - (
+                self.series_stiffness.current
+                * (disp_mid_pt * self._inv_radius - fib_deform_mid_pt)
+            )
+        )
+
+    def dfib_deform_equation_dfib_deform(self) -> Any:
+        """
+        Compute the equation partial derivative for ``fib_deform``
+
+        :return: the partial derivative value
+        :rtype: np.float64
+        """
+
+        return (
+            self.damping_parallel.current * self.time.inv_dt
+            + self.series_stiffness.current * 0.5
+        )
+
+    def dfib_deform_equation_ddisp(self) -> np.float64:
+        """
+        Compute the equation partial derivative for ``disp``
+
+        :return: the partial derivative value
+        :rtype: np.float64
+        """
+        return -self.series_stiffness.current * self._inv_radius * 0.5
+
+    def dfib_deform_equation_dactive_tension_discr(self) -> Any:
+        """
+        Compute the equation partial derivative for the ``active_tension_discr``
+
+        :return: the partial derivative value
+        :rtype: np.float64
+        """
+        return 1.0
+
+
+# Define the expression of the equation of the model.
+_fib_deform_equation_expr = Expression(
+    1,
+    RheologyFiberAdditiveModelComponent.fib_deform_equation,
+    {
+        "fib_deform": RheologyFiberAdditiveModelComponent.dfib_deform_equation_dfib_deform,  # noqa: E501
+        "disp": RheologyFiberAdditiveModelComponent.dfib_deform_equation_ddisp,
+        "active_tension_discr": RheologyFiberAdditiveModelComponent.dfib_deform_equation_dactive_tension_discr,  # noqa: E501
+    },
+)
+
+RheologyFiberAdditiveModelComponent.declares_internal_expression(
+    "fib_deform",
+    _fib_deform_equation_expr,
+)

physioblocks/library/model_components/velocity_law.py

@@ -0,0 +1,169 @@
+# SPDX-FileCopyrightText: Copyright INRIA
+#
+# SPDX-License-Identifier: LGPL-3.0-only
+#
+# Copyright INRIA
+#
+# This file is part of PhysioBlocks, a library mostly developed by the
+# [Ananke project-team](https://team.inria.fr/ananke) at INRIA.
+#
+# Authors:
+# - Colin Drieu
+# - Dominique Chapelle
+# - François Kimmig
+# - Philippe Moireau
+#
+# PhysioBlocks is free software: you can redistribute it and/or modify it under the
+# terms of the GNU Lesser General Public License as published by the Free Software
+# Foundation, version 3 of the License.
+#
+# PhysioBlocks is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License along with
+# PhysioBlocks. If not, see <https://www.gnu.org/licenses/>.
+
+"""
+Module describing a discretized Velocity Law Block.
+
+It defines two residual giving a dynamics on the velocity and acceleration.
+"""
+
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import NDArray
+
+from physioblocks.computing import (
+    Expression,
+    ModelComponent,
+    Quantity,
+    diff,
+    mid_alpha,
+    mid_point,
+)
+from physioblocks.registers import register_type
+from physioblocks.simulation import Time
+
+# Constant for the velocity law hht type name
+VELOCITY_LAW_HHT_TYPE_ID = "velocity_law_hht"
+
+
+@dataclass
+@register_type(VELOCITY_LAW_HHT_TYPE_ID)
+class VelocityLawHHTModelComponent(ModelComponent):
+    r"""
+    Velocity law HHT quantities and equation definitions
+
+    Implement the extended version of the **HHT time integration scheme**.
+    Velocity and acceleration unknowns are introduced and solved for by
+
+    **Discretised Internal Equations:**
+
+        .. math::
+
+            \frac{\dot{y}^{n+1}-\dot{y}^n}{\Delta t^n}
+            - (\tfrac{1}{2}+\alpha)\, \ddot{y}^{n+1}
+            - (\tfrac{1}{2}-\alpha)\, \ddot{y}^n = 0
+
+        .. math::
+
+            \frac{y^{n+1}-y^n}{\Delta t^n}
+            - \dot{y}^{n + \frac{1}{2}}
+            - \frac{\alpha^2}{4}\Delta t^n\, (\ddot{y}^{n+1}-\ddot{y}^n) = 0
+    """
+
+    scheme_ts_hht: Quantity[np.float64]
+    """:math:`\\alpha` the time shift scheme"""
+
+    accel: Quantity[np.float64]
+    """:math:`\\ddot{y}` the acceleration"""
+
+    vel: Quantity[np.float64]
+    """:math:`\\dot{y}` the velocity"""
+
+    disp: Quantity[np.float64]
+    """:math:`y` the displacement"""
+
+    time: Time
+    """:math:`t` the time"""
+
+    def velocity_law_residual(self) -> NDArray[np.float64]:
+        """
+        Compute the velocity law residual
+
+        :return: the residual value
+        :rtype: NDArray[np.float64]
+        """
+        accel_mid_alpha = mid_alpha(self.accel, self.scheme_ts_hht.current)
+        vel_mid_point = mid_point(self.vel)
+
+        return np.array(
+            [
+                (self.time.inv_dt * diff(self.vel) - accel_mid_alpha),
+                (
+                    self.time.inv_dt * diff(self.disp)
+                    - vel_mid_point
+                    - np.power(self.scheme_ts_hht.current, 2)
+                    * self.time.dt
+                    / 4.0
+                    * diff(self.accel)
+                ),
+            ],
+        )
+
+    def velocity_law_residual_daccel(self) -> NDArray[np.float64]:
+        """
+        Compute the velocity law residual partial derivative for ``accel``
+
+        :return: the partial derivative for accel
+        :rtype: NDArray[np.float64]
+        """
+        return np.array(
+            [
+                -(0.5 + self.scheme_ts_hht.current),
+                -np.power(self.scheme_ts_hht.current, 2) * self.time.dt * 0.25,
+            ],
+        )
+
+    def velocity_law_residual_dvel(self) -> NDArray[np.float64]:
+        """
+        Compute the velocity law residual partial derivative for ``vel``
+
+        :return: the partial derivative for vel
+        :rtype: NDArray[np.float64]
+        """
+        return np.array(
+            [self.time.inv_dt, -0.5],
+        )
+
+    def velocity_law_residual_ddisp(self) -> NDArray[np.float64]:
+        """
+        Compute the velocity law residual partial derivative for ``disp``
+
+        :return: the partial derivative for disp
+        :rtype: NDArray[np.float64]
+        """
+        return np.array(
+            [0.0, self.time.inv_dt],
+        )
+
+
+# Define the residual expression of the velocity law and its partial derivatives
+_velocity_law_hht_expression = Expression(
+    2,
+    VelocityLawHHTModelComponent.velocity_law_residual,
+    {
+        "accel": VelocityLawHHTModelComponent.velocity_law_residual_daccel,
+        "vel": VelocityLawHHTModelComponent.velocity_law_residual_dvel,
+        "disp": VelocityLawHHTModelComponent.velocity_law_residual_ddisp,
+    },
+)
+
+VelocityLawHHTModelComponent.declares_internal_expression(
+    "vel", _velocity_law_hht_expression, 1, 0
+)
+VelocityLawHHTModelComponent.declares_internal_expression(
+    "accel", _velocity_law_hht_expression, 1, 1
+)

physioblocks/references/circulation_alone_sim.jsonc

@@ -0,0 +1,24 @@
+{
+    "type": "circulation_alone_forward_simulation",
+    "time": {
+        "start": 0.0,
+        "duration": 25.0
+    },
+    "variables_initialization": {
+        "aorta_proximal.blood_pressure": 10760.0,
+        "aorta_distal.blood_pressure": 10760.0
+    },
+    "parameters": {
+        "heart_rate": 60.0, // in beats / min
+        "aorta_proximal.resistance": 7.0e6,
+        "aorta_distal.resistance": 1.1e8,
+        "aorta_distal.time_constant": 2.0,
+        "venous.blood_pressure": 1600.0,
+        "aorta_proximal.blood_flow.min": 0.0,
+        "aorta_proximal.blood_flow.max": 0.5e-3
+
+    },
+    "output_functions":{
+        "aorta_proximal.blood_flow": {"type": "watch_quantity", "quantity": "aorta_proximal.blood_flow"}
+    } 
+}

physioblocks/references/spherical_heart_respiration_sim.jsonc

@@ -0,0 +1,33 @@
+{
+    "type": "spherical_heart_with_respiration_forward_simulation",
+    "time": {
+        "start": 0.0,
+        "duration": 25.0
+    },
+    "variables_initialization": {
+        "cavity.blood_pressure": "atrial.blood_pressure.max", // Initialization with an open atrial valve
+        "aorta_proximal.blood_pressure": 10760.0,
+        "aorta_distal.blood_pressure": 10760.0
+    },
+    "parameters": {
+        "heart_radius": 0.0340, // in m
+        "heart_thickness": 0.0113, // in m
+        "heart_contractility": 90000.0,
+        "heart_rate": 60.0, // in beats / min
+        "respiration.period": 5.0, // in seconds
+        "venous.blood_pressure": 1600.0,
+        "atrial.blood_pressure.min": 450.0,
+        "atrial.blood_pressure.max": 900.0,
+        "pleural.pressure.min": 0.0,
+        "pleural.pressure.max": 300.0,
+        "circulation_aorta_proximal.resistance": 7.0e6,
+        "circulation_aorta_distal.resistance": 1.1e8,
+        "circulation_aorta_distal.time_constant": 2.0,
+        "cavity.dynamics.hyperelastic_cst": [444.0, 2.9, 69.0, 6.5]
+    },
+    "output_functions": {
+        "atrial.blood_pressure": {"type": "watch_quantity", "quantity": "atrial.blood_pressure"},
+        "active_law.activation": {"type": "watch_quantity", "quantity": "cavity.rheology.active_law.activation"},
+        "pleural.pressure": {"type": "watch_quantity", "quantity": "pleural.pressure"}
+    }
+}

physioblocks/references/spherical_heart_sim.jsonc

@@ -0,0 +1,29 @@
+{
+    "type": "spherical_heart_forward_simulation",
+    "time": {
+        "start": 0.0,
+        "duration": 25.0
+    },
+    "variables_initialization": {
+        "cavity.blood_pressure": "atrial.blood_pressure.max", // Initialization with an open atrial valve
+        "aorta_proximal.blood_pressure": 10760.0,
+        "aorta_distal.blood_pressure": 10760.0
+    },
+    "parameters": {
+        "heart_radius": 0.0340,
+        "heart_thickness": 0.0113,
+        "heart_contractility": 90000.0,
+        "heart_rate": 60.0, // in beats / min
+        "venous.blood_pressure": 1600.0,
+        "atrial.blood_pressure.min": 450.0,
+        "atrial.blood_pressure.max": 900.0,
+        "circulation_aorta_proximal.resistance": 7.0e6,
+        "circulation_aorta_distal.resistance": 1.1e8,
+        "circulation_aorta_distal.time_constant": 2.0,
+        "cavity.dynamics.hyperelastic_cst": [444.0, 2.9, 69.0, 6.5]
+    },
+    "output_functions": {
+        "atrial.blood_pressure": {"type": "watch_quantity", "quantity": "atrial.blood_pressure"},
+        "active_law.activation": {"type": "watch_quantity", "quantity": "cavity.rheology.active_law.activation"}
+    }
+}

physioblocks/registers/__init__.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: Copyright INRIA
+#
+# SPDX-License-Identifier: LGPL-3.0-only
+#
+# Copyright INRIA
+#
+# This file is part of PhysioBlocks, a library mostly developed by the
+# [Ananke project-team](https://team.inria.fr/ananke) at INRIA.
+#
+# Authors:
+# - Colin Drieu
+# - Dominique Chapelle
+# - François Kimmig
+# - Philippe Moireau
+#
+# PhysioBlocks is free software: you can redistribute it and/or modify it under the
+# terms of the GNU Lesser General Public License as published by the Free Software
+# Foundation, version 3 of the License.
+#
+# PhysioBlocks is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License along with
+# PhysioBlocks. If not, see <https://www.gnu.org/licenses/>.
+
+"""
+Defines functions to access registers
+"""
+
+__all__ = ["register_type"]
+from physioblocks.registers.type_register import register_type

physioblocks/registers/load_function_register.py

@@ -0,0 +1,93 @@
+# SPDX-FileCopyrightText: Copyright INRIA
+#
+# SPDX-License-Identifier: LGPL-3.0-only
+#
+# Copyright INRIA
+#
+# This file is part of PhysioBlocks, a library mostly developed by the
+# [Ananke project-team](https://team.inria.fr/ananke) at INRIA.
+#
+# Authors:
+# - Colin Drieu
+# - Dominique Chapelle
+# - François Kimmig
+# - Philippe Moireau
+#
+# PhysioBlocks is free software: you can redistribute it and/or modify it under the
+# terms of the GNU Lesser General Public License as published by the Free Software
+# Foundation, version 3 of the License.
+#
+# PhysioBlocks is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License along with
+# PhysioBlocks. If not, see <https://www.gnu.org/licenses/>.
+
+"""
+Define decorators to register any function as a specific load function
+of a configuration object.
+"""
+
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from physioblocks.base.registers import register
+
+__load_functions_register: dict[type, Callable[..., Any]] = {}
+
+
+T = TypeVar("T")
+
+
+def loads(
+    loaded_type: type[T],
+) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    """
+    Decorator to register a method that loads a registered type.
+
+    :param loaded_type: the loaded type
+    :type loaded_type: str
+
+    :return: the class decorator
+    :rtype: Callable
+    """
+
+    def register_decorator(load_function: Callable[..., T]) -> Callable[..., T]:
+        register(__load_functions_register, loaded_type, load_function)
+        return load_function
+
+    return register_decorator
+
+
+def get_load_function(loaded_type: type) -> Callable[..., Any]:
+    """
+    Get a registered load function.
+
+    :param type_id: the registered type id
+    :type type_id: str
+
+    :raise KeyError: Raises a key error if the type is not registered.
+
+    :return: the registered type
+    :rtype: type
+    """
+    key_type = _get_closest_type(loaded_type)
+
+    if key_type is None:
+        raise KeyError(
+            str.format(
+                "No load function registered for type {0}",
+                loaded_type.__name__,
+            )
+        )
+    return __load_functions_register[key_type]
+
+
+def _get_closest_type(searched_type: type | None) -> None | type:
+    if searched_type is None:
+        return None
+    elif searched_type in __load_functions_register:
+        return searched_type
+    else:
+        return _get_closest_type(searched_type.__base__)

physioblocks/registers/save_function_register.py

@@ -0,0 +1,106 @@
+# SPDX-FileCopyrightText: Copyright INRIA
+#
+# SPDX-License-Identifier: LGPL-3.0-only
+#
+# Copyright INRIA
+#
+# This file is part of PhysioBlocks, a library mostly developed by the
+# [Ananke project-team](https://team.inria.fr/ananke) at INRIA.
+#
+# Authors:
+# - Colin Drieu
+# - Dominique Chapelle
+# - François Kimmig
+# - Philippe Moireau
+#
+# PhysioBlocks is free software: you can redistribute it and/or modify it under the
+# terms of the GNU Lesser General Public License as published by the Free Software
+# Foundation, version 3 of the License.
+#
+# PhysioBlocks is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License along with
+# PhysioBlocks. If not, see <https://www.gnu.org/licenses/>.
+
+"""
+Define decorators to register any function as a specific save function
+of a configuration object.
+"""
+
+from collections.abc import Callable
+from typing import Any
+
+from physioblocks.base.registers import register
+
+__save_functions_register: dict[type, Callable[..., Any]] = {}
+
+
+def saves(
+    saved_type: type,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """
+    Decorator to register a method that saves a registered type.
+
+    :param saved_type: the saved type by the method
+    :type saved_type: str
+
+    :return: the class decorator
+    :rtype: Callable
+    """
+
+    def register_decorator(
+        save_function: Callable[..., Any],
+    ) -> Callable[..., Any]:
+        register(__save_functions_register, saved_type, save_function)
+        return save_function
+
+    return register_decorator
+
+
+def has_save_function(key: type) -> bool:
+    """
+    Check if the type has a save function
+
+    :param key: the key to test
+    :type key: Any
+
+    :return: True if the key is registered, False otherwise
+    :rtype: bool
+    """
+    key_type = _get_closest_type(key)
+    return key_type in __save_functions_register
+
+
+def get_save_function(saved_type: type) -> Callable[..., Any]:
+    """
+    Get a registered save function.
+
+    :param type_id: the registered type id
+    :type type_id: str
+
+    :raise KeyError: Raises a key error if the type is not registered.
+
+    :return: the registered type
+    :rtype: type
+    """
+    key_type = _get_closest_type(saved_type)
+
+    if key_type is None:
+        raise KeyError(
+            str.format(
+                "No save function registered for type {0}",
+                saved_type.__name__,
+            )
+        )
+    return __save_functions_register[key_type]
+
+
+def _get_closest_type(searched_type: type | None) -> None | type:
+    if searched_type is None:
+        return None
+    elif searched_type in __save_functions_register:
+        return searched_type
+    else:
+        return _get_closest_type(searched_type.__base__)