mxlpy 0.21.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

mxlpy/simulator.py

@@ -10,9 +10,9 @@ Classes:
 
 from __future__ import annotations
 
-import warnings
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Literal, Self, cast, overload
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Self, cast
 
 import numpy as np
 import pandas as pd
@@ -20,287 +20,19 @@ from sympy import lambdify
 
 from mxlpy.integrators import DefaultIntegrator
 from mxlpy.symbolic import to_symbolic_model
+from mxlpy.types import Result
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
-
     from mxlpy.model import Model
     from mxlpy.types import Array, ArrayLike, IntegratorProtocol, IntegratorType
 
+_LOGGER = logging.getLogger(__name__)
+
 __all__ = [
-    "Result",
     "Simulator",
 ]
 
 
-def _normalise_split_results(
-    results: list[pd.DataFrame],
-    normalise: float | ArrayLike,
-) -> list[pd.DataFrame]:
-    """Normalize split results by a given factor or array.
-
-    Args:
-        results: List of DataFrames containing the results to normalize.
-        normalise: Normalization factor or array.
-
-    Returns:
-        list[pd.DataFrame]: List of normalized DataFrames.
-
-    """
-    if isinstance(normalise, int | float):
-        return [i / normalise for i in results]
-    if len(normalise) == len(results):
-        return [(i.T / j).T for i, j in zip(results, normalise, strict=True)]
-
-    results = []
-    start = 0
-    end = 0
-    for i in results:
-        end += len(i)
-        results.append(i / np.reshape(normalise[start:end], (len(i), 1)))  # type: ignore
-        start += end
-    return results
-
-
-@dataclass(kw_only=True, slots=True)
-class Result:
-    """Simulation results."""
-
-    model: Model
-    _raw_variables: list[pd.DataFrame]
-    _parameters: list[dict[str, float]]
-    _dependent: list[pd.DataFrame] = field(default_factory=list)
-
-    @property
-    def variables(self) -> pd.DataFrame:
-        """Simulation variables."""
-        return self.get_variables(
-            include_derived=True,
-            include_readouts=True,
-            concatenated=True,
-            normalise=None,
-        )
-
-    @property
-    def fluxes(self) -> pd.DataFrame:
-        """Simulation fluxes."""
-        return self.get_fluxes()
-
-    def __iter__(self) -> Iterator[pd.DataFrame]:
-        """Iterate over the concentration and flux response coefficients."""
-        return iter((self.variables, self.fluxes))
-
-    def _get_dependent(
-        self,
-        *,
-        include_readouts: bool = True,
-    ) -> list[pd.DataFrame]:
-        # Already computed
-        if len(self._dependent) > 0:
-            return self._dependent
-
-        # Compute new otherwise
-        for res, p in zip(self._raw_variables, self._parameters, strict=True):
-            self.model.update_parameters(p)
-            self._dependent.append(
-                self.model.get_dependent_time_course(
-                    variables=res,
-                    include_readouts=include_readouts,
-                )
-            )
-        return self._dependent
-
-    def _select_variables(
-        self,
-        dependent: list[pd.DataFrame],
-        *,
-        include_derived: bool,
-        include_readouts: bool,
-    ) -> list[pd.DataFrame]:
-        names = self.model.get_variable_names()
-        if include_derived:
-            names.extend(self.model.get_derived_variable_names())
-        if include_readouts:
-            names.extend(self.model.get_readout_names())
-        return [i.loc[:, names] for i in dependent]
-
-    def _select_fluxes(
-        self,
-        dependent: list[pd.DataFrame],
-        *,
-        include_surrogates: bool,
-    ) -> list[pd.DataFrame]:
-        names = self.model.get_reaction_names()
-        if include_surrogates:
-            names.extend(self.model.get_surrogate_reaction_names())
-        return [i.loc[:, names] for i in dependent]
-
-    def _adjust_data(
-        self,
-        data: list[pd.DataFrame],
-        normalise: float | ArrayLike | None = None,
-        *,
-        concatenated: bool = True,
-    ) -> pd.DataFrame | list[pd.DataFrame]:
-        if normalise is not None:
-            data = _normalise_split_results(data, normalise=normalise)
-        if concatenated:
-            return pd.concat(data, axis=0)
-        return data
-
-    @overload
-    def get_variables(  # type: ignore
-        self,
-        *,
-        include_derived: bool = True,
-        include_readouts: bool = True,
-        concatenated: Literal[False],
-        normalise: float | ArrayLike | None = None,
-    ) -> list[pd.DataFrame]: ...
-
-    @overload
-    def get_variables(
-        self,
-        *,
-        include_derived: bool = True,
-        include_readouts: bool = True,
-        concatenated: Literal[True],
-        normalise: float | ArrayLike | None = None,
-    ) -> pd.DataFrame: ...
-
-    @overload
-    def get_variables(
-        self,
-        *,
-        include_derived: bool = True,
-        include_readouts: bool = True,
-        concatenated: bool = True,
-        normalise: float | ArrayLike | None = None,
-    ) -> pd.DataFrame: ...
-
-    def get_variables(
-        self,
-        *,
-        include_derived: bool = True,
-        include_readouts: bool = True,
-        concatenated: bool = True,
-        normalise: float | ArrayLike | None = None,
-    ) -> pd.DataFrame | list[pd.DataFrame]:
-        """Get the variables over time.
-
-        Examples:
-            >>> Result().get_variables()
-            Time            ATP      NADPH
-            0.000000   1.000000   1.000000
-            0.000100   0.999900   0.999900
-            0.000200   0.999800   0.999800
-
-        """
-        if not include_derived and not include_readouts:
-            return self._adjust_data(
-                self._raw_variables,
-                normalise=normalise,
-                concatenated=concatenated,
-            )
-
-        variables = self._select_variables(
-            self._get_dependent(),
-            include_derived=include_derived,
-            include_readouts=include_readouts,
-        )
-        return self._adjust_data(
-            variables, normalise=normalise, concatenated=concatenated
-        )
-
-    @overload
-    def get_fluxes(  # type: ignore
-        self,
-        *,
-        include_surrogates: bool = True,
-        normalise: float | ArrayLike | None = None,
-        concatenated: Literal[False],
-    ) -> list[pd.DataFrame]: ...
-
-    @overload
-    def get_fluxes(
-        self,
-        *,
-        include_surrogates: bool = True,
-        normalise: float | ArrayLike | None = None,
-        concatenated: Literal[True],
-    ) -> pd.DataFrame: ...
-
-    @overload
-    def get_fluxes(
-        self,
-        *,
-        include_surrogates: bool = True,
-        normalise: float | ArrayLike | None = None,
-        concatenated: bool = True,
-    ) -> pd.DataFrame: ...
-
-    def get_fluxes(
-        self,
-        *,
-        include_surrogates: bool = True,
-        normalise: float | ArrayLike | None = None,
-        concatenated: bool = True,
-    ) -> pd.DataFrame | list[pd.DataFrame]:
-        """Get the flux results.
-
-        Examples:
-            >>> Result.get_fluxes()
-            Time             v1         v2
-            0.000000   1.000000   10.00000
-            0.000100   0.999900   9.999000
-            0.000200   0.999800   9.998000
-
-        Returns:
-            pd.DataFrame: DataFrame of fluxes.
-
-        """
-        fluxes = self._select_fluxes(
-            self._get_dependent(),
-            include_surrogates=include_surrogates,
-        )
-        return self._adjust_data(
-            fluxes,
-            normalise=normalise,
-            concatenated=concatenated,
-        )
-
-    def get_combined(self) -> pd.DataFrame:
-        """Get the variables and fluxes as a single pandas.DataFrame.
-
-        Examples:
-            >>> Result.get_combined()
-            Time            ATP      NADPH         v1         v2
-            0.000000   1.000000   1.000000   1.000000   10.00000
-            0.000100   0.999900   0.999900   0.999900   9.999000
-            0.000200   0.999800   0.999800   0.999800   9.998000
-
-        Returns:
-            pd.DataFrame: DataFrame of fluxes.
-
-        """
-        return pd.concat((self.variables, self.fluxes), axis=1)
-
-    def get_new_y0(self) -> dict[str, float]:
-        """Get the new initial conditions after the simulation.
-
-        Examples:
-            >>> Simulator(model).simulate_to_steady_state().get_new_y0()
-            {"ATP": 1.0, "NADPH": 1.0}
-
-        """
-        return dict(
-            self.get_variables(
-                include_derived=False,
-                include_readouts=False,
-            ).iloc[-1]
-        )
-
-
 @dataclass(
     init=False,
     slots=True,
@@ -386,12 +118,12 @@ class Simulator:
                 )
 
             except Exception as e:  # noqa: BLE001
-                warnings.warn(str(e), stacklevel=2)
+                _LOGGER.warning(str(e), stacklevel=2)
 
         y0 = self.y0
         self.integrator = self._integrator_type(
             self.model,
-            [y0[k] for k in self.model.get_variable_names()],
+            tuple(y0[k] for k in self.model.get_variable_names()),
             jac_fn,
         )
 
@@ -431,7 +163,7 @@ class Simulator:
         # model._get_rhs sorts the return array by model.get_variable_names()
         # Do NOT change this ordering
         results_df = pd.DataFrame(
-            results,
+            data=results,
             index=time,
             columns=self.model.get_variable_names(),
         )
@@ -445,7 +177,7 @@ class Simulator:
 
         if self.simulation_parameters is None:
             self.simulation_parameters = []
-        self.simulation_parameters.append(self.model.parameters)
+        self.simulation_parameters.append(self.model.get_parameter_values())
 
     def simulate(
         self,
@@ -472,6 +204,13 @@ class Simulator:
         if self._time_shift is not None:
             t_end -= self._time_shift
 
+        prior_t_end: float = (
+            0.0 if (variables := self.variables) is None else variables[-1].index[-1]
+        )
+        if t_end <= prior_t_end:
+            msg = "End time point has to be larger than previous end time point"
+            raise ValueError(msg)
+
         time, results = self.integrator.integrate(t_end=t_end, steps=steps)
 
         self._handle_simulation_results(time, results, skipfirst=True)
@@ -495,17 +234,33 @@ class Simulator:
             Self: The Simulator instance with updated results.
 
         """
+        time_points = np.array(time_points, dtype=float)
+
         if self._time_shift is not None:
-            time_points = np.array(time_points, dtype=float)
             time_points -= self._time_shift
 
+        # Check if end is actually larger
+        prior_t_end: float = (
+            0.0 if (variables := self.variables) is None else variables[-1].index[-1]
+        )
+        if time_points[-1] <= prior_t_end:
+            msg = "End time point has to be larger than previous end time point"
+            raise ValueError(msg)
+
+        # Remove points which are smaller than previous t_end
+        if not (larger := time_points >= prior_t_end).all():
+            msg = f"Overlapping time points. Removing: {time_points[~larger]}"
+            _LOGGER.warning(msg)
+            time_points = time_points[larger]
+
         time, results = self.integrator.integrate_time_course(time_points=time_points)
         self._handle_simulation_results(time, results, skipfirst=True)
         return self
 
-    def simulate_over_protocol(
+    def simulate_protocol(
         self,
         protocol: pd.DataFrame,
+        *,
         time_points_per_step: int = 10,
     ) -> Self:
         """Simulate the model over a given protocol.
@@ -524,10 +279,81 @@ class Simulator:
             The Simulator instance with updated results.
 
         """
+        t_start = (
+            0.0 if (variables := self.variables) is None else variables[-1].index[-1]
+        )
+
         for t_end, pars in protocol.iterrows():
             t_end = cast(pd.Timedelta, t_end)
             self.model.update_parameters(pars.to_dict())
-            self.simulate(t_end.total_seconds(), steps=time_points_per_step)
+            self.simulate(t_start + t_end.total_seconds(), steps=time_points_per_step)
+            if self.variables is None:
+                break
+        return self
+
+    def simulate_protocol_time_course(
+        self,
+        protocol: pd.DataFrame,
+        time_points: ArrayLike,
+        *,
+        time_points_as_relative: bool = False,
+    ) -> Self:
+        """Simulate the model over a given protocol.
+
+        Examples:
+            >>> Simulator(model).simulate_over_protocol(
+            ...     protocol,
+            ...     time_points=np.array([1.0, 2.0, 3.0], dtype=float),
+            ... )
+
+        Args:
+            protocol: DataFrame containing the protocol.
+            time_points: Array of time points for which to return the simulation values.
+            time_points_as_relative: Interpret time points as relative time
+
+        Notes:
+            This function will return **both** the control points of the protocol as well
+            as the time points supplied in case they don't match.
+
+        Returns:
+            The Simulator instance with updated results.
+
+        """
+        t_start = (
+            0.0 if (variables := self.variables) is None else variables[-1].index[-1]
+        )
+
+        protocol = protocol.copy()
+        protocol.index = (
+            cast(pd.TimedeltaIndex, protocol.index) + pd.Timedelta(t_start, unit="s")
+        ).total_seconds()
+
+        time_points = np.array(time_points, dtype=float)
+        if time_points_as_relative:
+            time_points += t_start
+
+        # Error handling
+        if time_points[-1] <= t_start:
+            msg = "End time point has to be larger than previous end time point"
+            raise ValueError(msg)
+
+        larger = time_points > protocol.index[-1]
+        if any(larger):
+            msg = f"Ignoring time points outside of protocol range:\n {time_points[larger]}"
+            _LOGGER.warning(msg)
+
+        # Continue with logic
+        full_time_points = protocol.index.join(time_points, how="outer")
+
+        for t_end, pars in protocol.iterrows():
+            self.model.update_parameters(pars.to_dict())
+
+            self.simulate_time_course(
+                time_points=full_time_points[
+                    (full_time_points > t_start) & (full_time_points <= t_end)
+                ]
+            )
+            t_start = t_end
             if self.variables is None:
                 break
         return self
@@ -590,8 +416,8 @@ class Simulator:
             return None
         return Result(
             model=self.model,
-            _raw_variables=variables,
-            _parameters=parameters,
+            raw_variables=variables,
+            raw_parameters=parameters,
         )
 
     def update_parameter(self, parameter: str, value: float) -> Self:

mxlpy/symbolic/symbolic_model.py

@@ -4,15 +4,13 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 import sympy
 
-from mxlpy.meta.source_tools import fn_to_sympy
+from mxlpy.meta.sympy_tools import fn_to_sympy, list_of_symbols
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable
-
     from mxlpy.model import Model
 
 __all__ = [
@@ -36,30 +34,44 @@ class SymbolicModel:
         )
 
 
-def _list_of_symbols(args: Iterable[str]) -> list[sympy.Symbol]:
-    return [sympy.Symbol(arg) for arg in args]
-
-
 def to_symbolic_model(model: Model) -> SymbolicModel:
     cache = model._create_cache()  # noqa: SLF001
+    initial_conditions = model.get_initial_conditions()
 
     variables: dict[str, sympy.Symbol] = dict(
-        zip(model.variables, _list_of_symbols(model.variables), strict=True)
+        zip(
+            initial_conditions,
+            cast(list[sympy.Symbol], list_of_symbols(initial_conditions)),
+            strict=True,
+        )
     )
     parameters: dict[str, sympy.Symbol] = dict(
-        zip(model.parameters, _list_of_symbols(model.parameters), strict=True)
+        zip(
+            model.get_parameter_values(),
+            cast(list[sympy.Symbol], list_of_symbols(model.get_parameter_values())),
+            strict=True,
+        )
     )
     symbols: dict[str, sympy.Symbol | sympy.Expr] = variables | parameters  # type: ignore
 
     # Insert derived into symbols
-    for k, v in model.derived.items():
-        symbols[k] = fn_to_sympy(v.fn, [symbols[i] for i in v.args])
+    for k, v in model.get_raw_derived().items():
+        if (
+            expr := fn_to_sympy(v.fn, origin=k, model_args=[symbols[i] for i in v.args])
+        ) is None:
+            msg = f"Unable to parse derived value '{k}'"
+            raise ValueError(msg)
+        symbols[k] = expr
 
     # Insert derived into reaction via args
-    rxns = {
-        k: fn_to_sympy(v.fn, [symbols[i] for i in v.args])
-        for k, v in model.reactions.items()
-    }
+    rxns: dict[str, sympy.Expr] = {}
+    for k, v in model.get_raw_reactions().items():
+        if (
+            expr := fn_to_sympy(v.fn, origin=k, model_args=[symbols[i] for i in v.args])
+        ) is None:
+            msg = f"Unable to parse reaction '{k}'"
+            raise ValueError(msg)
+        rxns[k] = expr
 
     eqs: dict[str, sympy.Expr] = {}
     for cpd, stoich in cache.stoich_by_cpds.items():
@@ -80,5 +92,5 @@ def to_symbolic_model(model: Model) -> SymbolicModel:
         parameters=parameters,
         eqs=[eqs[i] for i in cache.var_names],
         initial_conditions=model.get_initial_conditions(),
-        parameter_values=model.parameters,
+        parameter_values=model.get_parameter_values(),
     )