mxlpy 0.15.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

mxlpy/mc.py

@@ -31,7 +31,7 @@ from mxlpy.scan import (
     _protocol_worker,
     _steady_state_worker,
     _time_course_worker,
-    _update_parameters_and,
+    _update_parameters_and_initial_conditions,
 )
 from mxlpy.types import (
     IntegratorType,
@@ -74,7 +74,6 @@ class ParameterScanWorker(Protocol):
     def __call__(
         self,
         model: Model,
-        y0: dict[str, float] | None,
         *,
         parameters: pd.DataFrame,
         rel_norm: bool,
@@ -86,7 +85,6 @@ class ParameterScanWorker(Protocol):
 
 def _parameter_scan_worker(
     model: Model,
-    y0: dict[str, float] | None,
     *,
     parameters: pd.DataFrame,
     rel_norm: bool,
@@ -117,8 +115,7 @@ def _parameter_scan_worker(
     """
     return scan.steady_state(
         model,
-        parameters=parameters,
-        y0=y0,
+        to_scan=parameters,
         parallel=False,
         rel_norm=rel_norm,
         integrator=integrator,
@@ -127,8 +124,8 @@ def _parameter_scan_worker(
 
 def steady_state(
     model: Model,
-    mc_parameters: pd.DataFrame,
     *,
+    mc_to_scan: pd.DataFrame,
     y0: dict[str, float] | None = None,
     max_workers: int | None = None,
     cache: Cache | None = None,
@@ -139,7 +136,7 @@ def steady_state(
     """Monte-carlo scan of steady states.
 
     Examples:
-        >>> steady_state(model, mc_parameters)
+        >>> steady_state(model, mc_to_scan)
         p    t     x      y
         0    0.0   0.1    0.00
             1.0   0.2    0.01
@@ -155,32 +152,35 @@ def steady_state(
         SteadyStates: Object containing the steady state solutions for the given parameter
 
     """
+    if y0 is not None:
+        model.update_variables(y0)
+
     res = parallelise(
         partial(
-            _update_parameters_and,
+            _update_parameters_and_initial_conditions,
             fn=partial(
                 worker,
-                y0=y0,
                 rel_norm=rel_norm,
                 integrator=integrator,
             ),
             model=model,
         ),
-        inputs=list(mc_parameters.iterrows()),
+        inputs=list(mc_to_scan.iterrows()),
         max_workers=max_workers,
         cache=cache,
     )
     return SteadyStates(
         variables=pd.concat({k: v.variables for k, v in res.items()}, axis=1).T,
         fluxes=pd.concat({k: v.fluxes for k, v in res.items()}, axis=1).T,
-        parameters=mc_parameters,
+        parameters=mc_to_scan,
     )
 
 
 def time_course(
     model: Model,
+    *,
     time_points: Array,
-    mc_parameters: pd.DataFrame,
+    mc_to_scan: pd.DataFrame,
     y0: dict[str, float] | None = None,
     max_workers: int | None = None,
     cache: Cache | None = None,
@@ -190,7 +190,7 @@ def time_course(
     """MC time course.
 
     Examples:
-        >>> time_course(model, time_points, mc_parameters)
+        >>> time_course(model, time_points, mc_to_scan)
         p    t     x      y
         0   0.0   0.1    0.00
             1.0   0.2    0.01
@@ -203,27 +203,29 @@ def time_course(
             3.0   0.4    0.03
     Returns:
         tuple[concentrations, fluxes] using pandas multiindex
-        Both dataframes are of shape (#time_points * #mc_parameters, #variables)
+        Both dataframes are of shape (#time_points * #mc_to_scan, #variables)
 
     """
+    if y0 is not None:
+        model.update_variables(y0)
+
     res = parallelise(
         partial(
-            _update_parameters_and,
+            _update_parameters_and_initial_conditions,
             fn=partial(
                 worker,
                 time_points=time_points,
-                y0=y0,
                 integrator=integrator,
             ),
             model=model,
         ),
-        inputs=list(mc_parameters.iterrows()),
+        inputs=list(mc_to_scan.iterrows()),
         max_workers=max_workers,
         cache=cache,
     )
 
     return TimeCourseByPars(
-        parameters=mc_parameters,
+        parameters=mc_to_scan,
         variables=pd.concat({k: v.variables.T for k, v in res.items()}, axis=1).T,
         fluxes=pd.concat({k: v.fluxes.T for k, v in res.items()}, axis=1).T,
     )
@@ -231,8 +233,9 @@ def time_course(
 
 def time_course_over_protocol(
     model: Model,
+    *,
     protocol: pd.DataFrame,
-    mc_parameters: pd.DataFrame,
+    mc_to_scan: pd.DataFrame,
     y0: dict[str, float] | None = None,
     time_points_per_step: int = 10,
     max_workers: int | None = None,
@@ -243,7 +246,7 @@ def time_course_over_protocol(
     """MC time course.
 
     Examples:
-        >>> time_course_over_protocol(model, protocol, mc_parameters)
+        >>> time_course_over_protocol(model, protocol, mc_to_scan)
         p    t     x      y
         0   0.0   0.1    0.00
             1.0   0.2    0.01
@@ -257,22 +260,24 @@ def time_course_over_protocol(
 
     Returns:
         tuple[concentrations, fluxes] using pandas multiindex
-        Both dataframes are of shape (#time_points * #mc_parameters, #variables)
+        Both dataframes are of shape (#time_points * #mc_to_scan, #variables)
 
     """
+    if y0 is not None:
+        model.update_variables(y0)
+
     res = parallelise(
         partial(
-            _update_parameters_and,
+            _update_parameters_and_initial_conditions,
             fn=partial(
                 worker,
                 protocol=protocol,
-                y0=y0,
                 integrator=integrator,
                 time_points_per_step=time_points_per_step,
             ),
             model=model,
         ),
-        inputs=list(mc_parameters.iterrows()),
+        inputs=list(mc_to_scan.iterrows()),
         max_workers=max_workers,
         cache=cache,
     )
@@ -281,16 +286,16 @@ def time_course_over_protocol(
     return ProtocolByPars(
         variables=pd.concat(concs, axis=1).T,
         fluxes=pd.concat(fluxes, axis=1).T,
-        parameters=mc_parameters,
+        parameters=mc_to_scan,
         protocol=protocol,
     )
 
 
 def scan_steady_state(
     model: Model,
-    parameters: pd.DataFrame,
-    mc_parameters: pd.DataFrame,
     *,
+    to_scan: pd.DataFrame,
+    mc_to_scan: pd.DataFrame,
     y0: dict[str, float] | None = None,
     max_workers: int | None = None,
     cache: Cache | None = None,
@@ -304,7 +309,7 @@ def scan_steady_state(
         >>> scan_steady_state(
         ...     model,
         ...     parameters=pd.DataFrame({"k1": np.linspace(0, 1, 3)}),
-        ...     mc_parameters=mc_parameters,
+        ...     mc_to_scan=mc_to_scan,
         ... ).variables
                   x     y
           k1
@@ -319,8 +324,8 @@ def scan_steady_state(
 
     Args:
         model: The model to analyze
-        parameters: DataFrame containing parameter combinations to scan over
-        mc_parameters: DataFrame containing Monte Carlo parameter sets
+        to_scan: DataFrame containing parameter and initial values to scan over
+        mc_to_scan: DataFrame containing Monte Carlo parameter sets
         y0: Initial conditions for the solver
         max_workers: Maximum number of workers for parallel processing
         cache: Cache object for storing results
@@ -332,19 +337,21 @@ def scan_steady_state(
         McSteadyStates: Object containing the steady state solutions for the given parameter
 
     """
+    if y0 is not None:
+        model.update_variables(y0)
+
     res = parallelise(
         partial(
-            _update_parameters_and,
+            _update_parameters_and_initial_conditions,
             fn=partial(
                 worker,
-                parameters=parameters,
-                y0=y0,
+                parameters=to_scan,
                 rel_norm=rel_norm,
                 integrator=integrator,
             ),
             model=model,
         ),
-        inputs=list(mc_parameters.iterrows()),
+        inputs=list(mc_to_scan.iterrows()),
         cache=cache,
         max_workers=max_workers,
     )
@@ -353,17 +360,22 @@ def scan_steady_state(
     return McSteadyStates(
         variables=pd.concat(concs, axis=1).T,
         fluxes=pd.concat(fluxes, axis=1).T,
-        parameters=parameters,
-        mc_parameters=mc_parameters,
+        parameters=to_scan,
+        mc_to_scan=mc_to_scan,
     )
 
 
+###############################################################################
+# MCA
+###############################################################################
+
+
 def variable_elasticities(
     model: Model,
-    variables: list[str],
-    concs: dict[str, float],
-    mc_parameters: pd.DataFrame,
     *,
+    mc_to_scan: pd.DataFrame,
+    to_scan: list[str] | None = None,
+    variables: dict[str, float] | None = None,
     time: float = 0,
     cache: Cache | None = None,
     max_workers: int | None = None,
@@ -377,7 +389,7 @@ def variable_elasticities(
         ...     model,
         ...     variables=["x1", "x2"],
         ...     concs={"x1": 1, "x2": 2},
-        ...     mc_parameters=mc_parameters
+        ...     mc_to_scan=mc_to_scan
         ... )
                  x1     x2
         0   v1  0.0    0.0
@@ -389,9 +401,9 @@ def variable_elasticities(
 
     Args:
         model: The model to analyze
-        variables: List of variables for which to calculate elasticities
-        concs: Dictionary of concentrations for the model
-        mc_parameters: DataFrame containing Monte Carlo parameter sets
+        to_scan: List of variables for which to calculate elasticities
+        variables: Custom variable values. Defaults to initial conditions.
+        mc_to_scan: DataFrame containing Monte Carlo parameter sets
         time: Time point for the analysis
         cache: Cache object for storing results
         max_workers: Maximum number of workers for parallel processing
@@ -404,18 +416,18 @@ def variable_elasticities(
     """
     res = parallelise(
         partial(
-            _update_parameters_and,
+            _update_parameters_and_initial_conditions,
             fn=partial(
                 mca.variable_elasticities,
                 variables=variables,
-                concs=concs,
+                to_scan=to_scan,
                 time=time,
                 displacement=displacement,
                 normalized=normalized,
             ),
             model=model,
         ),
-        inputs=list(mc_parameters.iterrows()),
+        inputs=list(mc_to_scan.iterrows()),
         cache=cache,
         max_workers=max_workers,
     )
@@ -424,10 +436,10 @@ def variable_elasticities(
 
 def parameter_elasticities(
     model: Model,
-    parameters: list[str],
-    concs: dict[str, float],
-    mc_parameters: pd.DataFrame,
     *,
+    mc_to_scan: pd.DataFrame,
+    to_scan: list[str],
+    variables: dict[str, float],
     time: float = 0,
     cache: Cache | None = None,
     max_workers: int | None = None,
@@ -439,9 +451,9 @@ def parameter_elasticities(
     Examples:
         >>> parameter_elasticities(
         ...     model,
-        ...     variables=["p1", "p2"],
+        ...     parameters=["p1", "p2"],
         ...     concs={"x1": 1, "x2": 2},
-        ...     mc_parameters=mc_parameters
+        ...     mc_to_scan=mc_to_scan
         ... )
                  p1     p2
         0   v1  0.0    0.0
@@ -453,9 +465,9 @@ def parameter_elasticities(
 
     Args:
         model: The model to analyze
-        parameters: List of parameters for which to calculate elasticities
-        concs: Dictionary of concentrations for the model
-        mc_parameters: DataFrame containing Monte Carlo parameter sets
+        to_scan: List of parameters for which to calculate elasticities
+        variables: Custom variable values. Defaults to initial conditions.
+        mc_to_scan: DataFrame containing Monte Carlo parameter sets
         time: Time point for the analysis
         cache: Cache object for storing results
         max_workers: Maximum number of workers for parallel processing
@@ -468,18 +480,18 @@ def parameter_elasticities(
     """
     res = parallelise(
         partial(
-            _update_parameters_and,
+            _update_parameters_and_initial_conditions,
             fn=partial(
                 mca.parameter_elasticities,
-                parameters=parameters,
-                concs=concs,
+                to_scan=to_scan,
+                variables=variables,
                 time=time,
                 displacement=displacement,
                 normalized=normalized,
             ),
             model=model,
         ),
-        inputs=list(mc_parameters.iterrows()),
+        inputs=list(mc_to_scan.iterrows()),
         cache=cache,
         max_workers=max_workers,
     )
@@ -488,10 +500,10 @@ def parameter_elasticities(
 
 def response_coefficients(
     model: Model,
-    parameters: list[str],
-    mc_parameters: pd.DataFrame,
     *,
-    y0: dict[str, float] | None = None,
+    mc_to_scan: pd.DataFrame,
+    to_scan: list[str],
+    variables: dict[str, float] | None = None,
     cache: Cache | None = None,
     normalized: bool = True,
     displacement: float = 1e-4,
@@ -506,7 +518,7 @@ def response_coefficients(
         >>> response_coefficients(
         ...     model,
         ...     parameters=["vmax1", "vmax2"],
-        ...     mc_parameters=mc_parameters,
+        ...     mc_to_scan=mc_to_scan,
         ... ).variables
                     x1    x2
         0 vmax_1  0.01  0.01
@@ -516,9 +528,9 @@ def response_coefficients(
 
     Args:
         model: The model to analyze
-        parameters: List of parameters for which to calculate elasticities
-        mc_parameters: DataFrame containing Monte Carlo parameter sets
-        y0: Initial conditions for the solver
+        mc_to_scan: DataFrame containing Monte Carlo parameter sets
+        to_scan: List of parameters for which to calculate elasticities
+        variables: Custom variable values. Defaults to initial conditions.
         cache: Cache object for storing results
         normalized: Whether to use normalized elasticities
         displacement: Displacement for finite difference calculations
@@ -531,13 +543,15 @@ def response_coefficients(
         ResponseCoefficientsByPars: Object containing the response coefficients for the given parameters
 
     """
+    if variables is not None:
+        model.update_variables(variables)
+
     res = parallelise(
         fn=partial(
-            _update_parameters_and,
+            _update_parameters_and_initial_conditions,
             fn=partial(
                 mca.response_coefficients,
-                parameters=parameters,
-                y0=y0,
+                to_scan=to_scan,
                 normalized=normalized,
                 displacement=displacement,
                 rel_norm=rel_norm,
@@ -547,7 +561,7 @@ def response_coefficients(
             ),
             model=model,
         ),
-        inputs=list(mc_parameters.iterrows()),
+        inputs=list(mc_to_scan.iterrows()),
         cache=cache,
         max_workers=max_workers,
     )
@@ -557,5 +571,5 @@ def response_coefficients(
             pd.DataFrame, pd.concat({k: v.variables for k, v in res.items()})
         ),
         fluxes=cast(pd.DataFrame, pd.concat({k: v.fluxes for k, v in res.items()})),
-        parameters=mc_parameters,
+        parameters=mc_to_scan,
     )