mxlpy 0.8.0__py3-none-any.whl

mxlpy/integrators/__init__.py

@@ -0,0 +1,19 @@
+"""Integrator Package.
+
+This package provides integrators for solving ordinary differential equations (ODEs).
+It includes support for both Assimulo and Scipy integrators, with Assimulo being the default if available.
+"""
+
+from __future__ import annotations
+
+__all__ = ["DefaultIntegrator"]
+
+
+from .int_scipy import Scipy
+
+try:
+    from .int_assimulo import Assimulo
+
+    DefaultIntegrator = Assimulo
+except ImportError:
+    DefaultIntegrator = Scipy

mxlpy/integrators/int_assimulo.py

@@ -0,0 +1,146 @@
+"""Assimulo integrator for solving ODEs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+__all__ = [
+    "Assimulo",
+]
+
+import contextlib
+import os
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+
+with contextlib.redirect_stderr(open(os.devnull, "w")):  # noqa: PTH123
+    from assimulo.problem import Explicit_Problem  # type: ignore
+    from assimulo.solvers import CVode  # type: ignore
+    from assimulo.solvers.sundials import CVodeError  # type: ignore
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from mxlpy.types import Array, ArrayLike
+
+
+@dataclass
+class Assimulo:
+    """Assimulo integrator for solving ODEs.
+
+    Attributes:
+        rhs: Right-hand side function of the ODE.
+        y0: Initial conditions.
+        atol: Absolute tolerance for the solver.
+        rtol: Relative tolerance for the solver.
+        maxnef: Maximum number of error failures.
+        maxncf: Maximum number of convergence failures.
+        verbosity: Verbosity level of the solver.
+
+    Methods:
+        integrate: Integrate the ODE system.
+
+    """
+
+    rhs: Callable
+    y0: ArrayLike
+    atol: float = 1e-8
+    rtol: float = 1e-8
+    maxnef: int = 4  # max error failures
+    maxncf: int = 1  # max convergence failures
+    verbosity: Literal[50, 40, 30, 20, 10] = 50
+
+    def __post_init__(self) -> None:
+        """Post-initialization method for setting up the CVode integrator with the provided parameters.
+
+        This method initializes the CVode integrator with an explicit problem defined by the
+        right-hand side function (`self.rhs`) and the initial conditions (`self.y0`). It also
+        sets various integrator options such as absolute tolerance (`self.atol`), relative
+        tolerance (`self.rtol`), maximum number of error test failures (`self.maxnef`), maximum
+        number of convergence failures (`self.maxncf`), and verbosity level (`self.verbosity`).
+
+        """
+        self.integrator = CVode(Explicit_Problem(self.rhs, self.y0))
+        self.integrator.atol = self.atol
+        self.integrator.rtol = self.rtol
+        self.integrator.maxnef = self.maxnef
+        self.integrator.maxncf = self.maxncf
+        self.integrator.verbosity = self.verbosity
+
+    def reset(self) -> None:
+        """Reset the integrator."""
+        self.integrator.reset()
+
+    def integrate(
+        self,
+        *,
+        t_end: float,
+        steps: int | None = None,
+    ) -> tuple[Array | None, ArrayLike | None]:
+        """Integrate the ODE system.
+
+        Args:
+            t_end: Terminal time point for the integration.
+            steps: Number of steps for the integration.
+            time_points: Time points for the integration.
+
+        Returns:
+            np.ndarray: Array of integrated values.
+
+        """
+        if steps is None:
+            steps = 0
+        try:
+            return self.integrator.simulate(t_end, steps)  # type: ignore
+        except CVodeError:
+            return None, None
+
+    def integrate_time_course(
+        self,
+        *,
+        time_points: ArrayLike,
+    ) -> tuple[Array | None, ArrayLike | None]:
+        """Integrate the ODE system over a time course.
+
+        Args:
+            time_points: Time points for the integration.
+
+        Returns:
+            tuple[ArrayLike | None, ArrayLike | None]: Tuple containing the time points and the integrated values.
+
+        """
+        try:
+            return self.integrator.simulate(time_points[-1], 0, time_points)  # type: ignore
+        except CVodeError:
+            return None, None
+
+    def integrate_to_steady_state(
+        self,
+        *,
+        tolerance: float,
+        rel_norm: bool,
+        t_max: float = 1_000_000_000,
+    ) -> tuple[float | None, ArrayLike | None]:
+        """Integrate the ODE system to steady state.
+
+        Args:
+            tolerance: Tolerance for determining steady state.
+            rel_norm: Whether to use relative normalization.
+            t_max: Maximum time point for the integration (default: 1,000,000,000).
+
+        Returns:
+            tuple[float | None, ArrayLike | None]: Tuple containing the final time point and the integrated values at steady state.
+
+        """
+        self.reset()
+
+        try:
+            for t_end in np.geomspace(1000, t_max, 3):
+                t, y = self.integrator.simulate(t_end)
+                diff = (y[-1] - y[-2]) / y[-1] if rel_norm else y[-1] - y[-2]
+                if np.linalg.norm(diff, ord=2) < tolerance:
+                    return t[-1], y[-1]
+        except CVodeError:
+            return None, None
+        return None, None

mxlpy/integrators/int_scipy.py

@@ -0,0 +1,146 @@
+"""Scipy integrator for solving ODEs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+__all__ = [
+    "Scipy",
+]
+
+import copy
+from typing import TYPE_CHECKING, cast
+
+import numpy as np
+import scipy.integrate as spi
+
+from mxlpy.types import Array, ArrayLike
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+@dataclass
+class Scipy:
+    """Scipy integrator for solving ODEs.
+
+    Attributes:
+        rhs: Right-hand side function of the ODE.
+        y0: Initial conditions.
+        atol: Absolute tolerance for the solver.
+        rtol: Relative tolerance for the solver.
+        t0: Initial time point.
+        _y0_orig: Original initial conditions.
+
+    Methods:
+        __post_init__: Initialize the Scipy integrator.
+        reset: Reset the integrator.
+        integrate: Integrate the ODE system.
+        integrate_to_steady_state: Integrate the ODE system to steady state.
+
+    """
+
+    rhs: Callable
+    y0: ArrayLike
+    atol: float = 1e-8
+    rtol: float = 1e-8
+    t0: float = 0.0
+    _y0_orig: ArrayLike = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        """Create copy of initial state.
+
+        This method creates a copy of the initial state `y0` and stores it in the `_y0_orig` attribute.
+        This is useful for preserving the original initial state for future reference or reset operations.
+
+        """
+        self._y0_orig = self.y0.copy()
+
+    def reset(self) -> None:
+        """Reset the integrator."""
+        self.t0 = 0
+        self.y0 = self._y0_orig.copy()
+
+    def integrate(
+        self,
+        *,
+        t_end: float,
+        steps: int | None = None,
+    ) -> tuple[Array | None, ArrayLike | None]:
+        """Integrate the ODE system.
+
+        Args:
+            t_end: Terminal time point for the integration.
+            steps: Number of steps for the integration.
+            time_points: Array of time points for the integration.
+
+        Returns:
+            tuple[ArrayLike | None, ArrayLike | None]: Tuple containing the time points and the integrated values.
+
+        """
+        # Scipy counts the total amount of return points rather than steps as assimulo
+        steps = 100 if steps is None else steps + 1
+
+        return self.integrate_time_course(
+            time_points=np.linspace(self.t0, t_end, steps)
+        )
+
+    def integrate_time_course(
+        self, *, time_points: ArrayLike
+    ) -> tuple[Array | None, ArrayLike | None]:
+        """Integrate the ODE system over a time course.
+
+        Args:
+            time_points: Time points for the integration.
+
+        Returns:
+            tuple[ArrayLike, ArrayLike]: Tuple containing the time points and the integrated values.
+
+        """
+        y = spi.odeint(
+            func=self.rhs,
+            y0=self.y0,
+            t=time_points,
+            tfirst=True,
+            atol=self.atol,
+            rtol=self.rtol,
+        )
+        self.t0 = time_points[-1]
+        self.y0 = y[-1, :]
+        return np.array(time_points, dtype=float), y
+
+    def integrate_to_steady_state(
+        self,
+        *,
+        tolerance: float,
+        rel_norm: bool,
+        step_size: int = 100,
+        max_steps: int = 1000,
+    ) -> tuple[float | None, ArrayLike | None]:
+        """Integrate the ODE system to steady state.
+
+        Args:
+            tolerance: Tolerance for determining steady state.
+            rel_norm: Whether to use relative normalization.
+            step_size: Step size for the integration (default: 100).
+            max_steps: Maximum number of steps for the integration (default: 1,000).
+            integrator: Name of the integrator to use (default: "lsoda").
+
+        Returns:
+            tuple[float | None, ArrayLike | None]: Tuple containing the final time point and the integrated values at steady state.
+
+        """
+        self.reset()
+        integ = spi.ode(self.rhs)
+        integ.set_integrator(name="lsoda")
+        integ.set_initial_value(self.y0)
+        t = self.t0 + step_size
+        y1 = copy.deepcopy(self.y0)
+        for _ in range(max_steps):
+            y2 = integ.integrate(t)
+            diff = (y2 - y1) / y1 if rel_norm else y2 - y1
+            if np.linalg.norm(diff, ord=2) < tolerance:
+                return t, cast(ArrayLike, y2)
+            y1 = y2
+            t += step_size
+        return None, None