physioblocks 1.0.0__py3-none-any.whl

physioblocks/library/functions/first_order.py

@@ -0,0 +1,113 @@
+# 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/>.
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from numpy.typing import NDArray
+
+from physioblocks.registers.type_register import register_type
+from physioblocks.simulation import AbstractFunction
+
+# First order function id
+FIRST_ORDER_NAME = "first_order"
+
+
+@register_type(FIRST_ORDER_NAME)
+class FirstOrder(AbstractFunction):
+    """
+    Defines an evaluation method to get the value of a sum of first order functions
+    with heavyside for the given time.
+    """
+
+    times_start: NDArray[np.float64]
+    """Start times of first order components"""
+
+    amplitudes: NDArray[np.float64]
+    """Amplitudes of first order components"""
+
+    time_constants: NDArray[np.float64]
+    """Time constants of first order components"""
+
+    baseline_value: np.float64
+    """Baseline value of the function"""
+
+    def __init__(
+        self,
+        times_start: NDArray[np.float64],
+        amplitudes: NDArray[np.float64],
+        time_constants: NDArray[np.float64],
+        baseline_value: np.float64,
+    ):
+        # test arguments size consistency
+        if not (
+            (len(times_start) == len(amplitudes))
+            and (len(times_start) == len(time_constants))
+        ):
+            msg_error = (
+                "arguments 'times_start', 'amplitudes' and 'time_constants' "
+                "must have the same length. Got: "
+                f"- times_start (len = {len(times_start)}): {times_start}; "
+                f"- amplitudes (len = {len(amplitudes)}): {amplitudes}; "
+                f"- time_constants (len = {len(time_constants)}): {time_constants}."
+            )
+            raise ValueError(msg_error)
+
+        # reorder array arguments to have ascending times_start
+        sorted_indices = np.argsort(times_start)
+        amplitudes = amplitudes[sorted_indices]
+        time_constants = time_constants[sorted_indices]
+
+        # assign properties
+        self.times_start = times_start
+        self.amplitudes = amplitudes
+        self.time_constants = time_constants
+        self.baseline_value = baseline_value
+
+    def eval(self, time: np.float64) -> Any:
+        """
+        Evaluate function value at the given time.
+
+        :param time: evaluation  time
+        :type time: np.float64
+
+        :return: the function value
+        :rtype: np.float64
+        """
+
+        mask_activated = self.times_start <= time
+        amplitudes_activ = self.amplitudes[mask_activated]
+        time_cst_activ = self.time_constants[mask_activated]
+        times_start_activ = self.times_start[mask_activated]
+
+        output = self.baseline_value + np.sum(
+            amplitudes_activ
+            * (1 - np.exp(-(time - times_start_activ) / time_cst_activ))
+        )
+
+        return output

physioblocks/library/functions/piecewise.py

@@ -0,0 +1,271 @@
+# 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/>.
+
+"""Declare functions to define piecewise functions in the configuration"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+from numpy.typing import NDArray
+
+from physioblocks.registers.type_register import register_type
+from physioblocks.simulation import AbstractFunction
+
+# Piecewise linear function type name
+PIECEWISE_LINEAR_NAME = "piecewise_linear"
+
+
+@register_type(PIECEWISE_LINEAR_NAME)
+@dataclass
+class PiecewiseLinear(AbstractFunction):
+    """
+    Defines an evaluation method to get the value of a piecewise function
+    for the given time.
+    """
+
+    points_abscissas: NDArray[np.float64]
+    """The function abscissas"""
+
+    points_ordinates: NDArray[np.float64]
+    """The function ordinates"""
+
+    left_value: np.float64 | None = None
+    """Function value when the evaluation point is before the provided abscissas.
+    If it is not provided, it is the first ordinate value."""
+
+    right_value: np.float64 | None = None
+    """Function value when the evaluation point is after the provided abscissas.
+    If it is not provided, it is the last ordinate value."""
+
+    def eval(self, time: np.float64) -> Any:
+        """
+        Evaluate piecewise function for the given time.
+
+        :param time: the evaluated time
+        :type time: np.float64
+
+        :return: the activation point_value
+        :rtype: np.float64
+        """
+        return np.interp(
+            time,
+            self.points_abscissas,
+            self.points_ordinates,
+            self.left_value,
+            self.right_value,
+        )
+
+
+# Piecewise linear periodic function id
+PIECEWISE_LINEAR_PERIODIC_NAME = "piecewise_linear_periodic"
+
+
+@register_type(PIECEWISE_LINEAR_PERIODIC_NAME)
+@dataclass
+class PiecewiseLinearPeriodic(AbstractFunction):
+    """
+    Defines an evaluation method to get the value of a piecewise periodic function
+    for the given time.
+    """
+
+    period: np.float64
+    """The function period"""
+
+    points_abscissas: NDArray[np.float64]
+    """The function abscissas"""
+
+    points_ordinates: NDArray[np.float64]
+    """The function ordinates"""
+
+    def eval(self, time: np.float64) -> Any:
+        """
+        Evaluate piecewise periodic function for the given time.
+
+        :param time: the evaluated time
+        :type time: np.float64
+
+        :return: the activation point_value
+        :rtype: np.float64
+        """
+        return np.interp(
+            time, self.points_abscissas, self.points_ordinates, period=self.period
+        )
+
+
+# Rescale Two Phases function id
+RESCALE_TWO_PHASES_FUNCTION_NAME = "rescale_two_phases_function"
+
+
+@register_type(RESCALE_TWO_PHASES_FUNCTION_NAME)
+class RescaleTwoPhasesFunction(AbstractFunction):
+    """
+    Rescale each part of the input function (a linear interpollation) depending on
+    the proportion of variation of phase 0 when the period differs from the
+    reference function.
+    """
+
+    rescaled_period: float
+    """The actual function period"""
+
+    reference_function: list[tuple[float, float]]
+    """The reference function. Coordinates format is ``(abscissa, ordinate)``"""
+
+    alpha: float
+    """Proportion of the variation of phase 0"""
+
+    phases: list[int]
+    """For each intervals point of the reference, determine if it belong to
+    phase 0 or 1."""
+
+    def __init__(
+        self,
+        rescaled_period: float,
+        reference_function: list[tuple[float, float]],
+        alpha: float,
+        phases: list[int],
+    ):
+        if len(phases) != len(reference_function) - 1:
+            raise ValueError(
+                "A phase should be defined for each interval defined in the "
+                "reference function."
+            )
+
+        if any([elem not in [0, 1] for elem in phases]):
+            raise ValueError(
+                str.format(
+                    "There are only two phases allowed: 0 or 1, got {0}.", phases
+                )
+            )
+
+        if alpha >= 1.0 or alpha <= 0.0:
+            raise ValueError(
+                str.format(
+                    "The proportion of the variation of phase 0 should be in ]0, 1[, "
+                    "got {0}",
+                    alpha,
+                )
+            )
+
+        # check if the reference function is sorted
+        if (
+            all(
+                [
+                    reference_function[k][0] > reference_function[k - 1][0]
+                    for k in range(1, len(reference_function))
+                ]
+            )
+            is False
+        ):
+            raise ValueError(
+                str.format(
+                    "Reference function abscissas should be sorted, got {0}",
+                    [coord[0] for coord in reference_function],
+                )
+            )
+
+        self.reference_function = reference_function
+        reference_period = (
+            self.reference_function[-1][0] - self.reference_function[0][0]
+        )
+        self.phases = phases
+        self.alpha = alpha
+
+        self.beta = rescaled_period / reference_period
+        duration_phase_0_ref = sum(
+            [
+                self.reference_function[index][0]
+                - self.reference_function[index - 1][0]
+                for index in range(1, len(self.reference_function))
+                if phases[index - 1] == 0
+            ]
+        )
+        duration_phase_1_ref = reference_period - duration_phase_0_ref
+
+        scale_factor_phase_0 = (
+            1.0
+            + self.alpha * (self.beta - 1.0) * reference_period / duration_phase_0_ref
+        )
+        scale_factor_phase_1 = (
+            1.0
+            + (1.0 - self.alpha)
+            * (self.beta - 1.0)
+            * reference_period
+            / duration_phase_1_ref
+        )
+
+        if scale_factor_phase_0 <= 0 or scale_factor_phase_1 <= 0:
+            raise ValueError(
+                str.format(
+                    "Scale factors should not be negatives. Got ({0}, {1}) for "
+                    "phase 0 and 1 respectivly. You can try changing alpha.",
+                    scale_factor_phase_0,
+                    scale_factor_phase_1,
+                )
+            )
+        abscissas = [self.reference_function[0][0]]
+        for index in range(1, len(self.reference_function)):
+            rescaled_abs = (
+                abscissas[index - 1]
+                + (
+                    self.reference_function[index][0]
+                    - self.reference_function[index - 1][0]
+                )
+                * scale_factor_phase_0
+                if phases[index - 1] == 0
+                else abscissas[index - 1]
+                + (
+                    self.reference_function[index][0]
+                    - self.reference_function[index - 1][0]
+                )
+                * scale_factor_phase_1
+            )
+            abscissas.append(rescaled_abs)
+
+        ordinates = [value[1] for value in self.reference_function]
+
+        self.rescaled_period = abscissas[-1]
+        self.function_abcissas = np.array(abscissas)
+        self.function_ordinates = np.array(ordinates)
+
+    def eval(self, time: float) -> Any:
+        """
+        Evaluate the function.
+
+        :param time: the evaluated time
+        :type time: float
+
+        :return: the function value
+        :rtype: np.float64
+        """
+        return np.interp(
+            time,
+            self.function_abcissas,
+            self.function_ordinates,
+            period=self.rescaled_period,
+        )

physioblocks/library/functions/trigonometric.py

@@ -0,0 +1,78 @@
+# 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/>.
+
+"""
+Declare configuration function to set parameter with trigonometric function.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+from physioblocks.registers.type_register import register_type
+from physioblocks.simulation import AbstractFunction
+
+# sinus with offset function id
+SINUS_OFFSET_NAME = "sinus_offset"
+
+
+@register_type(SINUS_OFFSET_NAME)
+@dataclass
+class SinusOffset(AbstractFunction):
+    """
+    Defines an evaluation method to get the value of a offset sinus
+    function.
+    """
+
+    offset_value: float
+    """Offset value of the function"""
+
+    amplitude: float
+    """Peak amplitude of the function"""
+
+    frequency: float
+    """Frequency of the function"""
+
+    phase_shift: float
+    """Phase shift of the function"""
+
+    def eval(self, time: float) -> Any:
+        """
+        Evaluate function value at the given time.
+
+        :param time: evaluation  time
+        :type time: float
+
+        :return: the function value
+        :rtype: np.float64
+        """
+
+        output = self.offset_value + self.amplitude * np.sin(
+            2 * np.pi * self.frequency * time + self.phase_shift
+        )
+
+        return output

physioblocks/library/functions/watchers.py

@@ -0,0 +1,113 @@
+# 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/>.
+
+"""
+Watcher are useful functions to use to set **Output Functions**
+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.computing.models import Block
+from physioblocks.computing.quantities import Quantity
+from physioblocks.registers.type_register import register_type
+from physioblocks.simulation import AbstractFunction
+
+# Quantity Watcher function type name
+WATCH_QUANTITY_TYPE_ID = "watch_quantity"
+
+
+@dataclass
+@register_type(WATCH_QUANTITY_TYPE_ID)
+class WatchQuantity(AbstractFunction, AbstractBaseOperators):
+    """
+    Return the current value of the watch quantity.
+    """
+
+    quantity: Quantity[Any]
+    """The quantities to watch"""
+
+    @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:
+        """Just return the watched quantity current value
+
+        :return: the watched quantity current value
+        :rtype: np.float64 | np.ndarray"""
+        return self.quantity.current
+
+
+# Sum Blocks Quantity function type name
+SUM_BLOCKS_QUANTITY_TYPE_ID = "sum_blocks_quantity"
+
+
+@dataclass
+@register_type(SUM_BLOCKS_QUANTITY_TYPE_ID)
+class SumBlocksQuantity(AbstractFunction, AbstractBaseOperators):
+    """Sum the current values of quantities with the given name
+    for each the blocks."""
+
+    quantity_id: str
+    """block local id of the quantity to sum"""
+
+    elements: Iterable[Block] = field(default_factory=list)
+    """the blocks holding the quantity to sum"""
+
+    @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 quantities
+
+        :return: the sum of the quantities
+        :rtype: Any
+        """
+        return np.sum(
+            [getattr(block, self.quantity_id).current for block in self.elements]
+        )

physioblocks/library/model_components/__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 the available model components"""