physioblocks 1.0.1__tar.gz → 1.0.3__tar.gz

{physioblocks-1.0.1 → physioblocks-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physioblocks
-Version: 1.0.1
+Version: 1.0.3
 Dynamic: Author
 Dynamic: Author-email
 Dynamic: License
@@ -124,4 +124,7 @@ python -m physioblocks.launcher references/spherical_heart_sim.jsonc -v -t -s Qu
 ```
 
 
-Results will be available in the `$LAUNCHER_FOLDER_PATH$/simulations/QuickStart` series folder.
+Results will be available in the `$LAUNCHER_FOLDER_PATH$/simulations/QuickStart` series folder:
+* the csv file contains the simulation results.
+* the html allows you to visualize the results.
+* the log and json files are here for debug purposes.

{physioblocks-1.0.1 → physioblocks-1.0.3}/README.md

@@ -76,4 +76,7 @@ python -m physioblocks.launcher references/spherical_heart_sim.jsonc -v -t -s Qu
 ```
 
 
-Results will be available in the `$LAUNCHER_FOLDER_PATH$/simulations/QuickStart` series folder.
+Results will be available in the `$LAUNCHER_FOLDER_PATH$/simulations/QuickStart` series folder:
+* the csv file contains the simulation results.
+* the html allows you to visualize the results.
+* the log and json files are here for debug purposes.

{physioblocks-1.0.1 → physioblocks-1.0.3}/doc/source/library/aliases/simulation.rst

@@ -94,7 +94,7 @@ Parameters
         * ``proximal``: blood flow boundary condition
         * ``venous``: blood pressure boundary condition
 
-    * Sets default parameters, magnitudes. Especially:
+    * Sets default parameters, variables and magnitudes. Especially:
 
         * ``aorta_proximal.blood_flow`` is a periodic function needing a min and max value.
         * ``heart_rate`` parameter is introduced to set the function periodicity.

{physioblocks-1.0.1 → physioblocks-1.0.3}/doc/source/library/configuration/simulation.rst

@@ -133,6 +133,13 @@ Solvers Configuration
 
 Description of available configuration item to build :class:`~physioblocks.simulation.solvers.AbstractSolver` object from a configuration file.
 
+
+Linear Solver
+-------------
+
+* **Class:** :class:`~physioblocks.simulation.solvers.LinearSolver`
+* **Type name:** ``linear_solver``
+
 Newton Solver
 -------------
 

{physioblocks-1.0.1 → physioblocks-1.0.3}/doc/source/user_guide/level_2/create_simulation.rst

@@ -89,8 +89,7 @@ Solver
 
 This field define the solver implementation used to run a single simulation step.
 
-For now, only the :class:`~physioblocks.simulation.solvers.NewtonSolver` object is implemented in the current API.
-Its ``type`` is found in the :ref:`configuration section <library_configuration_simulation_solvers>` of the library
+The ``type`` parameters of available solver are found in the :ref:`configuration section <library_configuration_simulation_solvers>` of the library.
 
 .. code:: json
 
@@ -111,6 +110,7 @@ In this case, we set two parameters to the solver:
     Concerning our simple example the problem is **linear**, so a **Newton method is not adapted**.
     Still, we should be able to solve the system in two iterations, so ``iteration_max`` is set to 2.
 
+    A better choice would have been the ``linear_solver``, but we wanted to show the Newton solver in the example because it will be useful for most nets.
 
 Time
 ^^^^
@@ -135,7 +135,7 @@ It needs :
     }
 
 Here we set a 30 seconds simulation starting at 0.0.
-The simulation gives the state each 1ms and can divide a time step in parts of minimum lenght 62.5us before considering it can not solve the global system for the step.
+The simulation gives the state each 1ms and can divide a time step in parts of minimum length 62.5us before considering it can not solve the global system for the step.
 
 Net
 ^^^

{physioblocks-1.0.1 → physioblocks-1.0.3}/doc/source/user_guide/level_3/block_test.rst

@@ -144,10 +144,16 @@ Let's see an example for the RCR Block:
     state["pressure_2"] = ref_block.pressure_2
 
     # Provide the variables magnitudes
-    magnitudes = np.array([1e4, 1e4, 1e4])
+    state.set_variables_magnitudes(
+        {
+            "pressure_1": 1e4,
+            "pressure_mid": 1e4,
+            "pressure_2": 1e4,
+        }
+    )
 
     # call the test function
-    assert gradient_test_from_model(ref_rcr_block, state, magnitudes)
+    assert gradient_test_from_model(ref_rcr_block, state)
 
 
 Test a single expression
@@ -182,7 +188,13 @@ From our previous example, let's only test the flux at node 0:
     state["pressure_2"] = ref_block.pressure_2
 
     # Provide the variables magnitude
-    magnitudes = np.array([1e4, 1e4, 1e4])
+    state.set_variables_magnitudes(
+        {
+            "pressure_1": 1e4,
+            "pressure_mid": 1e4,
+            "pressure_2": 1e4,
+        }
+    )
 
     # call the test function
-    assert gradient_test_from_expression(RCRBlock.fluxes_expressions[0].expression, state, magnitudes)
+    assert gradient_test_from_expression(RCRBlock.fluxes_expressions[0].expression, state)

{physioblocks-1.0.1 → physioblocks-1.0.3}/physioblocks/__init__.py

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

{physioblocks-1.0.1 → physioblocks-1.0.3}/physioblocks/configuration/constants.py

@@ -38,11 +38,8 @@ PARAMETERS_ID = "parameters"
 # Definition of the flux-dof types couples
 FLUX_DOF_DEFINITION_ID = "flux_dof_definitions"
 
-
-# Magnitudes
-
-# The variable magnitude item label in the configuration
-MAGNITUDES = "magnitudes"
+# Options label for specific simulation types
+SIMULATION_OPTIONS = "simulation_options"
 
 # The variable magnitude item label in the configuration
 VARIABLES_MAGNITUDES = "variables_magnitudes"

{physioblocks-1.0.1 → physioblocks-1.0.3}/physioblocks/configuration/simulation/simulations.py

@@ -35,10 +35,10 @@ from typing import Any
 from physioblocks.configuration.base import Configuration, ConfigurationError
 from physioblocks.configuration.constants import (
     INIT_VARIABLES_ID,
-    MAGNITUDES,
     NET_ID,
     OUTPUTS_FUNCTIONS_ID,
     PARAMETERS_ID,
+    SIMULATION_OPTIONS,
     SOLVER_ID,
     TIME_MANAGER_ID,
     VARIABLES_MAGNITUDES,
@@ -86,16 +86,15 @@ def load_simulation_config(
         if SOLVER_ID in config:
             solver = load(config[SOLVER_ID])
 
-        # magnitudes
-        magnitudes = None
-        if VARIABLES_MAGNITUDES in config:
-            magnitudes = load(config[VARIABLES_MAGNITUDES])
+        simulation_options = None
+        if SIMULATION_OPTIONS in config:
+            simulation_options = load(config[SIMULATION_OPTIONS])
 
         sim_factory = SimulationFactory(
             configuration_type,
             solver,
             net,
-            simulation_options={MAGNITUDES: magnitudes},
+            simulation_options=simulation_options,
         )
 
         configuration_object = sim_factory.create_simulation()
@@ -147,7 +146,7 @@ def save_simulation_config(
                 type(variable_init_values).__name__,
             )
         )
-    sim_config[VARIABLES_MAGNITUDES] = save(simulation.magnitudes)
+    sim_config[VARIABLES_MAGNITUDES] = save(simulation.state.magnitudes)
 
     # Parameters
     # Get quantities
@@ -226,6 +225,11 @@ def _configure_simulation(
         configuration_references=simulation.quantities,
     )
 
+    # magnitudes
+    if VARIABLES_MAGNITUDES in config:
+        magnitudes = load(config[VARIABLES_MAGNITUDES])
+        simulation.state.set_variables_magnitudes(magnitudes)
+
     references.update(simulation.quantities)
     references.update(simulation.models)
 

{physioblocks-1.0.1 → physioblocks-1.0.3}/physioblocks/library/aliases/simulations/circulation_alone_forward_simulation.jsonc

@@ -49,7 +49,5 @@
             "inverses": ["aorta_distal.resistance"]
         }
     },
-    "solver": {
-        "iteration_max": 2 // This problem is linear
-    }
+    "solver": {"type": "linear_solver"}
 }

{physioblocks-1.0.1 → physioblocks-1.0.3}/physioblocks/library/model_components/dynamics.py

@@ -902,7 +902,9 @@ class SphericalDynamicsModelComponent(ModelComponent):
         eq_system = EqSystem(1)
 
         state = State()
-        state.add_variable(SPHERICAL_DYNAMICS_STATIC_DISP_LOCAL_ID, 1)
+        state.add_variable(
+            SPHERICAL_DYNAMICS_STATIC_DISP_LOCAL_ID, 1, _STATIC_PROBLEM_DISP_MAG
+        )
         state[SPHERICAL_DYNAMICS_STATIC_DISP_LOCAL_ID].initialize(self.disp.current)
 
         static_block = _SphericalDynamicsStaticModelComponent(
@@ -942,11 +944,7 @@ class SphericalDynamicsModelComponent(ModelComponent):
             p_test <= static_block.pressure.current
             and p_test > _STATIC_PROBLEM_MIN_PRESSURE_STEP
         ):
-            sol = solver.solve(
-                state,
-                eq_system,
-                {SPHERICAL_DYNAMICS_STATIC_DISP_LOCAL_ID: _STATIC_PROBLEM_DISP_MAG},
-            )
+            sol = solver.solve(state, eq_system)
 
             if sol.converged is True:
                 state[SPHERICAL_DYNAMICS_STATIC_DISP_LOCAL_ID].initialize(sol.x[0])

{physioblocks-1.0.1 → physioblocks-1.0.3}/physioblocks/simulation/runtime.py

@@ -96,9 +96,6 @@ class AbstractSimulation(ABC):
 
     :param eq_system: the equation system to solve at each time step
     :type eq_system: EqSystem
-
-    :param magnitudes: magnitude of the state variables
-    :type magnitudes: dict[str, float]
     """
 
     def __init__(
@@ -111,7 +108,6 @@ class AbstractSimulation(ABC):
         models: dict[str, ModelComponent],
         solver: AbstractSolver,
         eq_system: EqSystem,
-        magnitudes: dict[str, float] | None = None,
     ):
         self.factory = factory
         self.state = state
@@ -121,9 +117,6 @@ class AbstractSimulation(ABC):
         self.time_manager = time_manager
         self.solver = solver
         self.eq_system = eq_system
-        if magnitudes is None:
-            magnitudes = {}
-        self.magnitudes = self._check_magnitudes(magnitudes, state)
         self._timed_updates: dict[str, AbstractFunction] = {}
         self._output_functions_updates: dict[str, AbstractFunction] = {}
 
@@ -272,33 +265,6 @@ class AbstractSimulation(ABC):
         self.time_manager.time.initialize(self.time_manager.start)
         self.state.set_state_vector(self._initial_state)
 
-    def _check_magnitudes(
-        self, magnitudes: dict[str, float], state: State
-    ) -> dict[str, float]:
-        checked_magnitudes = {}
-
-        for variable_id in state:
-            if variable_id not in magnitudes:
-                message = str.format(
-                    "No magnitude initialized for variable {0}. Magnitude set to 1.0",
-                    variable_id,
-                )
-                _logger.warning(message)
-                checked_magnitudes[variable_id] = 1.0
-
-            elif magnitudes[variable_id] == 0.0:
-                message = str.format(
-                    "Magnitude for variable {0} is initialized to 0.0. "
-                    "Replacing with 1.0",
-                    variable_id,
-                )
-                _logger.warning(message)
-                checked_magnitudes[variable_id] = 1.0
-            else:
-                checked_magnitudes[variable_id] = magnitudes[variable_id]
-
-        return checked_magnitudes
-
     @abstractmethod
     def run(self) -> Results:
         """
@@ -406,7 +372,7 @@ class ForwardSimulation(AbstractSimulation):
                 ):
                     self.state.reset_state_vector()
 
-                    sol = self.solver.solve(self.state, self.eq_system, self.magnitudes)
+                    sol = self.solver.solve(self.state, self.eq_system)
 
                     if sol.converged is False:
                         inter_time = 0.5 * self.time_manager.current_step_size

{physioblocks-1.0.1 → physioblocks-1.0.3}/physioblocks/simulation/solvers.py

@@ -81,31 +81,8 @@ class AbstractSolver(ABC):
         self.tolerance = tolerance
         self.iteration_max = iteration_max
 
-    def _get_state_magnitude(
-        self, state: State, magnitudes: dict[str, float] | None = None
-    ) -> NDArray[np.float64]:
-        if magnitudes is None:
-            return np.ones(
-                state.size,
-            )
-
-        mag_dict = {}
-        for var_mag_key, var_mag_value in magnitudes.items():
-            var_index = state.get_variable_index(var_mag_key)
-            mag_dict[var_index] = var_mag_value
-        sorted_mag = sorted(mag_dict.items())
-        state_mag_list = [x[1] for x in sorted_mag]
-        return np.array(
-            state_mag_list,
-        )
-
     @abstractmethod
-    def solve(
-        self,
-        state: State,
-        system: EqSystem,
-        magnitudes: dict[str, float] | None = None,
-    ) -> Solution:
+    def solve(self, state: State, system: EqSystem) -> Solution:
         """
         Child classes have to override this method
 
@@ -114,6 +91,31 @@ class AbstractSolver(ABC):
         """
 
 
+LINEAR_SOLVER = "linear_solver"
+
+
+@register_type(LINEAR_SOLVER)
+class LinearSolver(AbstractSolver):
+    """
+    Implementation of the :class:`~.AbstractSolver` class for linear problems.
+    """
+
+    def solve(self, state: State, system: EqSystem) -> Solution:
+        """
+        Solve the equation system directly
+
+        :return: the solution
+        :rtype: Solution
+        """
+        res = system.compute_residual()
+        grad = system.compute_gradient()
+
+        xn = np.linalg.solve(grad, res)
+        x = state.state_vector - xn
+
+        return Solution(x, True)
+
+
 # Type id for the Newton Solver
 NEWTON_SOLVER_TYPE_ID = "newton_solver"
 
@@ -166,12 +168,7 @@ class NewtonSolver(AbstractSolver):
         grad_rescaled = gradient * grad_mag_inv
         return res_rescaled, grad_rescaled
 
-    def solve(
-        self,
-        state: State,
-        system: EqSystem,
-        magnitudes: dict[str, float] | None = None,
-    ) -> Solution:
+    def solve(self, state: State, system: EqSystem) -> Solution:
         """
         Solve the equation system using the Newton method.
 
@@ -183,15 +180,16 @@ class NewtonSolver(AbstractSolver):
             try:
                 i = 0
                 # initialize residual and magnitude
-                state_mag = self._get_state_magnitude(state, magnitudes)
                 res = np.ones(state.state_vector.shape)
 
                 # step 0 outside ou the loop to compute the residual and gradient
                 # magnitude
                 res, grad = self._compute_residual_and_gradient(system)
-                res_mag_inv, grad_mag_inv = self._compute_res_grad_mag(grad, state_mag)
+                res_mag_inv, grad_mag_inv = self._compute_res_grad_mag(
+                    grad, state.state_magnitudes
+                )
                 res, grad = self._rescale_res_grad(res, res_mag_inv, grad, grad_mag_inv)
-                x = self._compute_new_state(state, res, grad, state_mag)
+                x = self._compute_new_state(state, res, grad, state.state_magnitudes)
                 state.update_state_vector(x)
 
                 # Begin loop at iteration 1 (0 already done)
@@ -204,7 +202,9 @@ class NewtonSolver(AbstractSolver):
                     res, grad = self._rescale_res_grad(
                         res, res_mag_inv, grad, grad_mag_inv
                     )
-                    x = self._compute_new_state(state, res, grad, state_mag)
+                    x = self._compute_new_state(
+                        state, res, grad, state.state_magnitudes
+                    )
                     state.update_state_vector(x)
                     i += 1
 

{physioblocks-1.0.1 → physioblocks-1.0.3}/physioblocks/simulation/state.py

@@ -28,7 +28,7 @@
 Define the **State** that holds simulation variables.
 """
 
-from collections.abc import Callable, Generator, Mapping
+from collections.abc import Callable, Generator, Mapping, Sized
 from pprint import pformat
 from typing import Any
 
@@ -53,8 +53,12 @@ class State:
     _variables: dict[str, Quantity[Any]]
     """The variables ids and quantities values"""
 
+    _magnitudes: dict[str, Any]
+    """The variables magnitudes"""
+
     def __init__(self) -> None:
         self._variables = {}
+        self._magnitudes = {}
 
     @property
     def size(self) -> int:
@@ -76,6 +80,16 @@ class State:
         """
         return self._variables.copy()
 
+    @property
+    def magnitudes(self) -> dict[str, Any]:
+        """
+        Get a mapping of variables names and magnitudes.
+
+        :return: the variables names and magnitudes.
+        :rtype: dict[str, Quantity]
+        """
+        return self._magnitudes.copy()
+
     @property
     def state_vector(self) -> NDArray[np.float64]:
         """
@@ -91,8 +105,23 @@ class State:
         else:
             return np.array([])
 
-    def __array__(self) -> NDArray[Any]:
-        return self.state_vector
+    @property
+    def state_magnitudes(self) -> NDArray[np.float64]:
+        """
+        Get the state variables magnitudes.
+
+        :return: the state variables magnitudes
+        :rtype: NDArray[np.float64]
+        """
+        if len(self._variables) > 0:
+            return np.concatenate(
+                [self._magnitudes[var_id] for var_id in self._variables], axis=None
+            )
+        else:
+            return np.array([])
+
+    def __array__(self, *args: Any, **kwargs: Any) -> NDArray[Any]:
+        return np.array(self.state_vector, *args, **kwargs)
 
     def __getitem__(self, var_id: str) -> Quantity[Any]:
         """
@@ -311,7 +340,7 @@ class State:
                 quantity_part = x[var_index : var_index + quantity.size]
                 func(quantity, quantity_part)
 
-    def add_variable(self, var_id: str, var_value: Any) -> None:
+    def add_variable(self, var_id: str, var_value: Any, magnitude: Any = None) -> None:
         """
         Add a variable to the state.
 
@@ -328,6 +357,21 @@ class State:
         quantity = var_value if isinstance(var_value, Quantity) else Quantity(var_value)
         self._variables[var_id] = quantity
 
+        if magnitude is not None:
+            if quantity.size == 1 and isinstance(magnitude, float):
+                self._magnitudes[var_id] = magnitude
+            elif isinstance(magnitude, float):
+                self._magnitudes[var_id] = [magnitude] * quantity.size
+            elif isinstance(magnitude, Sized) and len(magnitude) == quantity.size:
+                self._magnitudes[var_id] = magnitude
+            else:
+                raise ValueError("Variable and magnitude sizes mismatch")
+        else:
+            if quantity.size == 1:
+                self._magnitudes[var_id] = 1.0
+            else:
+                self._magnitudes[var_id] = [1.0] * quantity.size
+
     def remove_variable(self, var_id: str) -> None:
         """
         Remove a variable from the state
@@ -338,3 +382,22 @@ class State:
         # remove the variable
         if var_id in self._variables:
             self._variables.pop(var_id)
+
+        if var_id in self._magnitudes:
+            self._magnitudes.pop(var_id)
+
+    def set_variables_magnitudes(self, magnitudes: dict[str, Any]) -> None:
+        """
+        Update all the state variables magnitudes.
+
+        :param magnitudes: the state variables magnitudes
+        :type magnitudes: dict[str, Any]
+
+        :raise KeyError: Raise a KeyError if one or more of the magnitude parameters key
+          is not in the state.
+        """
+
+        if set(magnitudes.keys()).issubset(self._variables.keys()) is False:
+            difference = set(magnitudes.keys()).difference(self._variables.keys())
+            raise KeyError(str.format("State has no variables named {0}.", difference))
+        self._magnitudes.update(magnitudes)

{physioblocks-1.0.1 → physioblocks-1.0.3}/physioblocks/utils/gradient_test_utils.py

@@ -77,22 +77,16 @@ def gradient_test_from_file(config_file_path: str) -> bool:
     :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.
+    :return: True if the gradient test is successful, 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
-    )
+    return gradient_test(sim.eq_system, sim.state)
 
 
-def gradient_test_from_model(
-    model: ModelComponent, state: State, state_magnitude: NDArray[np.float64]
-) -> bool:
+def gradient_test_from_model(model: ModelComponent, state: State) -> bool:
     """
     Create an equation system for the given block only and perform a gradient test.
 
@@ -106,10 +100,7 @@ def gradient_test_from_model(
     :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.
+    :return: True if the gradient test is successful, false otherwise.
     """
     line_index = 0
     expressions = setup.SystemExpressions()
@@ -124,14 +115,11 @@ def gradient_test_from_model(
 
     eq_system = setup.build_eq_system(expressions, state)
     model.initialize()
-    return gradient_test(eq_system, state, state_magnitude)
+    return gradient_test(eq_system, state)
 
 
 def gradient_test_from_expression(
-    expr: Expression,
-    expr_params: Any,
-    state: State,
-    state_magnitude: NDArray[np.float64],
+    expr: Expression, expr_params: Any, state: State
 ) -> bool:
     """
     Create an equation system for the given expression only and perform a gradient test.
@@ -145,20 +133,15 @@ def gradient_test_from_expression(
     :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.
+    :return: True if the gradient test is successful, false otherwise.
     :rtype: bool
     """
 
     eq_system = setup.build_eq_system([(0, expr, expr_params)], state)
-    return gradient_test(eq_system, state, state_magnitude)
+    return gradient_test(eq_system, state)
 
 
-def gradient_test(
-    eq_system: EqSystem, state: State, state_magnitude: NDArray[np.float64]
-) -> bool:
+def gradient_test(eq_system: EqSystem, state: State) -> bool:
     """
     Test the computed gradient for the equation system by comparing it to
     a gradient estimated with finite differences.
@@ -170,9 +153,6 @@ def gradient_test(
     :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.
     """
@@ -180,9 +160,9 @@ def gradient_test(
     _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
+    new_state = state.state_vector + _NEW_STATE_SHIFT_FACTOR * state.state_magnitudes
 
-    shift_1 = _SHIFT_FACTOR * state_magnitude
+    shift_1 = _SHIFT_FACTOR * state.state_magnitudes
     state.update_state_vector(new_state)
 
     res = eq_system.compute_residual()

{physioblocks-1.0.1 → physioblocks-1.0.3}/tests/tests_config/tests_simulation/test_config_simulation.py

@@ -186,7 +186,9 @@ def simulation_reference(net_reference: Net, ref_flux_expressions, ref_nodes):
     ):
         factory = SimulationFactory(AbstractSimulation, AbstractSolver(), net_reference)
         sim = factory.create_simulation()
-        sim.magnitudes = {str.format("{0}.{1}", NODE_A_ID, DOF_TYPE_ID): 1.1}
+        sim.state.set_variables_magnitudes(
+            {str.format("{0}.{1}", NODE_A_ID, DOF_TYPE_ID): 1.1}
+        )
         sim.register_timed_parameter_update(INLET_FLUX_CONDITION_ID, AbstractFunction())
         sim.register_output_function(OUTPUT_ID, AbstractFunction())
         sim.parameters[VECTOR_ID] = 3 * [0.0]

{physioblocks-1.0.1 → physioblocks-1.0.3}/tests/tests_library/tests_blocks/test_capacitances.py

@@ -24,7 +24,6 @@
 # You should have received a copy of the GNU Lesser General Public License along with
 # PhysioBlocks. If not, see <https://www.gnu.org/licenses/>.
 
-import numpy as np
 import pytest
 
 from physioblocks.computing.quantities import Quantity
@@ -48,9 +47,8 @@ class TestCBlock:
         state = State()
         state["pressure"] = ref_c_block.pressure
         ref_c_block.time.update(0.001)
-        magnitudes = np.array([1e5])
 
-        assert gradient_test_from_model(ref_c_block, state, magnitudes)
+        assert gradient_test_from_model(ref_c_block, state)
 
 
 @pytest.fixture
@@ -71,9 +69,7 @@ class TestRCBlock:
         state["pressure_2"] = ref_rc_block.pressure_2
         ref_rc_block.time.update(0.001)
 
-        magnitudes = np.array([1e5, 1e5])
-
-        assert gradient_test_from_model(ref_rc_block, state, magnitudes)
+        assert gradient_test_from_model(ref_rc_block, state)
 
 
 @pytest.fixture
@@ -97,6 +93,4 @@ class TestRCRBlock:
         state["pressure_2"] = ref_rcr_block.pressure_2
         ref_rcr_block.time.update(0.001)
 
-        magnitudes = np.array([1e4, 1e4, 1e4])
-
-        assert gradient_test_from_model(ref_rcr_block, state, magnitudes)
+        assert gradient_test_from_model(ref_rcr_block, state)