physioblocks 1.0.0__py3-none-any.whl

physioblocks/library/blocks/cavity.py

@@ -0,0 +1,192 @@
+# 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 cavity blocks
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+from physioblocks.computing import Block, Expression, Quantity
+from physioblocks.registers import register_type
+from physioblocks.simulation import Time
+
+# Local id for the volume saved quantity
+CAVITY_VOLUME_LOCAL_ID = "volume"
+
+# Local id for the pressure dof in the cavity
+CAVITY_PRESSURE_LOCAL_ID = "pressure"
+
+# Local id for the pressure dof in the cavity
+CAVITY_DISP_LOCAL_ID = "disp"
+
+# Constant for the cavity block type id
+CAVITY_BLOCK_TYPE_ID = "spherical_cavity_block"
+
+
+@register_type(CAVITY_BLOCK_TYPE_ID)
+@dataclass
+class SphericalCavityBlock(Block):
+    r"""
+    Spherical cavity block implementation
+
+    .. tikz:: Spherical Cavity Scheme
+
+        \filldraw [fill=gray!20]  (0, 0) circle [x radius = 3.0+0.2, y radius = 3.0+0.2];
+        \draw [thick, dashed] (0, 0) circle [x radius = 3.0, y radius = 3.0];
+        \filldraw [fill=red!25] (0, 0) circle [x radius = 3.0-0.2, y radius = 3.0-0.2];
+        \filldraw [fill=gray!40] (0, 0) circle [x radius = 1.8 + 0.5, y radius = 1.8 + 0.5];
+        \draw [dashed, thick] (0, 0) circle [x radius = 1.8, y radius = 1.8];
+        \filldraw [fill=red!25] (0, 0) circle [x radius = 1.8 - 0.5, y radius = 1.8 - 0.5];
+        \draw [thick][<->] (0, 0) -- node[above]{$R_0$} (-1.8, 0);
+        \draw [thick][<->] (0, 1.8-0.5) -- node[anchor=west, yshift=4]{$d_0$} (0, 1.8+0.5);
+        \draw [thick][dashed][<-] (-3.0, 0) -- node[anchor=north]{$y$} (-1.8, 0);
+        \draw [thick][<->] (0, 3.0-0.2) -- node[anchor=south, yshift=5]{$d(y)$} (0, 3.0+0.2);
+        \draw (3.0+0.2, 0) to[short, -*, i=$Q$]  (5, 0) node[above]{$P$};
+
+    **Node 1:**
+
+        :math:`Q = - \frac {dV(y)}{dt}`
+
+    **Discretised:**
+
+        :math:`Q^{n + \frac{1}{2}} = - \frac {V(y^{n + 1}) - V(y^{n})}{\Delta t^n}`
+
+    .. note::
+
+        Notice that no dynamics is given on the **DOF** in the block.
+        **Model components** of the cavity can access the pressure and give it a dynamics.
+
+    """  # noqa: E501
+
+    disp: Quantity[np.float64]
+    """Displacement y"""
+
+    radius: Quantity[np.float64]
+    """Initial Sphere radius R0"""
+
+    thickness: Quantity[np.float64]
+    """Initial thickness d0"""
+
+    time: Time
+    """time"""
+
+    def initialize(self) -> None:
+        """
+        Initialize block attributes from current quantity values
+        """
+        self.inv_radius = 1.0 / self.radius.current
+        self.sphere_volume = (4.0 / 3.0) * np.pi * np.pow(self.radius.current, 3)
+        self.sphere_surface = 4.0 * np.pi * np.pow(self.radius.current, 2)
+        self.thickness_radius_ratio = self.thickness.current * self.inv_radius
+        self.half_thickness_radius_ratio = 0.5 * self.thickness_radius_ratio
+
+    def fluid_volume_current(self) -> Any:
+        """
+        Compute the current fluid volume in the cavity.
+
+        :return: the fluid volume
+        :rtype: np.float64
+        """
+        disp_cur_ratio = 1.0 + self.disp.current * self.inv_radius
+        return self.sphere_volume * np.pow(
+            disp_cur_ratio
+            - np.pow(disp_cur_ratio, -2) * self.half_thickness_radius_ratio,
+            3,
+        )
+
+    def fluid_volume_new(self) -> Any:
+        """
+        Compute the new fluid volume in the cavity.
+
+        :return: the fluid volume
+        :rtype: np.float64
+        """
+        disp_new_ratio = 1.0 + self.disp.new * self.inv_radius
+        return self.sphere_volume * np.pow(
+            disp_new_ratio
+            - np.pow(disp_new_ratio, -2) * self.half_thickness_radius_ratio,
+            3,
+        )
+
+    def cavity_flux(self) -> Any:
+        """
+        Compute the ventricule flux at local node 1.
+
+        :return: the flux
+        :rtype: np.float64
+        """
+
+        cavity_flux = -(
+            (self.fluid_volume_new() - self.fluid_volume_current()) * self.time.inv_dt
+        )
+
+        return cavity_flux
+
+    def dcavity_flux_ddisp(self) -> Any:
+        """
+        Compute the partial derivative of the cavity flux for ``disp``
+
+        :return: the flux partial derivative
+        :rtype: np.float64
+        """
+
+        disp_new_ratio = 1.0 + self.disp.new * self.inv_radius
+
+        return -(
+            self.time.inv_dt
+            * self.sphere_surface
+            * np.pow(
+                disp_new_ratio
+                - np.pow(disp_new_ratio, -2) * self.half_thickness_radius_ratio,
+                2,
+            )
+            * (1.0 + np.pow(disp_new_ratio, -3) * self.thickness_radius_ratio)
+        )
+
+
+# Define the cavity block flux expression.
+_cavity_block_flux_expr = Expression(
+    1,
+    SphericalCavityBlock.cavity_flux,
+    {CAVITY_DISP_LOCAL_ID: SphericalCavityBlock.dcavity_flux_ddisp},
+)
+
+SphericalCavityBlock.declares_flux_expression(
+    1, CAVITY_PRESSURE_LOCAL_ID, _cavity_block_flux_expr
+)
+
+
+# Define the cavity block volume of fluid expression.
+_cavity_block_fluid_volume_expr = Expression(
+    1, SphericalCavityBlock.fluid_volume_current
+)
+SphericalCavityBlock.declares_saved_quantity_expression(
+    CAVITY_VOLUME_LOCAL_ID, _cavity_block_fluid_volume_expr
+)

physioblocks/library/blocks/valves.py

@@ -0,0 +1,281 @@
+# 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 Valve Blocks
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+from physioblocks.computing import (
+    Block,
+    Expression,
+    Quantity,
+    diff,
+    mid_alpha,
+    mid_point,
+)
+from physioblocks.registers import register_type
+from physioblocks.simulation import Time
+
+# Constant for the valve rl block type id
+VALVE_RL_BLOCK_ID = "valve_rl_block"
+
+
+# Flux through the block
+VALVE_RL_BLOCK_FLUX_VAR_ID = "flux"
+
+# Pressure at local node 1
+VALVE_RL_BLOCK_PRESSURE_1_DOF_ID = "pressure_1"
+
+# Pressure at local node 2
+VALVE_RL_BLOCK_PRESSURE_2_DOF_ID = "pressure_2"
+
+
+@dataclass
+@register_type(VALVE_RL_BLOCK_ID)
+class ValveRLBlock(Block):
+    r"""
+    Describes valve RL block quantities and flux definitions
+
+    .. tikz:: Valve RC Scheme
+
+        \draw (1,2) to[short, i=$Q_2$] (1,1) to[short, -*] (1,0) node[right]{$P_2$};
+        \draw (1,2) to[short, L=$L$] (1,4);
+        \draw (0,4) -- (2,4);
+        \draw (0,4) to[D] (0,6);
+        \draw (0,6) to[R=$R_{\text{back}}$] (0,8);
+        \draw (2,8) to[D] (2,6);
+        \draw (2,6) to[R=$R$] (2,4);
+        \draw (0,8) -- (2,8);
+        \draw (1,9) to[short, i=$Q$] (1,8);
+        \draw (1,9) to[short, i=$Q_1$] (1,10) to [short, -*] (1,10.5)
+        node[right]{$P_1$};
+
+    **Node 1:**
+
+        :math:`Q_1 = - Q`
+
+    **Node 2:**
+
+        :math:`Q_2 = Q`
+
+    **Internal Equations:**
+
+        .. math::
+
+            L\ \dot{Q} + P_2 - P_1 +
+            \begin{cases}
+            RQ \text{ if Q $>$ 0 } \\
+            R_{\text{back}}Q \text{ else }
+            \end{cases} = 0
+
+    **Discretisation:**
+
+
+        .. math:: Q_1^{{n + \frac{1}{2}}} = - Q^{{n + \frac{1}{2}}}
+
+        .. math:: Q_2^{{n + \frac{1}{2}}} = Q^{{n + \frac{1}{2}}}
+
+        .. math::
+
+            L\ \frac{Q^{n + 1} - Q^{n}}{\Delta t^n}
+            + P_2^{n + \frac{1}{2}} - P_1^{n + \frac{1}{2}}
+            + \begin{cases}
+                RQ^{{n + \theta}} \text{ if } Q^{{n + \theta}} > 0 \\
+                R_{\text{back}}Q^{{n + \theta}} \text{ else }
+            \end{cases} = 0
+
+    """
+
+    flux: Quantity[np.float64]
+    """Flux traversing the block"""
+
+    pressure_1: Quantity[np.float64]
+    """Pressure quantity at local node 1"""
+
+    pressure_2: Quantity[np.float64]
+    """Pressure quantity at local node 2"""
+
+    inductance: Quantity[np.float64]
+    """Inductance quantity"""
+
+    conductance: Quantity[np.float64]
+    """Conductance quantity for positive flux """
+
+    backward_conductance: Quantity[np.float64]
+    """Conductance quantity for negative flux"""
+
+    scheme_ts_flux: Quantity[np.float64]
+    """Scheme time shift for flux"""
+
+    time: Time
+    """Simulation time"""
+
+    def initialize(self) -> None:
+        self.k_0 = (
+            2.0
+            * (self.conductance.current * self.backward_conductance.current)
+            / (self.conductance.current + self.backward_conductance.current)
+        )
+
+    def flux_residual(self) -> Any:
+        """
+        Compute the residual giving the dynamics on the flux in the valve.
+
+        :return: the residual value
+        :rtype: np.float64
+        """
+
+        q_mid_alpha = mid_alpha(self.flux, self.scheme_ts_flux.current)
+        pressure_1_mid_point = mid_point(self.pressure_1)
+        pressure_2_mid_point = mid_point(self.pressure_2)
+
+        conductance = self.conductance.current
+        if q_mid_alpha < 0:
+            conductance = self.backward_conductance.current
+
+        return (
+            self.inductance.current * self.time.inv_dt * diff(self.flux)
+            - pressure_1_mid_point
+            + pressure_2_mid_point
+            + q_mid_alpha / conductance
+        )
+
+    def flux_residual_dflux(self) -> Any:
+        """
+        Compute the residual partial derivative for ``flux``
+
+        :return: the residual partial derivative for ``flux``
+        :rtype: np.float64
+        """
+        q_mid_alpha = mid_alpha(self.flux, self.scheme_ts_flux.current)
+        conductance = self.conductance.current
+        if q_mid_alpha < 0:
+            conductance = self.backward_conductance.current
+        elif q_mid_alpha == 0:
+            conductance = self.k_0
+
+        return (
+            self.inductance.current * self.time.inv_dt
+            + (0.5 + self.scheme_ts_flux.current) / conductance
+        )
+
+    def flux_residual_dp1(self) -> Any:
+        """
+        Compute the residual partial derivative for ``pressure_1``
+
+        :return: the residual partial derivative for ``pressure_1``
+        :rtype: np.float64
+        """
+
+        return -0.5
+
+    def flux_residual_dp2(self) -> Any:
+        """
+        Compute the residual partial derivative for ``pressure_2``
+
+        :return: the residual partial derivative for ``pressure_2``
+        :rtype: np.float64
+        """
+
+        return 0.5
+
+    def flux_1(self) -> Any:
+        """
+        Compute the block flux at node 1
+
+
+        :return: the block flux at node 1
+        :rtype: np.float64
+        """
+        return -mid_point(self.flux)
+
+    def dflux_1_dflux(self) -> Any:
+        """
+        Compute the block flux at node 1 partial derivative for ``flux``
+
+
+        :return: the block flux at node 1 partial derivative for ``flux``
+        :rtype: np.float64
+        """
+        return -0.5
+
+    def flux_2(self) -> Any:
+        """
+        Compute the block flux at node 2
+
+        :return: the block flux at node 2
+        :rtype: np.float64
+        """
+        return mid_point(self.flux)
+
+    def dflux_2_dflux(self) -> Any:
+        """
+        Compute the block flux at node 2 partial derivative for ``flux``
+
+        :return: the block flux at node 2 partial derivative for ``flux``
+        :rtype: np.float64
+        """
+        return 0.5
+
+
+# define the Valve RL internal variable residual expression
+# giving the dynamics on the flux in the valve
+_valve_rl_flux_residual_expr = Expression(
+    1,
+    ValveRLBlock.flux_residual,
+    {
+        VALVE_RL_BLOCK_FLUX_VAR_ID: ValveRLBlock.flux_residual_dflux,
+        VALVE_RL_BLOCK_PRESSURE_1_DOF_ID: ValveRLBlock.flux_residual_dp1,
+        VALVE_RL_BLOCK_PRESSURE_2_DOF_ID: ValveRLBlock.flux_residual_dp2,
+    },
+)
+
+# define the ValveRL flux expression at node 1.
+_valve_rl_flux_1_expr = Expression(
+    1, ValveRLBlock.flux_1, {VALVE_RL_BLOCK_FLUX_VAR_ID: ValveRLBlock.dflux_1_dflux}
+)
+
+# define the ValveRL flux expression at node 2.
+_valve_rl_flux_2_expr = Expression(
+    1,
+    ValveRLBlock.flux_2,
+    {VALVE_RL_BLOCK_FLUX_VAR_ID: ValveRLBlock.dflux_2_dflux},
+)
+
+ValveRLBlock.declares_internal_expression(
+    VALVE_RL_BLOCK_FLUX_VAR_ID, _valve_rl_flux_residual_expr
+)
+ValveRLBlock.declares_flux_expression(
+    1, VALVE_RL_BLOCK_PRESSURE_1_DOF_ID, _valve_rl_flux_1_expr
+)
+ValveRLBlock.declares_flux_expression(
+    2, VALVE_RL_BLOCK_PRESSURE_2_DOF_ID, _valve_rl_flux_2_expr
+)

physioblocks/library/functions/__init__.py

@@ -0,0 +1,27 @@
+# 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 defining configurable functions"""

physioblocks/library/functions/base_operations.py

@@ -0,0 +1,129 @@
+# 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 simple operations to initialize parameters in the configuration."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from typing import Any
+
+import numpy as np
+
+from physioblocks.base.operators import AbstractBaseOperators
+from physioblocks.registers.type_register import register_type
+from physioblocks.simulation import AbstractFunction
+
+# Sum funtion type id
+SUM_TYPE_ID = "sum"
+
+
+@dataclass
+@register_type(SUM_TYPE_ID)
+class Sum(AbstractFunction, AbstractBaseOperators):
+    """
+    Sum the elements in ``add`` and subtract the elements in ``subtract``.
+    """
+
+    add: Iterable[Any] = field(default_factory=list)
+    """the values to sum"""
+
+    subtract: Iterable[Any] | None = None
+    """the values to subtract"""
+
+    @property
+    def operation_value(self) -> Any:
+        """
+        Value used with base operators.
+
+        :return: the current evaluation of the function
+        :rtype: Any
+        """
+        return self.eval()
+
+    def eval(self) -> Any:
+        """
+        Sum the elements in ``add`` and subtract the elements in ``subtract``.
+
+        :return: the sum result
+        :rtype: Any
+        """
+
+        pos = np.sum(np.array(self.add), axis=0)
+
+        if self.subtract is None:
+            return pos
+
+        neg = np.sum(np.array(self.subtract), axis=0)
+        return pos - neg
+
+
+def _multiply(elements: Iterable[Any]) -> Any:
+    result = 1.0
+    for elem in elements:
+        result = np.multiply(result, elem)
+    return result
+
+
+# Product function type name
+PRODUCT_TYPE_ID = "product"
+
+
+@dataclass
+@register_type(PRODUCT_TYPE_ID)
+class Product(AbstractFunction, AbstractBaseOperators):
+    """
+    Multiply all values provided in ``factors`` list and divide the
+    result with the multiplication of the values in the ``inverses`` list.
+
+    ..note:: It uses the numpy multiply function
+
+    """
+
+    factors: Iterable[Any] = field(default_factory=list)
+    """The values to multiply"""
+
+    inverses: Iterable[Any] | None = None
+    """The values to inverse then multiply"""
+
+    @property
+    def operation_value(self) -> Any:
+        """
+        Value used with base operators.
+
+        :return: the current evaluation of the function
+        :rtype: Any
+        """
+        return self.eval()
+
+    def eval(self) -> Any:
+        product = _multiply(self.factors)
+        if self.inverses is None:
+            return product
+        else:
+            inverses_product = _multiply(self.inverses)
+            return product / inverses_product