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

mxlpy/integrators/int_assimulo.py

@@ -116,7 +116,8 @@ class Assimulo:
 
         """
         try:
-            return self.integrator.simulate(time_points[-1], 0, time_points)  # type: ignore
+            t, y = self.integrator.simulate(time_points[-1], 0, time_points)  # type: ignore
+            return np.array(t, dtype=float), np.array(y, dtype=float)
         except CVodeError:
             return None, None
 

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,
     )

mxlpy/mca.py

@@ -38,6 +38,73 @@ if TYPE_CHECKING:
     from mxlpy.types import IntegratorType
 
 
+def _response_coefficient_worker(
+    parameter: str,
+    *,
+    model: Model,
+    y0: dict[str, float] | None,
+    normalized: bool,
+    rel_norm: bool,
+    displacement: float = 1e-4,
+    integrator: IntegratorType,
+) -> tuple[pd.Series, pd.Series]:
+    """Calculate response coefficients for a single parameter.
+
+    Internal helper function that computes concentration and flux response
+    coefficients using finite differences. The function:
+    1. Perturbs the parameter up and down by a small displacement
+    2. Calculates steady states for each perturbation
+    3. Computes response coefficients from the differences
+    4. Optionally normalizes the results
+
+    Args:
+        parameter: Name of the parameter to analyze
+        model: Metabolic model instance
+        y0: Initial conditions as a dictionary {species: value}
+        normalized: Whether to normalize the coefficients
+        rel_norm: Whether to use relative normalization
+        displacement: Relative perturbation size (default: 1e-4)
+        integrator: Integrator function to use for steady state calculation
+
+    Returns:
+        tuple[pd.Series, pd.Series]: Tuple containing:
+            - Series of concentration response coefficients
+            - Series of flux response coefficients
+
+    """
+    old = model.parameters[parameter]
+    if y0 is not None:
+        model.update_variables(y0)
+
+    model.update_parameters({parameter: old * (1 + displacement)})
+    upper = _steady_state_worker(
+        model,
+        rel_norm=rel_norm,
+        integrator=integrator,
+    )
+
+    model.update_parameters({parameter: old * (1 - displacement)})
+    lower = _steady_state_worker(
+        model,
+        rel_norm=rel_norm,
+        integrator=integrator,
+    )
+
+    conc_resp = (upper.variables - lower.variables) / (2 * displacement * old)
+    flux_resp = (upper.fluxes - lower.fluxes) / (2 * displacement * old)
+    # Reset
+    model.update_parameters({parameter: old})
+    if normalized:
+        norm = _steady_state_worker(
+            model,
+            rel_norm=rel_norm,
+            integrator=integrator,
+        )
+        conc_resp *= old / norm.variables
+        flux_resp *= old / norm.fluxes
+    return conc_resp, flux_resp
+
+
 ###############################################################################
 # Non-steady state
 ###############################################################################
@@ -46,8 +113,8 @@ if TYPE_CHECKING:
 def variable_elasticities(
     model: Model,
     *,
-    concs: dict[str, float] | None = None,
-    variables: list[str] | None = None,
+    to_scan: list[str] | None = None,
+    variables: dict[str, float] | None = None,
     time: float = 0,
     normalized: bool = True,
     displacement: float = 1e-4,
@@ -67,8 +134,8 @@ def variable_elasticities(
 
     Args:
         model: Metabolic model instance
-        concs: Initial concentrations {metabolite: value}. Uses model defaults if None
-        variables: List of variables to analyze. Uses all if None
+        to_scan: List of variables to analyze. Uses all if None
+        variables: Custom variable values. Defaults to initial conditions.
         time: Time point for evaluation
         normalized: Whether to normalize coefficients
         displacement: Relative perturbation size
@@ -77,23 +144,23 @@ def variable_elasticities(
         DataFrame with elasticity coefficients (reactions x metabolites)
 
     """
-    concs = model.get_initial_conditions() if concs is None else concs
-    variables = model.get_variable_names() if variables is None else variables
+    variables = model.get_initial_conditions() if variables is None else variables
+    to_scan = model.get_variable_names() if to_scan is None else to_scan
     elasticities = {}
 
-    for var in variables:
-        old = concs[var]
+    for var in to_scan:
+        old = variables[var]
 
         upper = model.get_fluxes(
-            variables=concs | {var: old * (1 + displacement)}, time=time
+            variables=variables | {var: old * (1 + displacement)}, time=time
         )
         lower = model.get_fluxes(
-            variables=concs | {var: old * (1 - displacement)}, time=time
+            variables=variables | {var: old * (1 - displacement)}, time=time
         )
 
         elasticity_coef = (upper - lower) / (2 * displacement * old)
         if normalized:
-            elasticity_coef *= old / model.get_fluxes(variables=concs, time=time)
+            elasticity_coef *= old / model.get_fluxes(variables=variables, time=time)
         elasticities[var] = elasticity_coef
 
     return pd.DataFrame(data=elasticities)
@@ -101,10 +168,10 @@ def variable_elasticities(
 
 def parameter_elasticities(
     model: Model,
-    parameters: list[str] | None = None,
-    concs: dict[str, float] | None = None,
-    time: float = 0,
     *,
+    to_scan: list[str] | None = None,
+    variables: dict[str, float] | None = None,
+    time: float = 0,
     normalized: bool = True,
     displacement: float = 1e-4,
 ) -> pd.DataFrame:
@@ -119,8 +186,8 @@ def parameter_elasticities(
 
     Args:
         model: Metabolic model instance
-        parameters: List of parameters to analyze. Uses all if None
-        concs: Initial concentrations {metabolite: value}. Uses model defaults if None
+        to_scan: List of parameters to analyze. Uses all if None
+        variables: Custom variable values. Defaults to initial conditions.
         time: Time point for evaluation
         normalized: Whether to normalize coefficients
         displacement: Relative perturbation size
@@ -129,26 +196,26 @@ def parameter_elasticities(
         DataFrame with parameter elasticities (reactions x parameters)
 
     """
-    concs = model.get_initial_conditions() if concs is None else concs
-    parameters = model.get_parameter_names() if parameters is None else parameters
+    variables = model.get_initial_conditions() if variables is None else variables
+    to_scan = model.get_parameter_names() if to_scan is None else to_scan
 
     elasticities = {}
 
-    concs = model.get_initial_conditions() if concs is None else concs
-    for par in parameters:
+    variables = model.get_initial_conditions() if variables is None else variables
+    for par in to_scan:
         old = model.parameters[par]
 
         model.update_parameters({par: old * (1 + displacement)})
-        upper = model.get_fluxes(variables=concs, time=time)
+        upper = model.get_fluxes(variables=variables, time=time)
 
         model.update_parameters({par: old * (1 - displacement)})
-        lower = model.get_fluxes(variables=concs, time=time)
+        lower = model.get_fluxes(variables=variables, time=time)
 
         # Reset
         model.update_parameters({par: old})
         elasticity_coef = (upper - lower) / (2 * displacement * old)
         if normalized:
-            elasticity_coef *= old / model.get_fluxes(variables=concs, time=time)
+            elasticity_coef *= old / model.get_fluxes(variables=variables, time=time)
         elasticities[par] = elasticity_coef
 
     return pd.DataFrame(data=elasticities)
@@ -159,79 +226,11 @@ def parameter_elasticities(
 # ###############################################################################
 
 
-def _response_coefficient_worker(
-    parameter: str,
-    *,
-    model: Model,
-    y0: dict[str, float] | None,
-    normalized: bool,
-    rel_norm: bool,
-    displacement: float = 1e-4,
-    integrator: IntegratorType,
-) -> tuple[pd.Series, pd.Series]:
-    """Calculate response coefficients for a single parameter.
-
-    Internal helper function that computes concentration and flux response
-    coefficients using finite differences. The function:
-    1. Perturbs the parameter up and down by a small displacement
-    2. Calculates steady states for each perturbation
-    3. Computes response coefficients from the differences
-    4. Optionally normalizes the results
-
-    Args:
-        parameter: Name of the parameter to analyze
-        model: Metabolic model instance
-        y0: Initial conditions as a dictionary {species: value}
-        normalized: Whether to normalize the coefficients
-        rel_norm: Whether to use relative normalization
-        displacement: Relative perturbation size (default: 1e-4)
-        integrator: Integrator function to use for steady state calculation
-
-    Returns:
-        tuple[pd.Series, pd.Series]: Tuple containing:
-            - Series of concentration response coefficients
-            - Series of flux response coefficients
-
-    """
-    old = model.parameters[parameter]
-
-    model.update_parameters({parameter: old * (1 + displacement)})
-    upper = _steady_state_worker(
-        model,
-        y0=y0,
-        rel_norm=rel_norm,
-        integrator=integrator,
-    )
-
-    model.update_parameters({parameter: old * (1 - displacement)})
-    lower = _steady_state_worker(
-        model,
-        y0=y0,
-        rel_norm=rel_norm,
-        integrator=integrator,
-    )
-
-    conc_resp = (upper.variables - lower.variables) / (2 * displacement * old)
-    flux_resp = (upper.fluxes - lower.fluxes) / (2 * displacement * old)
-    # Reset
-    model.update_parameters({parameter: old})
-    if normalized:
-        norm = _steady_state_worker(
-            model,
-            y0=y0,
-            rel_norm=rel_norm,
-            integrator=integrator,
-        )
-        conc_resp *= old / norm.variables
-        flux_resp *= old / norm.fluxes
-    return conc_resp, flux_resp
-
-
 def response_coefficients(
     model: Model,
-    parameters: list[str] | None = None,
     *,
-    y0: dict[str, float] | None = None,
+    to_scan: list[str] | None = None,
+    variables: dict[str, float] | None = None,
     normalized: bool = True,
     displacement: float = 1e-4,
     disable_tqdm: bool = False,
@@ -250,8 +249,8 @@ def response_coefficients(
 
     Args:
         model: Metabolic model instance
-        parameters: Parameters to analyze. Uses all if None
-        y0: Initial conditions as a dictionary {species: value}
+        to_scan: Parameters to analyze. Uses all if None
+        variables: Custom variable values. Defaults to initial conditions.
         normalized: Whether to normalize coefficients
         displacement: Relative perturbation size
         disable_tqdm: Disable progress bar
@@ -266,19 +265,19 @@ def response_coefficients(
         - Concentration response coefficients
 
     """
-    parameters = model.get_parameter_names() if parameters is None else parameters
+    to_scan = model.get_parameter_names() if to_scan is None else to_scan
 
     res = parallelise(
         partial(
             _response_coefficient_worker,
             model=model,
-            y0=y0,
+            y0=variables,
             normalized=normalized,
             displacement=displacement,
             rel_norm=rel_norm,
             integrator=integrator,
         ),
-        inputs=list(zip(parameters, parameters, strict=True)),
+        inputs=list(zip(to_scan, to_scan, strict=True)),
         cache=None,
         disable_tqdm=disable_tqdm,
         parallel=parallel,

mxlpy/scan.py

@@ -51,7 +51,7 @@ if TYPE_CHECKING:
     from mxlpy.types import Array
 
 
-def _update_parameters_and[T](
+def _update_parameters_and_initial_conditions[T](
     pars: pd.Series,
     fn: Callable[[Model], T],
     model: Model,
@@ -67,7 +67,9 @@ def _update_parameters_and[T](
         Result of the function execution.
 
     """
-    model.update_parameters(pars.to_dict())
+    pd = pars.to_dict()
+    model.update_variables({k: v for k, v in pd.items() if k in model._variables})  # noqa: SLF001
+    model.update_parameters({k: v for k, v in pd.items() if k in model._parameters})  # noqa: SLF001
     return fn(model)
 
 
@@ -282,7 +284,6 @@ class SteadyStateWorker(Protocol):
     def __call__(
         self,
         model: Model,
-        y0: dict[str, float] | None,
         *,
         rel_norm: bool,
         integrator: IntegratorType,
@@ -297,7 +298,6 @@ class TimeCourseWorker(Protocol):
     def __call__(
         self,
         model: Model,
-        y0: dict[str, float] | None,
         time_points: Array,
         *,
         integrator: IntegratorType,
@@ -312,7 +312,6 @@ class ProtocolWorker(Protocol):
     def __call__(
         self,
         model: Model,
-        y0: dict[str, float] | None,
         protocol: pd.DataFrame,
         *,
         integrator: IntegratorType,
@@ -324,7 +323,6 @@ class ProtocolWorker(Protocol):
 
 def _steady_state_worker(
     model: Model,
-    y0: dict[str, float] | None,
     *,
     rel_norm: bool,
     integrator: IntegratorType,
@@ -343,7 +341,7 @@ def _steady_state_worker(
     """
     try:
         res = (
-            Simulator(model, y0=y0, integrator=integrator)
+            Simulator(model, integrator=integrator)
             .simulate_to_steady_state(rel_norm=rel_norm)
             .get_result()
         )
@@ -354,7 +352,6 @@ def _steady_state_worker(
 
 def _time_course_worker(
     model: Model,
-    y0: dict[str, float] | None,
     time_points: Array,
     integrator: IntegratorType,
 ) -> TimeCourse:
@@ -372,7 +369,7 @@ def _time_course_worker(
     """
     try:
         res = (
-            Simulator(model, y0=y0, integrator=integrator)
+            Simulator(model, integrator=integrator)
             .simulate_time_course(time_points=time_points)
             .get_result()
         )
@@ -387,7 +384,6 @@ def _time_course_worker(
 
 def _protocol_worker(
     model: Model,
-    y0: dict[str, float] | None,
     protocol: pd.DataFrame,
     *,
     integrator: IntegratorType = DefaultIntegrator,
@@ -408,7 +404,7 @@ def _protocol_worker(
     """
     try:
         res = (
-            Simulator(model, y0=y0, integrator=integrator)
+            Simulator(model, integrator=integrator)
             .simulate_over_protocol(
                 protocol=protocol,
                 time_points_per_step=time_points_per_step,
@@ -432,20 +428,20 @@ def _protocol_worker(
 
 def steady_state(
     model: Model,
-    parameters: pd.DataFrame,
-    y0: dict[str, float] | None = None,
     *,
+    to_scan: pd.DataFrame,
+    y0: dict[str, float] | None = None,
     parallel: bool = True,
     rel_norm: bool = False,
     cache: Cache | None = None,
     worker: SteadyStateWorker = _steady_state_worker,
     integrator: IntegratorType = DefaultIntegrator,
 ) -> SteadyStates:
-    """Get steady-state results over supplied parameters.
+    """Get steady-state results over supplied values.
 
     Args:
         model: Model instance to simulate.
-        parameters: DataFrame containing parameter values to scan.
+        to_scan: DataFrame containing parameter or initial values to scan.
         y0: Initial conditions as a dictionary {variable: value}.
         parallel: Whether to execute in parallel (default: True).
         rel_norm: Whether to use relative normalization (default: False).
@@ -478,39 +474,41 @@ def steady_state(
         | (2, 4) | 0.5  |   2 |
 
     """
+    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(parameters.iterrows()),
+        inputs=list(to_scan.iterrows()),
         cache=cache,
         parallel=parallel,
     )
     concs = pd.DataFrame({k: v.variables.T for k, v in res.items()}).T
     fluxes = pd.DataFrame({k: v.fluxes.T for k, v in res.items()}).T
     idx = (
-        pd.Index(parameters.iloc[:, 0])
-        if parameters.shape[1] == 1
-        else pd.MultiIndex.from_frame(parameters)
+        pd.Index(to_scan.iloc[:, 0])
+        if to_scan.shape[1] == 1
+        else pd.MultiIndex.from_frame(to_scan)
     )
     concs.index = idx
     fluxes.index = idx
-    return SteadyStates(variables=concs, fluxes=fluxes, parameters=parameters)
+    return SteadyStates(variables=concs, fluxes=fluxes, parameters=to_scan)
 
 
 def time_course(
     model: Model,
-    parameters: pd.DataFrame,
+    *,
+    to_scan: pd.DataFrame,
     time_points: Array,
     y0: dict[str, float] | None = None,
-    *,
     parallel: bool = True,
     cache: Cache | None = None,
     worker: TimeCourseWorker = _time_course_worker,
@@ -521,7 +519,7 @@ def time_course(
     Examples:
         >>> time_course(
         >>>     model,
-        >>>     parameters=pd.DataFrame({"k1": [1, 1.5, 2]}),
+        >>>     to_scan=pd.DataFrame({"k1": [1, 1.5, 2]}),
         >>>     time_points=np.linspace(0, 1, 3)
         >>> ).variables
 
@@ -539,7 +537,7 @@ def time_course(
 
         >>> time_course(
         >>>     model,
-        >>>     parameters=cartesian_product({"k1": [1, 2], "k2": [3, 4]}),
+        >>>     to_scan=cartesian_product({"k1": [1, 2], "k2": [3, 4]}),
         >>>     time_points=[0.0, 0.5, 1.0],
         >>> ).variables
 
@@ -553,7 +551,7 @@ def time_course(
 
     Args:
         model: Model instance to simulate.
-        parameters: DataFrame containing parameter values to scan.
+        to_scan: DataFrame containing parameter or initial values to scan.
         time_points: Array of time points for the simulation.
         y0: Initial conditions as a dictionary {variable: value}.
         cache: Optional cache to store and retrieve results.
@@ -566,25 +564,27 @@ def time_course(
 
 
     """
+    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(parameters.iterrows()),
+        inputs=list(to_scan.iterrows()),
         cache=cache,
         parallel=parallel,
     )
     concs = cast(dict, {k: v.variables for k, v in res.items()})
     fluxes = cast(dict, {k: v.fluxes for k, v in res.items()})
     return TimeCourseByPars(
-        parameters=parameters,
+        parameters=to_scan,
         variables=pd.concat(concs, names=["n", "time"]),
         fluxes=pd.concat(fluxes, names=["n", "time"]),
     )
@@ -592,11 +592,11 @@ def time_course(
 
 def time_course_over_protocol(
     model: Model,
-    parameters: pd.DataFrame,
+    *,
+    to_scan: pd.DataFrame,
     protocol: pd.DataFrame,
     time_points_per_step: int = 10,
     y0: dict[str, float] | None = None,
-    *,
     parallel: bool = True,
     cache: Cache | None = None,
     worker: ProtocolWorker = _protocol_worker,
@@ -618,7 +618,7 @@ def time_course_over_protocol(
 
     Args:
         model: Model instance to simulate.
-        parameters: DataFrame containing parameter values to scan.
+        to_scan: DataFrame containing parameter or initial values to scan.
         protocol: Protocol to follow for the simulation.
         time_points_per_step: Number of time points per protocol step (default: 10).
         y0: Initial conditions as a dictionary {variable: value}.
@@ -631,26 +631,28 @@ def time_course_over_protocol(
         TimeCourseByPars: Protocol series results for each parameter set.
 
     """
+    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,
                 time_points_per_step=time_points_per_step,
                 integrator=integrator,
             ),
             model=model,
         ),
-        inputs=list(parameters.iterrows()),
+        inputs=list(to_scan.iterrows()),
         cache=cache,
         parallel=parallel,
     )
     concs = cast(dict, {k: v.variables for k, v in res.items()})
     fluxes = cast(dict, {k: v.fluxes for k, v in res.items()})
     return ProtocolByPars(
-        parameters=parameters,
+        parameters=to_scan,
         protocol=protocol,
         variables=pd.concat(concs, names=["n", "time"]),
         fluxes=pd.concat(fluxes, names=["n", "time"]),

mxlpy/types.py

@@ -354,7 +354,7 @@ class McSteadyStates:
     variables: pd.DataFrame
     fluxes: pd.DataFrame
     parameters: pd.DataFrame
-    mc_parameters: pd.DataFrame
+    mc_to_scan: pd.DataFrame
 
     def __iter__(self) -> Iterator[pd.DataFrame]:
         """Iterate over the concentration and flux steady states."""

{mxlpy-0.15.0.dist-info → mxlpy-0.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mxlpy
-Version: 0.15.0
+Version: 0.16.0
 Summary: A package to build metabolic models
 Author-email: Marvin van Aalst <marvin.vanaalst@gmail.com>
 Maintainer-email: Marvin van Aalst <marvin.vanaalst@gmail.com>
@@ -60,7 +60,9 @@ Provides-Extra: torch
 Requires-Dist: torch>=2.5.1; extra == 'torch'
 Description-Content-Type: text/markdown
 
-<img src="docs/assets/logo-diagram.png" style="display: block; max-height: 30rem; margin: auto; padding: 0" alt='mxlpy-logo'>
+<p align="center">
+    <img src="docs/assets/logo-diagram.png" width="600px" alt='mxlpy-logo'>
+</p>
 
 # mxlpy
 
@@ -70,7 +72,7 @@ Description-Content-Type: text/markdown
 ![Coverage](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fgist.github.com%2Fmarvinvanaalst%2F98ab3ce1db511de42f9871e91d85e4cd%2Fraw%2Fcoverage.json&query=%24.message&label=Coverage&color=%24.color&suffix=%20%25)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
-[![Downloads](https://pepy.tech/badge/mxlpy)](https://pepy.tech/project/mxlpy)
+[![PyPI Downloads](https://static.pepy.tech/badge/mxlpy)](https://pepy.tech/projects/mxlpy)
 
 [docs-badge]: https://img.shields.io/badge/docs-main-green.svg?style=flat-square
 [docs]: https://computational-biology-aachen.github.io/mxlpy/

{mxlpy-0.15.0.dist-info → mxlpy-0.16.0.dist-info}/RECORD

@@ -5,8 +5,8 @@ mxlpy/fns.py,sha256=ct_RFj9koW8vXHyr27GnbZUHUS_zfs4rDysybuFiOaU,4599
 mxlpy/identify.py,sha256=af52SCG4nlY9sSw22goaIheuvXR09QYK4ksCT24QHWI,1946
 mxlpy/label_map.py,sha256=urv-QTb0MUEKjwWvKtJSB8H2kvhLn1EKfRIH7awQQ8Y,17769
 mxlpy/linear_label_map.py,sha256=DqzN_akacPccZwzYAR3ANIdzAU_GU6Xe6gWV9DHAAWU,10282
-mxlpy/mc.py,sha256=HWuJq4fV_wfTDERbLJRSF3fjCCYMxzLdqAyO53Z_uF8,16985
-mxlpy/mca.py,sha256=H0dfV45Kz5nMIW8s2V61op7x6LmI21wWgRf94i6iIY4,9328
+mxlpy/mc.py,sha256=oYd8a3ycyZLyh-ZxTYUjDRNfsCcwSQaLWssxv0yC5Cc,17399
+mxlpy/mca.py,sha256=1_qBX9lHI6svXSebtwvMldAMwPlLqMylAPmxMbMQdWw,9359
 mxlpy/model.py,sha256=qzol8nDSbM3HdESh50c4UFjn6Pw5JwcvhQ5AyKnbyvc,57576
 mxlpy/npe.py,sha256=oiRLA43-qf-AcS2KpQfJIOt7-Ev9Aj5sF6TMq9bJn84,8747
 mxlpy/parallel.py,sha256=kX4Td5YoovDwZp6kX_3cfO6QtHSS9ieJ0bMZiKs3Xv8,5002
@@ -15,13 +15,13 @@ mxlpy/paths.py,sha256=TK2wO4N9lG-UV1JGfeB64q48JVDbwqIUj63rl55MKuQ,1022
 mxlpy/plot.py,sha256=4uu-6d8LH-GWX-sG_TlSpkSsnikv1DLTtnjJzA7nuRA,24670
 mxlpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mxlpy/report.py,sha256=h7dhcBzPFydLPxdsEXokzDf7Ce4PirXMsvLqlDZLSWM,7181
-mxlpy/scan.py,sha256=-1SLyXJOX3U3CxeP1dEC4ytAoBMCH0Ql89wGvsG3LbI,18858
+mxlpy/scan.py,sha256=FBPpjv66v4IWZ5OwG_EWUdrucLWR9gq_XEsLFC-otaw,18969
 mxlpy/simulator.py,sha256=9Ne4P5Jrwgx4oAlljPvCqSCCy98_5Lv1B87y1AkbI4c,21041
-mxlpy/types.py,sha256=AGWFK59MRRVBOr8I1EmFKGdRpF1DiT8C4lB95-oBk40,14512
+mxlpy/types.py,sha256=GbdyzEDTN8QfUH6-XXdNgf_TzqIXaYvcZGxaXc5kVio,14509
 mxlpy/experimental/__init__.py,sha256=kZTE-92OErpHzNRqmgSQYH4CGXrogGJ5EL35XGZQ81M,206
 mxlpy/experimental/diff.py,sha256=4bztagJzFMsQJM7dlun_kv-WrWssM8CIw7gcL63hFf8,8952
 mxlpy/integrators/__init__.py,sha256=kqmV6a0TRyLGR_XqbyAI652AfptYnXAUpqbSFg0CpP8,450
-mxlpy/integrators/int_assimulo.py,sha256=d-4HHOj4vmGpg8ig2IXMO5CPiIrq89_quEKvCxIKrhw,4747
+mxlpy/integrators/int_assimulo.py,sha256=TCBWQd558ZeRdBba1jCNsFyLBOssKvm8dXK36Aqg4_k,4817
 mxlpy/integrators/int_scipy.py,sha256=dFHlYTeb2zX97f3VuNdMJdI7WEYshF4JAIgprKKk2z4,4581
 mxlpy/meta/__init__.py,sha256=Jyy4063fZy6iT4LSwjPyEAVr4N_3xxcLc8wDBoDPyKc,278
 mxlpy/meta/codegen_latex.py,sha256=R0OJqzE7PnOCWLk52C3XWuRb-zI2eYTvV2oJZJvPsOE,13414
@@ -44,7 +44,7 @@ mxlpy/surrogates/_torch.py,sha256=E_1eDUlPSVFwROkdMDCqYwwHE-61pjNMJWotnhjzge0,58
 mxlpy/symbolic/__init__.py,sha256=3hQjCMw8-6iOxeUdfnCg8449fF_BRF2u6lCM1GPpkRY,222
 mxlpy/symbolic/strikepy.py,sha256=r6nRtckV1nxKq3i1bYYWZOkzwZ5XeKQuZM5ck44vUo0,20010
 mxlpy/symbolic/symbolic_model.py,sha256=YL9noEeP3_0DoKXwMPELtfmPuP6mgNcLIJgDRCkyB7A,2434
-mxlpy-0.15.0.dist-info/METADATA,sha256=EXj4l7bToJEQx3jbL26ECI_VuxtSgutyL44zdxLQ4Bg,4564
-mxlpy-0.15.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mxlpy-0.15.0.dist-info/licenses/LICENSE,sha256=bEzjyjy1stQhfRDVaVHa3xV1x-V8emwdlbMvYO8Zo84,35073
-mxlpy-0.15.0.dist-info/RECORD,,
+mxlpy-0.16.0.dist-info/METADATA,sha256=ySMK4udu6wgaUpG7Wn0sa-XYUkaVz4u19C5PjMEM5p0,4551
+mxlpy-0.16.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mxlpy-0.16.0.dist-info/licenses/LICENSE,sha256=bEzjyjy1stQhfRDVaVHa3xV1x-V8emwdlbMvYO8Zo84,35073
+mxlpy-0.16.0.dist-info/RECORD,,