physioblocks 1.1.0__tar.gz → 1.1.2__tar.gz

{physioblocks-1.1.0 → physioblocks-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physioblocks
-Version: 1.1.0
+Version: 1.1.2
 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.1.0 → physioblocks-1.1.2}/physioblocks/__init__.py

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

{physioblocks-1.1.0 → physioblocks-1.1.2}/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-1.1.0 → physioblocks-1.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.1.0 → physioblocks-1.1.2}/pyproject.toml

@@ -10,7 +10,8 @@ dependencies = [
     "pandas",
     "plotly",
     "pyarrow",
-    "regex"
+    "regex",
+    "rich"
 ]
 description = "Physioblocks allows the simulation of dynamical models of physiological systems"
 keywords = [

physioblocks-1.1.2/references/full_configurations/circulation_alone_sim.jsonc

@@ -0,0 +1,146 @@
+{
+    "type": "forward_simulation",
+    "time": {
+        "type": "time",
+        "step_size": 0.001,
+        "min_step": 6.25e-05,
+        "start": 0.0,
+        "duration": 25.0
+    },
+    "solver": {
+        "type": "linear_solver"
+    },
+    "net": {
+        "type": "net",
+        "flux_dof_definitions": {
+            "blood_flow": "blood_pressure"
+        },
+        "nodes": [
+            "aorta_proximal",
+            "aorta_distal",
+            "venous"
+        ],
+        "blocks": {
+            "circulation_aorta_proximal": {
+                "type": "block_description",
+                "model_type": "rc_block",
+                "time": "time",
+                "flux_type": "blood_flow",
+                "resistance": "aorta_proximal.resistance",
+                "capacitance": "aorta_proximal.capacitance",
+                "nodes": {
+                    "1": "aorta_distal",
+                    "2": "aorta_proximal"
+                }
+            },
+            "circulation_aorta_distal": {
+                "type": "block_description",
+                "model_type": "rc_block",
+                "time": "time",
+                "flux_type": "blood_flow",
+                "resistance": "aorta_distal.resistance",
+                "capacitance": "aorta_distal.capacitance",
+                "nodes": {
+                    "1": "venous",
+                    "2": "aorta_distal"
+                }
+            }
+        },
+        "boundaries_conditions": {
+            "aorta_proximal": [
+                {
+                    "type": "condition",
+                    "condition_type": "blood_flow",
+                    "condition_id": "aorta_proximal.blood_flow"
+                }
+            ],
+            "venous": [
+                {
+                    "type": "condition",
+                    "condition_type": "blood_pressure",
+                    "condition_id": "venous.blood_pressure"
+                }
+            ]
+        }
+    },
+    "variables_magnitudes": {
+        "aorta_proximal.blood_pressure": 100000.0,
+        "aorta_distal.blood_pressure": 100000.0
+    },
+    "parameters": {
+        "heartbeat_duration": {
+            "type": "product",
+            "factors": [
+                60.0
+            ],
+            "inverses": [
+                "heart_rate"
+            ]
+        },
+        "aorta_proximal.capacitance": 2e-10,
+        "aorta_proximal.blood_flow": {
+            "type": "rescale_two_phases_function",
+            "rescaled_period": "heartbeat_duration",
+            "alpha": 0.8,
+            "reference_function": [
+                [
+                    0.0,
+                    "aorta_proximal.blood_flow.min"
+                ],
+                [
+                    0.075,
+                    "aorta_proximal.blood_flow.min"
+                ],
+                [
+                    0.134,
+                    "aorta_proximal.blood_flow.max"
+                ],
+                [
+                    0.142,
+                    "aorta_proximal.blood_flow.max"
+                ],
+                [
+                    0.281,
+                    "aorta_proximal.blood_flow.min"
+                ],
+                [
+                    0.9,
+                    "aorta_proximal.blood_flow.min"
+                ]
+            ],
+            "phases": [
+                0,
+                0,
+                1,
+                1,
+                0
+            ]
+        },
+        "aorta_distal.capacitance": {
+            "type": "product",
+            "factors": [
+                "aorta_distal.time_constant"
+            ],
+            "inverses": [
+                "aorta_distal.resistance"
+            ]
+        },
+        "heart_rate": 60.0,
+        "aorta_proximal.resistance": 7000000.0,
+        "aorta_distal.resistance": 110000000.0,
+        "aorta_distal.time_constant": 2.0,
+        "venous.blood_pressure": 1600.0,
+        "aorta_proximal.blood_flow.min": 0.0,
+        "aorta_proximal.blood_flow.max": 0.0005
+    },
+    "variables_initialization": {
+        "aorta_proximal.blood_pressure": 10760.0,
+        "aorta_distal.blood_pressure": 10760.0
+    },
+    "output_functions": {
+        "aorta_proximal.blood_flow": {
+            "type": "watch_quantity",
+            "quantity": "aorta_proximal.blood_flow"
+        }
+    }
+}