physioblocks 1.0.3__py3-none-any.whl → 1.1.1__py3-none-any.whl

physioblocks/__init__.py

@@ -26,7 +26,7 @@
 
 """Physioblocks package definition"""
 
-__version__ = "1.0.3"
+__version__ = "1.1.1"
 __copyright__ = "INRIA"
 __license__ = "LGPL-3.0-only"
 __authors__ = [

physioblocks/computing/models.py

@@ -32,6 +32,7 @@ functions.
 
 from __future__ import annotations
 
+import functools
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from inspect import get_annotations
@@ -46,7 +47,7 @@ SystemFunction: TypeAlias = Callable[..., np.float64 | NDArray[np.float64]]
 """Type alias for functions composing the system"""
 
 
-@dataclass(frozen=True)
+@dataclass
 class Expression:
     """Expression(size:int, expr_func: SystemFunction, expr_gradients: Mapping[str, SystemFunction] = {})
     Store function computing numerical values for terms in the models with the function
@@ -102,6 +103,223 @@ class Expression:
         )
 
 
+class ExpressionDecorator:
+    """
+    Base class for expression decorators.
+
+    This is a helper that defines expressions decorating methods in a model or block
+    class.
+    """
+
+    expression: Expression
+    """The expression resulting from decorators declarations"""
+
+    def __init__(
+        self,
+        wrapped_function: Callable[..., Any],
+    ):
+        """
+        :param wrapped_function: The decorated expression function
+        :type wrapped_function: Callable
+        """
+        self.expression = Expression(0, wrapped_function)
+        self._terms: list[tuple[str, int, int]] = []
+        functools.update_wrapper(self, wrapped_function)
+
+    def register_term(
+        self,
+        term_name: str,
+        term_size: int,
+        term_index: int,
+    ) -> None:
+        """
+        Register a new term to the expression decorator
+
+        :param term_name: the term local name.
+        :type term_name: str
+
+        :param term_size: The size of the term
+        :type term_size: int
+
+        :param term_index: The start index of the term in the expression
+        :type term_index: int
+        """
+        self.expression.size += term_size
+        self._terms.append((term_name, term_size, term_index))
+
+    @property
+    def terms(self) -> list[tuple[str, int, int]]:
+        """
+        Get the terms described by the expression.
+
+        :return: list of terms description
+        :rtype: list[[tuple[str, int, int]]]
+        """
+        return self._terms.copy()
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return self.expression.expr_func(*args, **kwargs)
+
+    def partial_derivative(
+        self, variable_name: str
+    ) -> Callable[..., Callable[..., Any]]:
+        """
+        Declares a flux partial derivative.
+
+        :param variable_name: the variable local name.
+        :type variable_name: str
+        """
+
+        def _register(wrapped: Callable[..., Any]) -> Callable[..., Any]:
+            self.expression.expr_gradients[variable_name] = wrapped
+            return wrapped
+
+        return _register
+
+
+def _check_expression_decorator_type(
+    wrapped_function: Any, new_decorator_type: type[ExpressionDecorator]
+) -> None:
+    if (
+        isinstance(wrapped_function, ExpressionDecorator) is True
+        and isinstance(wrapped_function, new_decorator_type) is False
+    ):
+        raise ValueError(
+            str.format(
+                "Can not decorate a function of an other type. "
+                "Current type is {0}, new type is {1}.",
+                type(wrapped_function),
+                new_decorator_type,
+            )
+        )
+
+
+class InternalEquationDecorator(ExpressionDecorator):
+    """
+    Define a decorator that identifies internal equation expressions.
+    """
+
+    pass
+
+
+def declares_internal_equation(
+    variable_name: str, size: int = 1, starting_index: int = 0
+) -> Callable[..., InternalEquationDecorator]:
+    """
+    Declares a internal equation expression.
+
+    Once the internal equation function is declared, partial derivatives can be added
+    using the function name and the local variable name for the partial derivative.
+
+    :param variable_name: the variable name on which the expression provides a dynamic.
+    :type variable_name: str
+
+    :param size: the size of the equation. Default is 1
+    :type size: int
+
+    :param starting_index: the starting index of the equation line matching the
+      variable. Default is 0
+    :type starting_index: int
+
+    :raises ValueError: Raises a ValueError if the function is already decorated with
+      an expression decorator of an other type.
+
+    Example
+    ^^^^^^^
+
+    .. code:: python
+
+        @dataclass
+        class SimpleModel(ModelComponent):
+
+            x: Quantity
+            a: Quantity
+
+            @declares_internal_equation("x")
+            def residual(self):
+                return x.new**2 - a.current
+
+            @flux_1.partial_derivative("x")
+            def dresidual_dx(self):
+                return 2.0 * x.new
+    """
+
+    def _create_internal_equation_decorator(
+        wrapped: Callable[..., Any],
+    ) -> InternalEquationDecorator:
+        _check_expression_decorator_type(wrapped, InternalEquationDecorator)
+
+        decorated = (
+            wrapped
+            if isinstance(wrapped, InternalEquationDecorator)
+            else InternalEquationDecorator(wrapped)
+        )
+        decorated.register_term(variable_name, size, starting_index)
+        return decorated
+
+    return _create_internal_equation_decorator
+
+
+class SavedQuantityDecorator(ExpressionDecorator):
+    """
+    Define a decorator that identifies saved quantities expressions.
+    """
+
+    pass
+
+
+def declares_saved_quantity(
+    quantity_name: str, size: int = 1, starting_index: int = 0
+) -> Callable[..., SavedQuantityDecorator]:
+    """
+    Declares a saved quantity expression.
+
+    :param quantity_name: the local quantity name.
+    :type quantity_name: str
+
+    :param size: the size of the expression. Default is 1
+    :type size: int
+
+    :param starting_index: the starting index of the expression in the function.
+      Default is 0
+    :type starting_index: int
+
+    :raises ValueError: Raises a ValueError if the function is already decorated with
+      an expression decorator of an other type.
+
+    Example
+    ^^^^^^^
+
+    .. code:: python
+
+        @dataclass
+        class SimpleModel(ModelComponent):
+
+            a: Quantity
+            b: Quantity
+
+            @declares_saved_quantity("a + b")
+            def sum(self):
+                return a.current + b.current
+    """
+
+    def _create_saved_quantity_decorator(
+        wrapped: Callable[..., Any],
+    ) -> SavedQuantityDecorator:
+        _check_expression_decorator_type(wrapped, SavedQuantityDecorator)
+
+        decorator = (
+            wrapped
+            if isinstance(wrapped, SavedQuantityDecorator)
+            else SavedQuantityDecorator(wrapped)
+        )
+        decorator.register_term(quantity_name, size, starting_index)
+
+        return decorator
+
+    return _create_saved_quantity_decorator
+
+
 @dataclass(frozen=True)
 class TermDefinition:
     """Describe Terms defined in an :class:`~physioblocks.computing.models.Expression`.
@@ -303,6 +521,23 @@ class ModelComponentMetaClass(type):
             cls.__INTERNAL_EXPRESSION_KEY: [],
             cls.__SAVED_QUANTITIES_EXPRESSION_KEY: [],
         }
+        for attr in cls.__dict__.values():
+            if isinstance(attr, InternalEquationDecorator):
+                for term_name, term_size, term_index in attr.terms:
+                    cls.declares_internal_expression(
+                        term_name,
+                        attr.expression,
+                        term_size,
+                        term_index,
+                    )
+            elif isinstance(attr, SavedQuantityDecorator):
+                for term_name, term_size, term_index in attr.terms:
+                    cls.declares_saved_quantity_expression(
+                        term_name,
+                        attr.expression,
+                        term_size,
+                        term_index,
+                    )
 
     @staticmethod
     def __is_quantity_type(type_to_test: Any) -> bool:
@@ -481,6 +716,7 @@ class ModelComponentMetaClass(type):
 
         # Add the term definition to the expression definition
         expression_def.terms.append(TermDefinition(term_id, size, index))
+        expression_def.terms.sort(key=lambda term: term.index)
 
     def declares_internal_expression(
         cls,
@@ -690,6 +926,78 @@ class ModelComponent(metaclass=ModelComponentMetaClass):
         """Override this method to define specific for model initialization."""
 
 
+class FluxDecorator(ExpressionDecorator):
+    """
+    Define a decorator that identifies flux functions
+    """
+
+    pass
+
+
+def declares_flux(
+    index: int, dof_name: str, size: int = 1
+) -> Callable[..., FluxDecorator]:
+    """
+    Declares a flux function.
+
+    Once the flux expression is declared, partial derivatives can be added using the
+    flux function name and the local variable name for the partial derivative.
+
+    :param index: the index of the flux in the block.
+    :type index: int
+
+    :param dof_name: the matching dof local name
+    :type dof_name: str
+
+    :param size: the size of the flux returned by the function
+    :type size: int
+
+    :raises ValueError: Raises a ValueError if the function is already decorated with
+      an expression decorator of an other type.
+
+
+    Example
+    ^^^^^^^
+
+    .. code:: python
+
+        @dataclass
+        class SimpleBlock(Block):
+
+            q_1: Quantity
+
+            # declares a flux shared at local node 1, where the associated dof has the
+            # local name "potential_1"
+            @declares_flux(1, "potential_1")
+            def flux_1(self):
+                return q_1.new
+
+            # associate the following function as the partial derivative of "flux_1" for
+            # variable "q_1"
+            @flux_1.partial_derivative("q_1")
+            def dflux_1_dq_1(self):
+                return 1.0
+
+    """
+
+    def _create_flux_decorator(wrapped: Callable[..., Any]) -> FluxDecorator:
+        if isinstance(wrapped, ExpressionDecorator) is True:
+            raise ValueError(
+                str.format(
+                    "Function already declares an expression, it can not be a flux."
+                )
+            )
+
+        decorator = (
+            wrapped if isinstance(wrapped, FluxDecorator) else FluxDecorator(wrapped)
+        )
+        decorator.register_term(dof_name, size, index)
+
+        return decorator
+
+    return _create_flux_decorator
+
+
 class BlockMetaClass(ModelComponentMetaClass):
     """Meta-class for :class:`~physioblocks.computing.models.Block`.
 
@@ -711,6 +1019,10 @@ class BlockMetaClass(ModelComponentMetaClass):
     def __init__(cls, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         cls._fluxes = {}
+        for attr in cls.__dict__.values():
+            if isinstance(attr, FluxDecorator):
+                for term_name, _term_size, term_index in attr.terms:
+                    cls.declares_flux_expression(term_index, term_name, attr.expression)
 
     def declares_flux_expression(
         cls, node_index: int, variable_id: str, expr: Expression

physioblocks/launcher/__main__.py

@@ -37,6 +37,7 @@ from pathlib import Path
 from typing import Any
 
 import pandas as pd
+from rich.logging import RichHandler
 
 import physioblocks.utils.exceptions_utils as exception_utils
 from physioblocks.configuration import Configuration, load, unwrap_aliases
@@ -64,8 +65,9 @@ from physioblocks.simulation import AbstractSimulation, SimulationError
 .. note:: When deleting a serie from the launcher folder, or a specific simulation from
   a serie, the launchers logs are updated the next time any simulation is launched.
 """
+FILE_LOG_FORMATTER = logging.Formatter(logging.BASIC_FORMAT)
+RICH_LOG_FORMATTER = logging.Formatter("%(message)s", "[%X]")
 
-SIMULATION_LOG_FORMATER = logging.Formatter(logging.BASIC_FORMAT)
 _root_logger = logging.getLogger()
 _root_logger.setLevel(logging.DEBUG)
 
@@ -90,8 +92,10 @@ def run_simulation(config: Configuration) -> pd.DataFrame:
     return pd.DataFrame(results)
 
 
-def add_log_handler(handler: logging.Handler, level: str | int) -> None:
-    handler.setFormatter(SIMULATION_LOG_FORMATER)
+def add_log_handler(
+    handler: logging.Handler, level: str | int, formatter: logging.Formatter
+) -> None:
+    handler.setFormatter(formatter)
     handler.setLevel(level)
     _root_logger.addHandler(handler)
 
@@ -132,7 +136,7 @@ def main(
     # configure the simulation log file (always in DEBUG)
     log_file_path = sim_folder / str.join(".", [sim_info.reference, "log"])
     file_handler = logging.FileHandler(log_file_path)
-    add_log_handler(file_handler, logging.DEBUG)
+    add_log_handler(file_handler, logging.DEBUG, FILE_LOG_FORMATTER)
 
     # log the current simulation infos
     _root_logger.info(str(sim_info))
@@ -260,8 +264,8 @@ if __name__ == "__main__":
 
     # setup logger when verbose
     if args.verbose is True:
-        stdout_handler = logging.StreamHandler(sys.stdout)
-        add_log_handler(stdout_handler, args.log_level)
+        # stdout_handler = logging.StreamHandler(sys.stdout)
+        add_log_handler(RichHandler(), args.log_level, RICH_LOG_FORMATTER)
 
     # create paths from arguments
     root_folder_path = Path(args.launcher_directory).absolute()

physioblocks/library/blocks/capacitances.py

@@ -31,7 +31,12 @@ from typing import Any
 
 import numpy as np
 
-from physioblocks.computing import Block, Expression, Quantity, diff, mid_point
+from physioblocks.computing import Block, Quantity, diff, mid_point
+from physioblocks.computing.models import (
+    declares_flux,
+    declares_internal_equation,
+    declares_saved_quantity,
+)
 from physioblocks.registers import register_type
 from physioblocks.simulation import Time
 
@@ -41,8 +46,8 @@ from physioblocks.simulation import Time
 # Constant for the c block type id
 C_BLOCK_TYPE_ID = "c_block"
 
-# Constant for the c block dof id
-C_BLOCK_PRESSURE_DOF_ID = "pressure"
+# Constant for the c block pressure local id
+C_BLOCK_PRESSURE_ID = "pressure"
 
 
 @register_type(C_BLOCK_TYPE_ID)
@@ -77,6 +82,7 @@ class CBlock(Block):
     time: Time
     """Simulation time"""
 
+    @declares_flux(1, C_BLOCK_PRESSURE_ID)
     def flux(self) -> Any:
         """
         Compute the flux at local node 1
@@ -86,6 +92,7 @@ class CBlock(Block):
         """
         return -self.capacitance.current * diff(self.pressure) * self.time.inv_dt
 
+    @flux.partial_derivative(C_BLOCK_PRESSURE_ID)
     def dflux_dpressure(self) -> Any:
         """
         Compute the flux at local node 1 partial derivative for pressure
@@ -96,12 +103,6 @@ class CBlock(Block):
         return -self.capacitance.current * self.time.inv_dt
 
 
-_c_block_flux_expression = Expression(
-    1, CBlock.flux, {C_BLOCK_PRESSURE_DOF_ID: CBlock.dflux_dpressure}
-)
-CBlock.declares_flux_expression(1, C_BLOCK_PRESSURE_DOF_ID, _c_block_flux_expression)
-
-
 # RC BLOCK Definition
 
 # Constant for the rc block type id
@@ -164,6 +165,7 @@ class RCBlock(Block):
     time: Time
     """The simulation time"""
 
+    @declares_flux(1, RC_BLOCK_PRESSURE_1_DOF_ID)
     def flux_1(self) -> Any:
         """
         Computes the outlet flux at local node 1.
@@ -175,6 +177,7 @@ class RCBlock(Block):
         pressure_2 = mid_point(self.pressure_2)
         return (pressure_2 - pressure_1) / self.resistance.current
 
+    @flux_1.partial_derivative(RC_BLOCK_PRESSURE_1_DOF_ID)
     def dflux_1_dpressure_1(self) -> Any:
         """
         Computes the outlet flux at node 1 derivative for pressure_1.
@@ -184,6 +187,7 @@ class RCBlock(Block):
         """
         return -0.5 / self.resistance.current
 
+    @flux_1.partial_derivative(RC_BLOCK_PRESSURE_2_DOF_ID)
     def dflux_1_dpressure_2(self) -> Any:
         """
         Computes the outlet flux at node 1 derivative for pressure_2.
@@ -193,6 +197,7 @@ class RCBlock(Block):
         """
         return 0.5 / self.resistance.current
 
+    @declares_flux(2, RC_BLOCK_PRESSURE_2_DOF_ID)
     def flux_2(self) -> Any:
         """
         Computes the outlet flux at node 2.
@@ -208,6 +213,7 @@ class RCBlock(Block):
             - self.capacitance.current * self.time.inv_dt * dpressure_2
         )
 
+    @flux_2.partial_derivative(RC_BLOCK_PRESSURE_1_DOF_ID)
     def dflux_2_dpressure_1(self) -> Any:
         """
         Computes the outlet flux at node 2 derivative for pressure_1.
@@ -217,6 +223,7 @@ class RCBlock(Block):
         """
         return 0.5 / self.resistance.current
 
+    @flux_2.partial_derivative(RC_BLOCK_PRESSURE_2_DOF_ID)
     def dflux_2_dpressure_2(self) -> Any:
         """
         Computes the outlet flux at node 2 derivative for pressure_2.
@@ -229,29 +236,6 @@ class RCBlock(Block):
         )
 
 
-# Define the flux expression going in the input node for rc_block
-_rc_block_flux_1_expr = Expression(
-    1,
-    RCBlock.flux_1,
-    {
-        RC_BLOCK_PRESSURE_1_DOF_ID: RCBlock.dflux_1_dpressure_1,
-        RC_BLOCK_PRESSURE_2_DOF_ID: RCBlock.dflux_1_dpressure_2,
-    },
-)
-
-# Define the flux expression going in the output node for rc_block
-_rc_block_flux_2_expr = Expression(
-    1,
-    RCBlock.flux_2,
-    {
-        RC_BLOCK_PRESSURE_1_DOF_ID: RCBlock.dflux_2_dpressure_1,
-        RC_BLOCK_PRESSURE_2_DOF_ID: RCBlock.dflux_2_dpressure_2,
-    },
-)
-
-RCBlock.declares_flux_expression(1, RC_BLOCK_PRESSURE_1_DOF_ID, _rc_block_flux_1_expr)
-RCBlock.declares_flux_expression(2, RC_BLOCK_PRESSURE_2_DOF_ID, _rc_block_flux_2_expr)
-
 # RCR BLOCK Definition
 
 # Constant for the rcr block type id
@@ -300,7 +284,7 @@ class RCRBlock(Block):
 
             \frac{P_1 - P_{mid}}{R_1} + \frac{P_2 - P_{mid}}{R_2} - C\dot{P}_{mid} = 0
 
-    **Discretisation:**
+    **Discretization:**
 
         .. math::
 
@@ -341,6 +325,7 @@ class RCRBlock(Block):
     time: Time
     """The simulation time"""
 
+    @declares_flux(1, RCR_BLOCK_PRESSURE_1_ID)
     def flux_1(self) -> Any:
         """
         Computes the outlet flux at node 1.
@@ -354,6 +339,7 @@ class RCRBlock(Block):
 
         return (pressure_mid_discr - pressure_1_discr) / self.resistance_1.current
 
+    @flux_1.partial_derivative(RCR_BLOCK_PRESSURE_1_ID)
     def dflux_1_dp_1(self) -> Any:
         """
         Computes the outlet flux at node 1 derivative for pressure_1.
@@ -364,6 +350,7 @@ class RCRBlock(Block):
 
         return -0.5 / self.resistance_1.current
 
+    @flux_1.partial_derivative(RCR_BLOCK_PRESSURE_MID_ID)
     def dflux_1_dp_mid(self) -> Any:
         """
         Computes the outlet flux at node 1 derivative for pressure_mid.
@@ -374,6 +361,7 @@ class RCRBlock(Block):
 
         return 0.5 / self.resistance_1.current
 
+    @declares_flux(2, RCR_BLOCK_PRESSURE_2_ID)
     def flux_2(self) -> Any:
         """
         Computes the flux at node 2.
@@ -386,6 +374,7 @@ class RCRBlock(Block):
 
         return (pressure_mid_discr - pressure_2_discr) / self.resistance_2.current
 
+    @flux_2.partial_derivative(RCR_BLOCK_PRESSURE_MID_ID)
     def dflux_2_dp_mid(self) -> Any:
         """
         Computes the outlet flux at node 2 derivative for pressure_mid.
@@ -396,6 +385,7 @@ class RCRBlock(Block):
 
         return 0.5 / self.resistance_2.current
 
+    @flux_2.partial_derivative(RCR_BLOCK_PRESSURE_2_ID)
     def dflux_2_dp_2(self) -> Any:
         """
         Computes the outlet flux at node 2 derivative for pressure_2.
@@ -406,6 +396,7 @@ class RCRBlock(Block):
 
         return -0.5 / self.resistance_2.current
 
+    @declares_internal_equation(RCR_BLOCK_PRESSURE_MID_ID)
     def pressure_mid_residual(self) -> Any:
         """
         Compute the residual representing dynamics of the mid node pressure.
@@ -424,6 +415,7 @@ class RCRBlock(Block):
             - self.capacitance.current * self.time.inv_dt * diff(self.pressure_mid)
         )
 
+    @pressure_mid_residual.partial_derivative(RCR_BLOCK_PRESSURE_1_ID)
     def pressure_mid_residual_dp_1(self) -> Any:
         """
         Compute the residual derivative for pressure_1
@@ -434,6 +426,7 @@ class RCRBlock(Block):
 
         return 0.5 / self.resistance_1.current
 
+    @pressure_mid_residual.partial_derivative(RCR_BLOCK_PRESSURE_2_ID)
     def pressure_mid_residual_dp_2(self) -> Any:
         """
         Compute the residual derivative for pressure_2
@@ -444,6 +437,7 @@ class RCRBlock(Block):
 
         return 0.5 / self.resistance_2.current
 
+    @pressure_mid_residual.partial_derivative(RCR_BLOCK_PRESSURE_MID_ID)
     def pressure_mid_residual_dp_mid(self) -> Any:
         """
         Compute the residual derivative for pressure_mid
@@ -458,6 +452,7 @@ class RCRBlock(Block):
             - 0.5 / self.resistance_2.current
         )
 
+    @declares_saved_quantity("volume")
     def compute_volume_stored(self) -> Any:
         """
         Computes volume stored in the capacitance.
@@ -467,50 +462,3 @@ class RCRBlock(Block):
         """
 
         return self.capacitance.current * self.pressure_mid.current
-
-
-# Define the flux expression going in node 1 for rcr block
-_rcr_block_flux_1_expr = Expression(
-    1,
-    RCRBlock.flux_1,
-    {
-        RCR_BLOCK_PRESSURE_1_ID: RCRBlock.dflux_1_dp_1,
-        RCR_BLOCK_PRESSURE_MID_ID: RCRBlock.dflux_1_dp_mid,
-    },
-)
-
-
-# Define the flux expression going in node 2 for rcr block
-_rcr_block_flux_2_expr = Expression(
-    1,
-    RCRBlock.flux_2,
-    {
-        RCR_BLOCK_PRESSURE_MID_ID: RCRBlock.dflux_2_dp_mid,
-        RCR_BLOCK_PRESSURE_2_ID: RCRBlock.dflux_2_dp_2,
-    },
-)
-
-# Define the residual expression giving the pressure at the mid node
-_rcr_block_pressure_mid_residual_expr = Expression(
-    1,
-    RCRBlock.pressure_mid_residual,
-    {
-        RCR_BLOCK_PRESSURE_1_ID: RCRBlock.pressure_mid_residual_dp_1,
-        RCR_BLOCK_PRESSURE_MID_ID: RCRBlock.pressure_mid_residual_dp_mid,
-        RCR_BLOCK_PRESSURE_2_ID: RCRBlock.pressure_mid_residual_dp_2,
-    },
-)
-
-# Derfine the stored volume saved quantity expression.
-_rcr_volume_stored_expr = Expression(1, RCRBlock.compute_volume_stored)
-
-
-RCRBlock.declares_internal_expression(
-    RCR_BLOCK_PRESSURE_MID_ID, _rcr_block_pressure_mid_residual_expr
-)
-
-RCRBlock.declares_flux_expression(1, RCR_BLOCK_PRESSURE_1_ID, _rcr_block_flux_1_expr)
-RCRBlock.declares_flux_expression(2, RCR_BLOCK_PRESSURE_2_ID, _rcr_block_flux_2_expr)
-RCRBlock.declares_saved_quantity_expression(
-    RCR_BLOCK_VOLUME_OUTPUT_ID, _rcr_volume_stored_expr
-)

physioblocks/library/blocks/cavity.py

@@ -33,7 +33,8 @@ from typing import Any
 
 import numpy as np
 
-from physioblocks.computing import Block, Expression, Quantity
+from physioblocks.computing import Block, Quantity
+from physioblocks.computing.models import declares_flux
 from physioblocks.registers import register_type
 from physioblocks.simulation import Time
 
@@ -74,7 +75,7 @@ class SphericalCavityBlock(Block):
 
         :math:`Q = - \frac {dV(y)}{dt}`
 
-    **Discretised:**
+    **Discretized:**
 
         :math:`Q^{n + \frac{1}{2}} = - \frac {V(y^{n + 1}) - V(y^{n})}{\Delta t^n}`
 
@@ -135,9 +136,10 @@ class SphericalCavityBlock(Block):
             3,
         )
 
+    @declares_flux(1, CAVITY_PRESSURE_LOCAL_ID)
     def cavity_flux(self) -> Any:
         """
-        Compute the ventricule flux at local node 1.
+        Compute the cavity flux at local node 1.
 
         :return: the flux
         :rtype: np.float64
@@ -149,6 +151,7 @@ class SphericalCavityBlock(Block):
 
         return cavity_flux
 
+    @cavity_flux.partial_derivative(CAVITY_DISP_LOCAL_ID)
     def dcavity_flux_ddisp(self) -> Any:
         """
         Compute the partial derivative of the cavity flux for ``disp``
@@ -169,24 +172,3 @@ class SphericalCavityBlock(Block):
             )
             * (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

@@ -35,12 +35,12 @@ import numpy as np
 
 from physioblocks.computing import (
     Block,
-    Expression,
     Quantity,
     diff,
     mid_alpha,
     mid_point,
 )
+from physioblocks.computing.models import declares_flux, declares_internal_equation
 from physioblocks.registers import register_type
 from physioblocks.simulation import Time
 
@@ -96,7 +96,7 @@ class ValveRLBlock(Block):
             R_{\text{back}}Q \text{ else }
             \end{cases} = 0
 
-    **Discretisation:**
+    **Discretization:**
 
 
         .. math:: Q_1^{{n + \frac{1}{2}}} = - Q^{{n + \frac{1}{2}}}
@@ -145,6 +145,7 @@ class ValveRLBlock(Block):
             / (self.conductance.current + self.backward_conductance.current)
         )
 
+    @declares_internal_equation(VALVE_RL_BLOCK_FLUX_VAR_ID)
     def flux_residual(self) -> Any:
         """
         Compute the residual giving the dynamics on the flux in the valve.
@@ -168,6 +169,7 @@ class ValveRLBlock(Block):
             + q_mid_alpha / conductance
         )
 
+    @flux_residual.partial_derivative(VALVE_RL_BLOCK_FLUX_VAR_ID)
     def flux_residual_dflux(self) -> Any:
         """
         Compute the residual partial derivative for ``flux``
@@ -187,6 +189,7 @@ class ValveRLBlock(Block):
             + (0.5 + self.scheme_ts_flux.current) / conductance
         )
 
+    @flux_residual.partial_derivative(VALVE_RL_BLOCK_PRESSURE_1_DOF_ID)
     def flux_residual_dp1(self) -> Any:
         """
         Compute the residual partial derivative for ``pressure_1``
@@ -197,6 +200,7 @@ class ValveRLBlock(Block):
 
         return -0.5
 
+    @flux_residual.partial_derivative(VALVE_RL_BLOCK_PRESSURE_2_DOF_ID)
     def flux_residual_dp2(self) -> Any:
         """
         Compute the residual partial derivative for ``pressure_2``
@@ -207,6 +211,7 @@ class ValveRLBlock(Block):
 
         return 0.5
 
+    @declares_flux(1, VALVE_RL_BLOCK_PRESSURE_1_DOF_ID)
     def flux_1(self) -> Any:
         """
         Compute the block flux at node 1
@@ -217,6 +222,7 @@ class ValveRLBlock(Block):
         """
         return -mid_point(self.flux)
 
+    @flux_1.partial_derivative(VALVE_RL_BLOCK_FLUX_VAR_ID)
     def dflux_1_dflux(self) -> Any:
         """
         Compute the block flux at node 1 partial derivative for ``flux``
@@ -227,6 +233,7 @@ class ValveRLBlock(Block):
         """
         return -0.5
 
+    @declares_flux(2, VALVE_RL_BLOCK_PRESSURE_2_DOF_ID)
     def flux_2(self) -> Any:
         """
         Compute the block flux at node 2
@@ -236,6 +243,7 @@ class ValveRLBlock(Block):
         """
         return mid_point(self.flux)
 
+    @flux_2.partial_derivative(VALVE_RL_BLOCK_FLUX_VAR_ID)
     def dflux_2_dflux(self) -> Any:
         """
         Compute the block flux at node 2 partial derivative for ``flux``
@@ -244,38 +252,3 @@ class ValveRLBlock(Block):
         :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/model_components/active_law.py

@@ -31,24 +31,36 @@ import numpy as np
 from numpy.typing import NDArray
 
 from physioblocks.computing import (
-    Expression,
     ModelComponent,
     Quantity,
     diff,
     mid_point,
 )
+from physioblocks.computing.models import declares_internal_equation
 from physioblocks.registers import register_type
 from physioblocks.simulation import Time
 
 # Constant for the active law type id
 ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_TYPE_ID = "active_law_macro_huxley_two_moments"
 
+# Constant for the active stiffness local id
+ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_ACTIVE_STIFFNESS = "active_stiffness"
+
+# Constant for the active energy sqrt local id
+ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_ACTIVE_ENERGY_SQRT = "active_energy_sqrt"
+
+# Constant for the active tension discretization local id
+ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_ACTIVE_TENSION_DISCR = "active_tension_discr"
+
+# Constant for the fiber deformation local id
+ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_FIB_DEFORM = "fib_deform"
+
 
 @register_type(ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_TYPE_ID)
 @dataclass
 class ActiveLawMacroscopicHuxleyTwoMoment(ModelComponent):
     r"""
-    Describes the Macroscopic Huxley Two Moment implementation of the ative law.
+    Describes the Macroscopic Huxley Two Moment implementation of the active law.
 
     **Internal Equations:**
 
@@ -65,7 +77,7 @@ class ActiveLawMacroscopicHuxleyTwoMoment(ModelComponent):
 
             \lambda_c - T_c/\sqrt{K_c} = 0
 
-    **Discretised:**
+    **Discretized:**
 
         .. math::
 
@@ -90,7 +102,7 @@ class ActiveLawMacroscopicHuxleyTwoMoment(ModelComponent):
     """:math:`\\lambda_c` the active energy sqrt"""
 
     active_tension_discr: Quantity[np.float64]
-    """:math:`T_c^{n + \\frac{1}{2}\\sharp}` the active tension discretisation"""
+    """:math:`T_c^{n + \\frac{1}{2}\\sharp}` the active tension discretization"""
 
     starling_abscissas: Quantity[NDArray[np.float64]]
     """Abscissas of :math:`n_0` the discretized starling function"""
@@ -113,6 +125,15 @@ class ActiveLawMacroscopicHuxleyTwoMoment(ModelComponent):
     time: Time
     """:math:`t` the simulation time"""
 
+    @declares_internal_equation(
+        ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_ACTIVE_STIFFNESS, 1, 0
+    )
+    @declares_internal_equation(
+        ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_ACTIVE_ENERGY_SQRT, 1, 1
+    )
+    @declares_internal_equation(
+        ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_ACTIVE_TENSION_DISCR, 1, 2
+    )
     def active_law_residual(self) -> Any:
         """
         Compute the residual of the active law.
@@ -166,6 +187,9 @@ class ActiveLawMacroscopicHuxleyTwoMoment(ModelComponent):
             ],
         )
 
+    @active_law_residual.partial_derivative(
+        ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_ACTIVE_STIFFNESS
+    )
     def active_law_residual_dactive_stiffness(self) -> Any:
         """
         Compute the residual partial derivative for the active stiffness
@@ -219,6 +243,9 @@ class ActiveLawMacroscopicHuxleyTwoMoment(ModelComponent):
             ],
         )
 
+    @active_law_residual.partial_derivative(
+        ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_ACTIVE_ENERGY_SQRT
+    )
     def active_law_residual_dactive_energy_sqrt(self) -> Any:
         """
         Compute the residual partial derivative for the active energy sqrt
@@ -264,6 +291,9 @@ class ActiveLawMacroscopicHuxleyTwoMoment(ModelComponent):
             ],
         )
 
+    @active_law_residual.partial_derivative(
+        ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_FIB_DEFORM
+    )
     def active_law_residual_dfib_deform(self) -> Any:
         """
         Compute the residual partial derivative for the fiber deformation
@@ -293,6 +323,9 @@ class ActiveLawMacroscopicHuxleyTwoMoment(ModelComponent):
             ],
         )
 
+    @active_law_residual.partial_derivative(
+        ACTIVE_LAW_MACRO_HUXLEY_TWO_MOMENTS_ACTIVE_TENSION_DISCR
+    )
     def active_law_residual_dactive_tension(self) -> Any:
         """
         Compute the residual partial derivative for the active tension
@@ -310,36 +343,3 @@ class ActiveLawMacroscopicHuxleyTwoMoment(ModelComponent):
             * np.fabs(diff(self.fib_deform))
             * self.time.inv_dt
         )
-
-
-# Define the expression for the residual of the ActiveLawMacroscopicHuxleyTwoMoment and
-# its partial derivatives.
-_active_law_macroscopic_huxley_two_moment_residual_expression = Expression(
-    3,
-    ActiveLawMacroscopicHuxleyTwoMoment.active_law_residual,
-    {
-        "active_stiffness": ActiveLawMacroscopicHuxleyTwoMoment.active_law_residual_dactive_stiffness,  # noqa: E501
-        "active_energy_sqrt": ActiveLawMacroscopicHuxleyTwoMoment.active_law_residual_dactive_energy_sqrt,  # noqa: E501
-        "active_tension_discr": ActiveLawMacroscopicHuxleyTwoMoment.active_law_residual_dactive_tension,  # noqa: E501
-        "fib_deform": ActiveLawMacroscopicHuxleyTwoMoment.active_law_residual_dfib_deform,  # noqa: E501
-    },
-)
-
-ActiveLawMacroscopicHuxleyTwoMoment.declares_internal_expression(
-    "active_stiffness",
-    _active_law_macroscopic_huxley_two_moment_residual_expression,
-    1,
-    0,
-)
-ActiveLawMacroscopicHuxleyTwoMoment.declares_internal_expression(
-    "active_energy_sqrt",
-    _active_law_macroscopic_huxley_two_moment_residual_expression,
-    1,
-    1,
-)
-ActiveLawMacroscopicHuxleyTwoMoment.declares_internal_expression(
-    "active_tension_discr",
-    _active_law_macroscopic_huxley_two_moment_residual_expression,
-    1,
-    2,
-)

physioblocks/simulation/runtime.py

@@ -37,6 +37,7 @@ from typing import Any, TypeAlias
 
 import numpy as np
 from numpy.typing import NDArray
+from rich.progress import Progress
 
 from physioblocks.computing.assembling import EqSystem
 from physioblocks.computing.models import ModelComponent
@@ -359,77 +360,82 @@ class ForwardSimulation(AbstractSimulation):
         """
         # initialize the simulation and save the initial results
         results = self._initialize()
-
-        try:
-            while self.time_manager.ended is False:
-                next_step = self.time_manager.time.new
-
-                self._update_time()
-
-                while (
-                    np.abs(next_step - self.time_manager.time.current)
-                    > self.time_manager.min_step
-                ):
-                    self.state.reset_state_vector()
-
-                    sol = self.solver.solve(self.state, self.eq_system)
-
-                    if sol.converged is False:
-                        inter_time = 0.5 * self.time_manager.current_step_size
-                        if inter_time < self.time_manager.min_step:
-                            raise ConvergenceError(
-                                str.format(
-                                    "The solver did not converge at {0}s for minimal"
-                                    "time step {1}",
-                                    self.time_manager.time.current,
-                                    self.time_manager.min_step,
+        progress_step_update = (
+            100.0 * self.time_manager.step_size / self.time_manager.duration
+        )
+        with Progress() as progress:
+            try:
+                sim_task = progress.add_task("Simulation in progress...")
+                while self.time_manager.ended is False:
+                    next_step = self.time_manager.time.new
+
+                    self._update_time()
+
+                    while (
+                        np.abs(next_step - self.time_manager.time.current)
+                        > self.time_manager.min_step
+                    ):
+                        self.state.reset_state_vector()
+
+                        sol = self.solver.solve(self.state, self.eq_system)
+
+                        if sol.converged is False:
+                            inter_time = 0.5 * self.time_manager.current_step_size
+                            if inter_time < self.time_manager.min_step:
+                                raise ConvergenceError(
+                                    str.format(
+                                        "The solver did not converge at {0}s for "
+                                        "minimal time step {1}",
+                                        self.time_manager.time.current,
+                                        self.time_manager.min_step,
+                                    )
                                 )
-                            )
 
-                        self.time_manager.current_step_size = inter_time
-                        self.time_manager.time.update(
-                            self.time_manager.time.current
-                            + self.time_manager.current_step_size
-                        )
-                    else:
-                        self.state.set_state_vector(sol.x)
-
-                        self.time_manager.update_time()
-                        if (
-                            np.abs(next_step - self.time_manager.time.current)
-                            >= self.time_manager.min_step
-                        ):
-                            self.time_manager.current_step_size = (
-                                next_step - self.time_manager.time.current
-                            )
-                            self.time_manager.time.update(next_step)
-                        else:
-                            self.time_manager.time.initialize(next_step)
-                            self.time_manager.current_step_size = (
-                                self.time_manager.step_size
-                            )
+                            self.time_manager.current_step_size = inter_time
                             self.time_manager.time.update(
                                 self.time_manager.time.current
                                 + self.time_manager.current_step_size
                             )
+                        else:
+                            self.state.set_state_vector(sol.x)
+
+                            self.time_manager.update_time()
+                            if (
+                                np.abs(next_step - self.time_manager.time.current)
+                                >= self.time_manager.min_step
+                            ):
+                                self.time_manager.current_step_size = (
+                                    next_step - self.time_manager.time.current
+                                )
+                                self.time_manager.time.update(next_step)
+                            else:
+                                progress.update(sim_task, advance=progress_step_update)
+                                self.time_manager.time.initialize(next_step)
+                                self.time_manager.current_step_size = (
+                                    self.time_manager.step_size
+                                )
+                                self.time_manager.time.update(
+                                    self.time_manager.time.current
+                                    + self.time_manager.current_step_size
+                                )
 
-                self.state.set_state_vector(sol.x)
-                results.append(self._get_current_result())
-        except Exception as exception:
-            log_exception(
-                _logger,
-                type(exception),
-                exception,
-                exception.__traceback__,
-                logging.DEBUG,
-            )
-            raise SimulationError(
-                str.format(
-                    "An error caused the simulation to stop prematurely",
-                    intermediate_results=results,
-                ),
-                results,
-            ) from exception
+                    self.state.set_state_vector(sol.x)
+                    results.append(self._get_current_result())
+            except Exception as exception:
+                log_exception(
+                    _logger,
+                    type(exception),
+                    exception,
+                    exception.__traceback__,
+                    logging.DEBUG,
+                )
+                raise SimulationError(
+                    str.format(
+                        "An error caused the simulation to stop prematurely",
+                        intermediate_results=results,
+                    ),
+                    results,
+                ) from exception
 
         self._finalize()
         return results

{physioblocks-1.0.3.dist-info → physioblocks-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physioblocks
-Version: 1.0.3
+Version: 1.1.1
 Dynamic: Author
 Dynamic: Author-email
 Dynamic: License
@@ -31,6 +31,7 @@ Requires-Dist: pandas
 Requires-Dist: plotly
 Requires-Dist: pyarrow
 Requires-Dist: regex
+Requires-Dist: rich
 Requires-Dist: scipy
 Provides-Extra: doc
 Requires-Dist: sphinx; extra == 'doc'

{physioblocks-1.0.3.dist-info → physioblocks-1.1.1.dist-info}/RECORD

@@ -1,10 +1,10 @@
-physioblocks/__init__.py,sha256=cISNrgJhzM89OfbdFh9adOQcp0TvpiqizNJtm-sBWEE,1169
+physioblocks/__init__.py,sha256=NthjhG_G55GynSs5McIQOqRAVapELOh35oy3nf19u-E,1169
 physioblocks/base/__init__.py,sha256=2h6bk0fe8pwQvJ15Buytg4SZzYOH-Ep7WqoD6pd1eOQ,986
 physioblocks/base/operators.py,sha256=uUfswQZsaMNd2bd7wsaxSGFIYLAr1hQCQ6SQfYawdBc,5689
 physioblocks/base/registers.py,sha256=Cd0hmy1XqojjPQgb_jn4mGeAMTyWWgDkl3qJHCVjCRU,3119
 physioblocks/computing/__init__.py,sha256=rLjuzRCA0nVAnHcYsL0jhn2KQpl6MnC3DJLf3a0i6uw,1302
 physioblocks/computing/assembling.py,sha256=2pKNA85PWJJ4fwSPRi7IitMdjlYTTiWQIgnKyhHja-8,9308
-physioblocks/computing/models.py,sha256=2V5Xbsoy3jK_OcubTKxmTUa7nKBag0x-T4Zivcul7So,24489
+physioblocks/computing/models.py,sha256=3CbSsbvEvHg4dgHFF-I7UZSY3O9tg_SxYJcKjAAQdJs,33556
 physioblocks/computing/quantities.py,sha256=f2wU0VDylJ8nuUtOsV0FsA1mJnqNy1AvoK6-w04Fctc,8934
 physioblocks/configuration/__init__.py,sha256=XNeIev97Fc9DAy_mA3CAZ0kMif7Nkop9sCI38ZZ2wgM,1454
 physioblocks/configuration/aliases.py,sha256=o7E54IYeW0NfmCX_r3zLKURVHsQoCmTlLD5085kY0eg,6302
@@ -25,7 +25,7 @@ physioblocks/description/nets.py,sha256=pKG2uB-4dABc-lvGswkybiho18bOkUwsVJYBdlX7
 physioblocks/io/__init__.py,sha256=bOGWA0hAifT9wHxD4kWFQuAXpAx0GzDmGfmcgNDUCGo,990
 physioblocks/io/aliases.py,sha256=d_Gqz0-8SVD6tA9N-T9xYL8SRhaSMmIOjqvOKHBb-Yo,2288
 physioblocks/io/configuration.py,sha256=UY8whA_7KcMwi_gXPIt5h8_gD7TKO2Co5cyf9MHO0yg,3578
-physioblocks/launcher/__main__.py,sha256=pLTJzaMZGN7elr8aAvgkjYOhnp6fbGouH5SWq_5bKIg,8811
+physioblocks/launcher/__main__.py,sha256=BMErik5JIbCKmjZecQHMUUq5_GQeRQg8zLwYvHFelxk,8968
 physioblocks/launcher/configuration.py,sha256=dqHCR_7PSDInA8NC3NFONqK3PPwSQYpLkZgYSyVU1vs,7959
 physioblocks/launcher/constants.py,sha256=FIBKde1vJrUzMk9dSl4q8f8jqN7bFxYF05EIG2-V0zw,3033
 physioblocks/launcher/files.py,sha256=zvif_8Woh3vEYCb_K3YnFFZYpgMhdlf4c2OSIVW4jC4,4950
@@ -51,9 +51,9 @@ physioblocks/library/aliases/simulations/newton_method_solver.json,sha256=p0jgVC
 physioblocks/library/aliases/simulations/spherical_heart_forward_simulation.jsonc,sha256=CXG5m8lRftbqYUchDedA_ggO81v1M0qiqyshRCMOl4E,5664
 physioblocks/library/aliases/simulations/spherical_heart_with_respiration_forward_simulation.jsonc,sha256=kCy065DN5Cau3d7ouuzdDAaLevBuzlnZkWtROG3DgtY,1542
 physioblocks/library/blocks/__init__.py,sha256=EhnoyZYTooSd_cTfysnT-YR6Ylrn15dJsfWwALFV00I,991
-physioblocks/library/blocks/capacitances.py,sha256=-coa-Zb4rVHwZVM2ip3iAHKURlQ9Mzw4Q34eCc-DHKc,14175
-physioblocks/library/blocks/cavity.py,sha256=JODm84TYz0Zuji3QXHb-bhQZlM_QZh6lTluf_8c0GL8,6064
-physioblocks/library/blocks/valves.py,sha256=jMo5ZaBIONaiG-e2y-5zRnayOq7YhsG44zL6mn900Ag,7747
+physioblocks/library/blocks/capacitances.py,sha256=fMd-UXv4b4ggfOn1qjPj0xxR7q4Dk4-N7NKdIS_aVjc,13011
+physioblocks/library/blocks/cavity.py,sha256=SgiBs4xeuIC1pXj_ZffEleA1Aw8AAvFdMKkf_I4IkCI,5632
+physioblocks/library/blocks/valves.py,sha256=S-5uZ2jRE7r7zc24Lpl2ryNutH3OxPOHHI3AlDUpkgQ,7223
 physioblocks/library/functions/__init__.py,sha256=k9cFPqrsApbeSkcnu-FbhonilTTeJS0Cp5EJCrfPeII,988
 physioblocks/library/functions/base_operations.py,sha256=TpN7rabrX9Nojd2uu90j1Dw_7OpdjbBSuiM_HWzJH3M,3507
 physioblocks/library/functions/first_order.py,sha256=oSkFyECA7ywgQCYKt-sEZmSu84QrRere_Ee736vk2Ik,3687
@@ -61,7 +61,7 @@ physioblocks/library/functions/piecewise.py,sha256=xpR22eP0Jkfuskc737uttenbpOOMX
 physioblocks/library/functions/trigonometric.py,sha256=Y5UolXZTASEi4EH_GpLpUIxMZbXIVHc-THFEXg9vrtg,2126
 physioblocks/library/functions/watchers.py,sha256=fY1SSPn-7R9cix0VMFP69H5-pmJzl4OXs1tgvjCetvM,3212
 physioblocks/library/model_components/__init__.py,sha256=JcDL2PaPTrT9mTlDUbPjUsyFfsiGh5GgroJ7J3g2uwE,998
-physioblocks/library/model_components/active_law.py,sha256=97D3fC7Dmzw8jLqDALxUJgl48EZYOx39SYjZgGJx-Eo,11634
+physioblocks/library/model_components/active_law.py,sha256=EWVG6C13VxUydUKebDUqeKtEra0mbFwU0wfgIAEURmw,11692
 physioblocks/library/model_components/dynamics.py,sha256=T-ZmfhTgtr1Tj6434GDYU-5XSztHx-dd6sf228c4cyo,35198
 physioblocks/library/model_components/rheology.py,sha256=7x5RrB_0DXMWlm0mIrTxdLlsjXVa1WPuFYYifW4fKeg,4724
 physioblocks/library/model_components/velocity_law.py,sha256=UYr9MywlLkRw0LszK0u_AamwThjobDMV9jYbaSbdDkU,5047
@@ -72,7 +72,7 @@ physioblocks/registers/type_register.py,sha256=JUlrPfP-X_TjIOHewSTkzf7Ck3L0ivVoH
 physioblocks/simulation/__init__.py,sha256=wqKVI3OLLVWuQoUcWwKSs5ibdkTP3Da_5DOe36v1up4,1504
 physioblocks/simulation/constants.py,sha256=w9CsB4V7YtvcdW4N1p7Iu6MeV4i-kazcEPAygE7mSx0,1075
 physioblocks/simulation/functions.py,sha256=c6HFwXK8IAzH7gSkz9aMiXLqnWXn_4_9WsX4jrGN9pY,2307
-physioblocks/simulation/runtime.py,sha256=JDRBoN5lSDUmEKohXIWPadxjO6JcFHd7JYzUlkFrzxE,15498
+physioblocks/simulation/runtime.py,sha256=Moa6S1iR7oPuni8yvO7VwmBsubMcJMpIUeowk1BLaC0,16104
 physioblocks/simulation/saved_quantities.py,sha256=fKWr1wScqxHPhuCE7aDNs8lpm9oWfyLN8NZDus2knPM,4111
 physioblocks/simulation/setup.py,sha256=UmIklaHmfkxi_BIdYKOhorLoC9QT9D4oEXwC-Xfd6v0,18109
 physioblocks/simulation/solvers.py,sha256=xztL-QboEO2mgtws13QE0-wHJ22vjQQzAQahYfxXVBQ,7226
@@ -86,8 +86,8 @@ physioblocks/utils/math_utils.py,sha256=w5MDs4cP5WiTPHe8WofFuNZZ20WDNLT0XmFGlbis
 physioblocks/references/circulation_alone_sim.jsonc,sha256=qv27nzmK7jennhtCJ7wQ_f83mt9_YJSOTABjGCYMcZw,736
 physioblocks/references/spherical_heart_respiration_sim.jsonc,sha256=kKq5xf94r90O1KpkCHk1qwgy6DJ37ePo3-8buEtcu5Y,1397
 physioblocks/references/spherical_heart_sim.jsonc,sha256=kGGBqxY8dnmGKmpMv216kbneyJRGz_3VkcYn1OWavIA,1151
-physioblocks-1.0.3.dist-info/METADATA,sha256=-_Pm7SVFyAzY4eHI79u3CGR93C-Yo5iWGwUJzDtM6gM,4708
-physioblocks-1.0.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-physioblocks-1.0.3.dist-info/licenses/licenses/GPL-3.0-only.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-physioblocks-1.0.3.dist-info/licenses/licenses/LGPL-3.0-only.txt,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-physioblocks-1.0.3.dist-info/RECORD,,
+physioblocks-1.1.1.dist-info/METADATA,sha256=eDM0OMOHOexQxV_g4XMTCVcr9eJQYFoHVkqzSZ4O5Hk,4728
+physioblocks-1.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+physioblocks-1.1.1.dist-info/licenses/licenses/GPL-3.0-only.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+physioblocks-1.1.1.dist-info/licenses/licenses/LGPL-3.0-only.txt,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+physioblocks-1.1.1.dist-info/RECORD,,