physioblocks 1.0.0__py3-none-any.whl

physioblocks/utils/gradient_test_utils.py

@@ -0,0 +1,337 @@
+# 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 functions to perform gradient tests to check the coherence between an
+function and its gradient.
+
+The gradient test principle is to compare the result of a **computed** and estimated
+gradient from a :class:`~physioblocks.computing.assembling.EqSystem` object.
+"""
+
+from __future__ import annotations
+
+import logging
+from os import linesep
+from typing import Any
+
+import numpy as np
+from numpy.typing import NDArray
+from scipy.optimize import approx_fprime
+
+import physioblocks.simulation.setup as setup
+from physioblocks.computing.assembling import EqSystem
+from physioblocks.computing.models import Block, Expression, ModelComponent
+from physioblocks.configuration.aliases import unwrap_aliases
+from physioblocks.configuration.functions import load
+from physioblocks.io.configuration import read_json
+from physioblocks.simulation.runtime import AbstractSimulation
+from physioblocks.simulation.state import State
+
+_logger = logging.getLogger(__name__)
+
+_ZERO = 1e-16
+_REL_TOL = 1e-6
+_NEW_STATE_SHIFT_FACTOR = 1e-3
+_SHIFT_FACTOR = 1e-4
+_CONVERGENCE_FACTOR = 0.1
+_CONVERGENCE_TOL = 0.11
+
+
+def gradient_test_from_file(config_file_path: str) -> bool:
+    """
+    Read the given configuration file and perform a gradient test on the full Net
+    with the provided parameters and variables.
+
+    .. warning::
+
+        Every type (especially **Blocks**, **ModelComponents** and **Functions**) and
+        alias used in the configuration file have to be loaded.
+        Follow this
+        :ref:`user guide section <user_guide_level_3_block_test_dynamic_import>`
+        to import libraries and aliases dynamically.
+
+    :param config_file_path: the file path to the simulation configuration file.
+    :type config_file_path: str
+
+    :return: True if the gradient test is successfull, false otherwise.
+    """
+    configuration = read_json(config_file_path)
+    configuration = unwrap_aliases(configuration)
+    sim: AbstractSimulation = load(configuration)
+    sim._initialize()  # noqa SLF001
+    return gradient_test(
+        sim.eq_system,
+        sim.state,
+        sim.solver._get_state_magnitude(sim.state, sim.magnitudes),  # noqa: SLF001
+    )
+
+
+def gradient_test_from_model(
+    model: ModelComponent, state: State, state_magnitude: NDArray[np.float64]
+) -> bool:
+    """
+    Create an equation system for the given block only and perform a gradient test.
+
+    .. note::
+
+        It does not test the submodels of the model.
+
+    :param model: the model to test.
+    :type model: str
+
+    :param state: the state used to determine the variables in the model.
+    :type state: str
+
+    :param state_magnitude: the state variables magnitudes
+    :type state_magnitude: str
+
+    :return: True if the gradient test is successfull, false otherwise.
+    """
+    line_index = 0
+    expressions = setup.SystemExpressions()
+    for internal_expr_def in type(model).internal_expressions:
+        expressions.append((line_index, internal_expr_def.expression, model))
+        line_index += internal_expr_def.expression.size
+
+    if isinstance(model, Block):
+        for fluxes_expr_def in type(model).fluxes_expressions.values():
+            expressions.append((line_index, fluxes_expr_def.expression, model))
+            line_index += fluxes_expr_def.expression.size
+
+    eq_system = setup.build_eq_system(expressions, state)
+    model.initialize()
+    return gradient_test(eq_system, state, state_magnitude)
+
+
+def gradient_test_from_expression(
+    expr: Expression,
+    expr_params: Any,
+    state: State,
+    state_magnitude: NDArray[np.float64],
+) -> bool:
+    """
+    Create an equation system for the given expression only and perform a gradient test.
+
+    :param expr: the expression to test.
+    :type expr: Expression
+
+    :param expr_params: the parameters to pass to the expression
+    :type expr_params: Any
+
+    :param state: the state used to determine the variables in the expression.
+    :type state: str
+
+    :param state_magnitude: the state variables magnitudes
+    :type state_magnitude: str
+
+    :return: True if the gradient test is successfull, false otherwise.
+    :rtype: bool
+    """
+
+    eq_system = setup.build_eq_system([(0, expr, expr_params)], state)
+    return gradient_test(eq_system, state, state_magnitude)
+
+
+def gradient_test(
+    eq_system: EqSystem, state: State, state_magnitude: NDArray[np.float64]
+) -> bool:
+    """
+    Test the computed gradient for the equation system by comparing it to
+    a gradient estimated with finite differences.
+
+    :param eq_system: the equation system providing method to compute a residual and a
+      gradient
+    :type eq_system: EqSystem
+
+    :param state: system state
+    :type state: State
+
+    :param state_magnitude: the state variables magnitudes
+    :type state_magnitude: str
+
+    :return: True if the estimated and computed gradient meet tolerance,
+      False otherwise.
+    """
+
+    _logger.info(str.format("State:{0}{1}", linesep, state))
+    _logger.info(str.format("System:{0}{1}", linesep, eq_system))
+
+    new_state = state.state_vector + _NEW_STATE_SHIFT_FACTOR * state_magnitude
+
+    shift_1 = _SHIFT_FACTOR * state_magnitude
+    state.update_state_vector(new_state)
+
+    res = eq_system.compute_residual()
+    grad = eq_system.compute_gradient()
+
+    grad_estimated_1 = _estimate_gradient(eq_system, shift_1, state)
+
+    shift_2 = _CONVERGENCE_FACTOR * shift_1
+    state.update_state_vector(new_state)
+    grad_estimated_2 = _estimate_gradient(eq_system, shift_2, state)
+
+    state.update_state_vector(new_state)
+
+    with np.printoptions(precision=9, linewidth=10000, suppress=True):
+        _logger.debug(str.format("Residual:{0}{1}", linesep, res))
+        _logger.debug(str.format("Gradient{0}{1}", linesep, grad))
+        _logger.debug(
+            str.format("Gradient Estimated:{0}{1}", linesep, grad_estimated_1)
+        )
+
+    grad_error_pos = get_errors_gradient(grad, grad_estimated_1, grad_estimated_2)
+
+    error_message = str.format("State:{0}{1}", linesep, state)
+    error_message += str.format("System:{0}{1}{0}{0}", linesep, eq_system)
+
+    for line_error, col_error in grad_error_pos:
+        error_msg_line = str.format(
+            "Error in gradient at ({0},{1}).{2}", line_error, col_error, linesep
+        )
+        _logger.debug(error_msg_line)
+        error_message += error_msg_line
+
+        error_msg_line = str.format(
+            "Variable Id: {0}.{1}", state.get_variable_id(col_error), linesep
+        )
+        _logger.debug(error_msg_line)
+
+        error_msg_line = str.format("Residual Index: {0}.{1}{1}", line_error, linesep)
+        _logger.debug(error_msg_line)
+
+    if len(grad_error_pos) != 0:
+        raise GradientError(error_message)
+
+    return len(grad_error_pos) == 0
+
+
+def _estimate_gradient(
+    eq_system: EqSystem, shift: NDArray[np.float64], state: State
+) -> NDArray[np.float64]:
+    """
+    Gradient finite difference estimation
+
+    :param eq_system: the equation system providing method to compute a residual
+      and a gradient
+    :type eq_system: EqSystem
+
+    :param shift_factor: the shift factor to apply on the state (can be 0).
+      It is multiplied with the variables magnitude then added to the state.
+    :type shift_factor: NDArray
+
+    :param state: system state
+    :type state: State
+    """
+
+    def residual(x: NDArray[np.float64]) -> NDArray[np.float64]:
+        state.update_state_vector(x)
+        res = eq_system.compute_residual()
+
+        return res
+
+    x0 = state.state_vector
+    grad_est = np.atleast_2d(approx_fprime(x0, residual, shift))
+
+    return grad_est
+
+
+def get_errors_gradient(
+    computed: NDArray[np.float64],
+    estimated_1: NDArray[np.float64],
+    estimated_2: NDArray[np.float64],
+) -> list[tuple[int, int]]:
+    """
+    Get the ``(line, column)`` positions of the errors in the gradient matrix.
+
+    :param computed: computed gradient
+    :type computed: NDArray[np.float64]
+
+    :param estimated_1: first gradient estimate
+    :type estimated_1: NDArray[np.float64]
+
+    :param estimated_2: second gradient estimate
+    :type estimated_2: NDArray[np.float64]
+
+    :return: the position of the errors in the gradient matrix
+    :rtype: list[tuple[int, int]]
+    """
+    abs_computed = np.abs(computed)
+
+    error_1 = np.empty(computed.shape)
+    error_1[:] = np.inf
+    error_2 = error_1.copy()
+
+    for grad_line in range(0, computed.shape[0]):
+        for grad_col in range(0, computed.shape[1]):
+            if abs_computed[grad_line, grad_col] < _ZERO:
+                error_1[grad_line, grad_col] = (
+                    np.abs(
+                        computed[grad_line, grad_col] - estimated_1[grad_line, grad_col]
+                    )
+                    / _ZERO
+                )
+                error_2[grad_line, grad_col] = (
+                    np.abs(
+                        computed[grad_line, grad_col] - estimated_2[grad_line, grad_col]
+                    )
+                    / _ZERO
+                )
+            else:
+                error_1[grad_line, grad_col] = (
+                    np.abs(
+                        computed[grad_line, grad_col] - estimated_1[grad_line, grad_col]
+                    )
+                    / abs_computed[grad_line, grad_col]
+                )
+                error_2[grad_line, grad_col] = (
+                    np.abs(
+                        computed[grad_line, grad_col] - estimated_2[grad_line, grad_col]
+                    )
+                    / abs_computed[grad_line, grad_col]
+                )
+
+    with np.printoptions(precision=9, linewidth=10000, suppress=False):
+        _logger.debug(str.format("Error:{0}{1}", error_1, linesep))
+
+    error_positions = []
+
+    for grad_line in range(0, computed.shape[0]):
+        for grad_col in range(0, computed.shape[1]):
+            if error_1[grad_line, grad_col] > _REL_TOL:
+                err_div = error_2[grad_line, grad_col] / error_1[grad_line, grad_col]
+                if err_div > _CONVERGENCE_TOL:
+                    error_positions.append((grad_line, grad_col))
+            elif np.isnan(error_1[grad_line, grad_col]):
+                error_positions.append((grad_line, grad_col))
+
+    return error_positions
+
+
+class GradientError(Exception):
+    """Error raised when the estimated and computed gradients do not match."""
+
+    pass

physioblocks/utils/math_utils.py

@@ -0,0 +1,109 @@
+# 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 some math functions to help compute quantities"""
+
+from typing import Any
+
+import numpy as np
+
+
+def exp_diff(a: float, b: float, diff: float) -> Any:
+    """
+    Computes exponential differences with more numerical accuracy when a and b are close
+    using the relationship:
+
+    .. math::
+
+        e^a - e^b = 2\\ e^{\\frac{a + b}{2}}\\ \\text{sinh}(\\frac{a + b}{2})
+
+    :param a: value of a
+    :type a: np.float64
+
+    :param b: value of b
+    :type b: np.float64
+
+    :param diff: value of a - b
+    :type diff: np.float64
+
+    :return: exponential difference value
+    :rtype: np.float64
+    """
+    return np.exp(0.5 * (a + b)) * 2.0 * np.sinh(0.5 * diff)
+
+
+def power_diff(a: float, b: float, diff: float, n: int) -> Any:
+    """
+    Computes the a and b power n difference with more numerical accuracy when a and
+    b are close by using the following relationship:
+
+    .. math::
+
+        a^n - b^n = (a-b) * \\sum_{i = 0}^{n -1}{a^i b^{n-1-i}}
+
+    When n is negative, the following transformation is used:
+
+    .. math::
+
+        \\frac{1}{a^n} - \\frac{1}{b^n} = -\\frac{a^n-b^n}{{ab}^n}
+
+    :param a: value of a
+    :type a: np.float64
+
+    :param b: value of b
+    :type b: np.float64
+
+    :param diff: value of a - b
+    :type diff: np.float64
+
+    :return: the a and b power n difference value
+    :rtype: np.float64
+    """
+
+    if n < 0:
+        return -power_diff(a, b, diff, -n) / np.pow(a * b, -n)
+    elif n > 0:
+        return diff * _power_dec(a, b, n - 1, 0)
+    else:
+        return 0.0
+
+
+def _power_dec(a: float, b: float, n1: int, n2: int) -> Any:
+    """
+    Helper recursive function used by :func:`power_diff` to compute the term:
+
+    .. math::
+
+        \\sum_{i = 0}^{n -1}{a^i b^{n-1-i}}
+    """
+
+    if n1 != 0 or n2 != 0:
+        if n1 != 0:
+            return np.pow(a, n1) * np.pow(b, n2) + _power_dec(a, b, n1 - 1, n2 + 1)
+        else:
+            return np.pow(b, n2)
+
+    return 1.0

physioblocks-1.0.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: physioblocks
+Version: 1.0.0
+Dynamic: Author
+Dynamic: Author-email
+Dynamic: License
+Dynamic: License-Expression
+Summary: Physioblocks allows the simulation of dynamical models of physiological systems
+Project-URL: Homepage, https://github.com/physioblocks/physioblocks
+Project-URL: Documentation, https://physioblocks.gitlabpages.inria.fr/physioblocks/
+Project-URL: Issues, https://github.com/physioblocks/physioblocks/issues
+Project-URL: Discussions, https://github.com/physioblocks/physioblocks/discussions
+License-File: licenses/GPL-3.0-only.txt
+License-File: licenses/LGPL-3.0-only.txt
+Keywords: block diagram,cardiovascular modeling,dynamical systems,physiology
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: plotly
+Requires-Dist: pyarrow
+Requires-Dist: regex
+Requires-Dist: scipy
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == 'doc'
+Requires-Dist: sphinx-rtd-theme; extra == 'doc'
+Requires-Dist: sphinxcontrib-tikz; extra == 'doc'
+Provides-Extra: quality
+Requires-Dist: mypy; extra == 'quality'
+Requires-Dist: ruff; extra == 'quality'
+Provides-Extra: test
+Requires-Dist: coverage; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Provides-Extra: tox
+Requires-Dist: tox>=4; extra == 'tox'
+Description-Content-Type: text/markdown
+
+# PhysioBlocks
+
+PhysioBlocks allows the simulation of dynamical models of physiological systems.
+
+## User Levels
+
+They are several use cases for PhysioBlocks depending on the user profile:
+
+* __Level 1:__ Configure and run physiological systems simulation (for pre-existing systems)
+* __Level 2:__ Create new systems with existing blocks without writing code
+* __Level 3:__ Write and add new blocks to the library.
+
+## Principle
+
+* A __Net__ (system) is built from __Nodes__ and __Blocks__ connected by those nodes.
+* At each node in the net, connected blocks share __Degrees of Freedom__ (ex: pressure) and send __Fluxes__ that verify Kirchhoff Law.
+* __ModelComponents__ concatenate blocks equations to the global system (if necessary, for modularity purposes within the block)
+
+## Interactions
+
+__Level 1:__ Configure and run a simulation : JSON
+* Update the model parameters
+
+__Level 2:__ Create Nets : JSON
+* Declare the nodes, the blocks, and the block - nodes connections
+
+
+__Level 3:__ Write and add models to the library: Python
+* Declare the quantities to use in the model
+* Write the fluxes and equations
+
+## Documentation
+
+Here are the links to the sections of the [full documentation](https://physioblocks.gitlabpages.inria.fr/physioblocks/):
+* [Installation](https://physioblocks.gitlabpages.inria.fr/physioblocks/installation.html)
+* [User Guide](https://physioblocks.gitlabpages.inria.fr/physioblocks/user_guide.html)
+* [Library](https://physioblocks.gitlabpages.inria.fr/physioblocks/library.html)
+* [API Reference](https://physioblocks.gitlabpages.inria.fr/physioblocks/api_reference.html)
+
+## Quick start
+
+Complete instructions are available in the [documentation](https://physioblocks.gitlabpages.inria.fr/physioblocks/). This instructions will enable you to launch a reference simulation.
+
+### Installation
+
+This project requires a recent version of python installed.
+Then: 
+```
+    pip install physioblocks
+```
+
+### Configuration
+
+To configure PhysioBlocks Launcher:
+
+```
+# Create an empty folder where you want to store simulations results.
+mkdir $LAUNCHER_FOLDER_PATH$
+
+# Configure the folder
+python -m physioblocks.launcher.configure -d $LAUNCHER_FOLDER_PATH$ -v
+```
+
+### Launch a simulation
+
+With a Launcher folder configured:
+
+```
+# Move to your configured launcher folder
+cd $LAUNCHER_FOLDER_PATH$
+
+#  Launch a reference simulation
+python -m physioblocks.launcher references/spherical_heart_sim.jsonc -v -t -s QuickStart
+
+# This can take some time.
+```
+
+
+Results will be available in the `$LAUNCHER_FOLDER_PATH$/simulations/QuickStart` series folder.

physioblocks-1.0.0.dist-info/RECORD

@@ -0,0 +1,93 @@
+physioblocks/__init__.py,sha256=0ZHZb8nU30moO0pf0Z2UarcVWvhTPtI878IkQcpSDpc,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/quantities.py,sha256=f2wU0VDylJ8nuUtOsV0FsA1mJnqNy1AvoK6-w04Fctc,8934
+physioblocks/configuration/__init__.py,sha256=XNeIev97Fc9DAy_mA3CAZ0kMif7Nkop9sCI38ZZ2wgM,1454
+physioblocks/configuration/aliases.py,sha256=o7E54IYeW0NfmCX_r3zLKURVHsQoCmTlLD5085kY0eg,6302
+physioblocks/configuration/base.py,sha256=eLxZXZdc4QkSsA7TOA0-E5ckfMZZkdgPJ6JVrFwM4nY,3627
+physioblocks/configuration/constants.py,sha256=JsXGcoxHXgaixpIIiYZDPNiKSeD7Y_4YswVm0Uaf-Hs,3056
+physioblocks/configuration/functions.py,sha256=pJl5BkSwRoIydH3bSMNilu0wj7yOVJ_BVAPNS-yMl8k,23520
+physioblocks/configuration/computing/__init__.py,sha256=duNJXdaHTZ9_V9XScNXjJgPsKSc6FbHGrwNDLrcYDg8,1012
+physioblocks/configuration/computing/quantities.py,sha256=fM5L4YeeM1NQQjhbdU4e50yxZ9B2ogF0WzDIYqFDbgg,1721
+physioblocks/configuration/description/__init__.py,sha256=-KyjKPheXzgKiVZ0jL-nl8H-uN9cYjXJkX6XL6q9oVg,1169
+physioblocks/configuration/description/blocks.py,sha256=FGYFR5S15jGlZnIIfvZLdMr33bXabXMi9Vj9jETLeeM,8003
+physioblocks/configuration/description/nets.py,sha256=wKAH1Qq_tQ65-bn17qV6c_n0dt__PtY9r8TnYtZsPTY,5124
+physioblocks/configuration/simulation/__init__.py,sha256=RuRdBDvwqBcyghwh1D0ud3qwdUEcw2vgHPoB8drXp6w,1126
+physioblocks/configuration/simulation/simulations.py,sha256=4W-pcSDIMBKRFYjkkHOePrcZfXiFdfCHdyI_qpFSZ_c,8795
+physioblocks/description/__init__.py,sha256=o6G4LgLuSKSXOF6Uex-nua-8MyWsiwBd_G4dQLJsA6Y,1200
+physioblocks/description/blocks.py,sha256=y0qLvdE4VBmdDmOeHFaRFsmPRg-7_JVSGs2thAAUzHc,13542
+physioblocks/description/flux.py,sha256=aKs31bO1KyfAlHhmWUP9ZS7V7SryyVe_6MZG_Sp9jCQ,4858
+physioblocks/description/nets.py,sha256=pKG2uB-4dABc-lvGswkybiho18bOkUwsVJYBdlX7p5s,23604
+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/configuration.py,sha256=dqHCR_7PSDInA8NC3NFONqK3PPwSQYpLkZgYSyVU1vs,7959
+physioblocks/launcher/constants.py,sha256=FIBKde1vJrUzMk9dSl4q8f8jqN7bFxYF05EIG2-V0zw,3033
+physioblocks/launcher/files.py,sha256=zvif_8Woh3vEYCb_K3YnFFZYpgMhdlf4c2OSIVW4jC4,4950
+physioblocks/launcher/series.py,sha256=x2XazVzVT6Co8Nco92jdO8XlsjgCxFHkxGQZ5RSl4Ik,5048
+physioblocks/launcher/configure/__main__.py,sha256=4RPUtUSBV2DlJeHmOf0fqRFAdud3Tx12M-nKQ3epRGc,2955
+physioblocks/library/__init__.py,sha256=Yilh0uLw1Ac7xe9aLqCg-DFYQobzZJMk9B64cAuCUKk,1026
+physioblocks/library/aliases/blocks/c_block.json,sha256=-63XyPEv7xhvMoHIF9ShLIz8jqDRWkOyRAyfF4VpIFY,84
+physioblocks/library/aliases/blocks/rc_block.json,sha256=OesNIQadZainjoU7O0gXy2Tnd8LWoYsS6JM0XiwRacc,85
+physioblocks/library/aliases/blocks/rcr_block.json,sha256=u9ILSfzn29y84jGX-CnNFQkoPloE6YDc4rtHWTsUplM,86
+physioblocks/library/aliases/blocks/spherical_cavity_block.json,sha256=_cWeg4kHL2Cm9t6em3eoMUIZov04XgysRq3R6ZduSQM,99
+physioblocks/library/aliases/blocks/valve_rl_block.json,sha256=cuNCgx88JkP7FfNH6mHHCxRB-jt8d3PySbkVGzIuLXQ,91
+physioblocks/library/aliases/flux/heart_flux_dof_couples.jsonc,sha256=P09q70D-qIoj6l2IcwN3LQaPqZ8sJ_m7Fm2sf9H00Uw,83
+physioblocks/library/aliases/model_components/active_law_macro_huxley_two_moments.json,sha256=Pw4ZupAKIDukUXCAXZ3ERNF7RoEzNtgUC-umuqGDnIw,112
+physioblocks/library/aliases/model_components/rheology_fiber_additive.json,sha256=dw0zC8UFjIjNsNdl9l6P1nWQ0lRBe3QmYZ8vXCEkbZE,100
+physioblocks/library/aliases/model_components/spherical_dynamics.json,sha256=Tcd1t6JSVO-ty-gfksTUl_oXX_l1GuwBFuvH-fujLus,95
+physioblocks/library/aliases/model_components/velocity_law_hht.json,sha256=HKbc5_2hGuOiQKUvLGto6tBQI_Z5AbbhXp8Itwmo2ag,93
+physioblocks/library/aliases/nets/circulation_alone_net.json,sha256=M3TiXIXgaXCsdwfyA5cm3fqspViiIl0Kyb6NKMiFsQ8,874
+physioblocks/library/aliases/nets/spherical_heart_net.json,sha256=UnOSQslMJuvbT6dXXPWj-HEvqe6U4fG1CK17_sKTxM8,3057
+physioblocks/library/aliases/simulations/circulation_alone_forward_simulation.jsonc,sha256=0l4dKEvmY6-3NLB70B4zVF_OJs-bzgxAsesgr3KZ7P0,1983
+physioblocks/library/aliases/simulations/default_forward_simulation.jsonc,sha256=TE_82KWUYAQdMX4MpDGY-Hi_djpwYAhSB5uzYtzYqcA,136
+physioblocks/library/aliases/simulations/default_time.jsonc,sha256=LM2_EU-GvOeGXJMvXXyJeWEOv-cfy25luhcaSMj5hkw,165
+physioblocks/library/aliases/simulations/newton_method_solver.json,sha256=p0jgVCpySTR0Npo5iFZrUUys3SRcy4j_EesQw9SvoyA,79
+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/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
+physioblocks/library/functions/piecewise.py,sha256=xpR22eP0Jkfuskc737uttenbpOOMXEfrOAyconAg_-4,8401
+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/dynamics.py,sha256=SZaOU2_EFMRlqvJvsW9NXLTviN8NBAhy_9z_0EErPb0,35282
+physioblocks/library/model_components/rheology.py,sha256=7x5RrB_0DXMWlm0mIrTxdLlsjXVa1WPuFYYifW4fKeg,4724
+physioblocks/library/model_components/velocity_law.py,sha256=UYr9MywlLkRw0LszK0u_AamwThjobDMV9jYbaSbdDkU,5047
+physioblocks/registers/__init__.py,sha256=trxT3MHDFX8cJ-IBX2cEIm8-uZBnfs2UkV8QDclq9so,1081
+physioblocks/registers/load_function_register.py,sha256=z2iXShQCJHwSUJFNv2hJ19CLVSX5zlc2caxFg9x4-WE,2626
+physioblocks/registers/save_function_register.py,sha256=mOK486hKsX3dqi5P_KBnH5DE0_xl3Uzvik9xE4N-SIM,2943
+physioblocks/registers/type_register.py,sha256=JUlrPfP-X_TjIOHewSTkzf7Ck3L0ivVoHOvHQkyRpBM,2577
+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=xMtUL07SSQYpskK_EnNi-qz2D1d4wlDAESWHPqMUHn8,16762
+physioblocks/simulation/saved_quantities.py,sha256=fKWr1wScqxHPhuCE7aDNs8lpm9oWfyLN8NZDus2knPM,4111
+physioblocks/simulation/setup.py,sha256=UmIklaHmfkxi_BIdYKOhorLoC9QT9D4oEXwC-Xfd6v0,18109
+physioblocks/simulation/solvers.py,sha256=IrLHrsLJhM97SYzeygz2-UkkNbpp2hsixCuUi0Nis98,7353
+physioblocks/simulation/state.py,sha256=jE6fTxzsnGKch1H6mErunpi7lwTb_9fvs2Hx77LIaMA,10310
+physioblocks/simulation/time_manager.py,sha256=AbP_Y8mcG7-6x-3rGY5CHFQwKMqksO4HvdCJ-mU03d4,9381
+physioblocks/utils/__init__.py,sha256=EMwPHVznBryA1uOEFfY_11L9Sd9bdCU_x_huNgIaZtQ,988
+physioblocks/utils/dynamic_import_utils.py,sha256=AvGFRYPQcI2JSVpScXCgnYJDgF2uh8QI7xBewoe_9Ks,4862
+physioblocks/utils/exceptions_utils.py,sha256=2w2q1XP-UDnxCXFu4XI2k1-jLUub24oYuwdUfd6tOkE,3421
+physioblocks/utils/gradient_test_utils.py,sha256=41FVSrjzOLWmxvaiZI258QbmnQOA7M2tBm-Vd2GsEuo,11208
+physioblocks/utils/math_utils.py,sha256=w5MDs4cP5WiTPHe8WofFuNZZ20WDNLT0XmFGlbisJJ0,2881
+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.0.dist-info/METADATA,sha256=FcgqHhXq-C2RQKkG6t8WzxJ3-MvEoOGNHs_r5VGC_b0,4558
+physioblocks-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+physioblocks-1.0.0.dist-info/licenses/licenses/GPL-3.0-only.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+physioblocks-1.0.0.dist-info/licenses/licenses/LGPL-3.0-only.txt,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+physioblocks-1.0.0.dist-info/RECORD,,

physioblocks-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any