amici.amici

Core C++ bindings

This module encompasses the complete public C++ API of AMICI, which was exposed via swig. All functions listed here are directly accessible in the main amici package, i.e., amici.amici.ExpData is available as amici.ExpData. Usage of functions and classes from the base amici package is generally recommended as they often include convenience wrappers that avoid common pitfalls when accessing C++ types from python and implement some nonstandard type conversions.

Module Attributes

`SensitivityOrder_none`	Don't compute sensitivities.
`SensitivityOrder_first`	First-order sensitivities.
`SensitivityOrder_second`	Second-order sensitivities.
`SensitivityMethod_none`	Don't compute sensitivities.
`SensitivityMethod_forward`	Forward sensitivity analysis.
`SensitivityMethod_adjoint`	Adjoint sensitivity analysis.

Functions

`compiled_with_openmp`()	AMICI extension was compiled with OpenMP?
`enum`(prefix)
`get_backtrace_string`(maxFrames[, first_frame])	Returns the current backtrace as std::string
`parameter_scaling_from_int_vector`(int_vec)	Swig-Generated class, which, in contrast to other Vector classes, does not allow for simple interoperability with common Python types, but must be created using `amici.amici.parameter_scaling_from_int_vector()`
`read_exp_data_from_hdf5`(hdf5Filename, ...)	Read AMICI ExpData data from HDF5 file.
`read_model_data_from_hdf5`(*args)	Overload 1:
`read_solver_settings_from_hdf5`(*args)	Overload 1:
`run_simulation`(solver, edata, model[, rethrow])	Core integration routine.
`run_simulations`(solver, edatas, model, ...)	Same as run_simulation, but for multiple ExpData instances.
`scale_parameter`(unscaledParameter, scaling)	Apply parameter scaling according to scaling
`simulation_status_to_str`(status)	Get the string representation of the given simulation status code (see ReturnData::status).
`unscale_parameter`(scaledParameter, scaling)	Remove parameter scaling according to scaling
`write_exp_data_to_hdf5`(*args)	Overload 1:
`write_return_data_to_hdf5`(*args)	Overload 1:
`write_solver_settings_to_hdf5`(*args)	Overload 1:

Classes

`BoolVector`(*args)	Swig-Generated class templating common python types including `Iterable` [`bool`] and `numpy.array` [`bool`] to facilitate interfacing with C++ bindings.
`Constraint`(value[, names, module, qualname, ...])
`CpuTimer`()	Tracks elapsed CPU time using std::clock.
`DoubleVector`(*args)	Swig-Generated class templating common python types including `Iterable` [`float`] and `numpy.array` [`float`] to facilitate interfacing with C++ bindings.
`ExpData`(*args)	ExpData carries all information about experimental or condition-specific data.
`ExpDataPtr`(*args)	Swig-Generated class that implements smart pointers to ExpData as objects.
`ExpDataPtrVector`(*args)	Swig-Generated class templating common python types including `Iterable` [`amici.amici.ExpData`] and `numpy.array` [`amici.amici.ExpData`] to facilitate interfacing with C++ bindings.
`FixedParameterContext`(value[, names, ...])
`IntVector`(*args)	Swig-Generated class templating common python types including `Iterable` [`int`] and `numpy.array` [`int`] to facilitate interfacing with C++ bindings.
`InternalSensitivityMethod`(value[, names, ...])
`InterpolationType`(value[, names, module, ...])
`LinearMultistepMethod`(value[, names, ...])
`LinearSolver`(value[, names, module, ...])
`LogItem`(*args)	A log item.
`LogItemVector`(*args)
`LogSeverity`(value[, names, module, ...])
`Model`(args, *kwargs)	The Model class represents an AMICI ODE/DAE model.
`ModelDimensions`()	Container for model dimensions.
`ModelPtr`(*args)	Swig-Generated class that implements smart pointers to Model as objects.
`NewtonDampingFactorMode`(value[, names, ...])
`NonlinearSolverIteration`(value[, names, ...])
`ObservableScaling`(value[, names, module, ...])
`ParameterScaling`(value[, names, module, ...])
`ParameterScalingVector`(*args)
`RDataReporting`(value[, names, module, ...])
`ReturnData`(*args)	Stores all data to be returned by `amici.amici.runAmiciSimulation()`.
`ReturnDataPtr`(*args)	Swig-Generated class that implements smart pointers to ReturnData as objects.
`SecondOrderMode`(value[, names, module, ...])
`SensitivityMethod`(value[, names, module, ...])
`SensitivityOrder`(value[, names, module, ...])
`SimulationParameters`(*args)	Container for various simulation parameters.
`Solver`(args, *kwargs)	The Solver class provides a generic interface to CVODES and IDAS solvers, individual realizations are realized in the CVodeSolver and the IDASolver class.
`SolverPtr`(*args)	Swig-Generated class that implements smart pointers to Solver as objects.
`SteadyStateComputationMode`(value[, names, ...])
`SteadyStateSensitivityMode`(value[, names, ...])
`SteadyStateStatus`(value[, names, module, ...])
`SteadyStateStatusVector`(*args)
`StringDoubleMap`(*args)	Swig-Generated class templating `Dict` [`str`, `float`] to facilitate interfacing with C++ bindings.
`StringVector`(*args)	Swig-Generated class templating common python types including `Iterable` [`str`] and `numpy.array` [`str`] to facilitate interfacing with C++ bindings.

class amici.amici.BoolVector(*args)[source]: Swig-Generated class templating common python types including Iterable [bool] and numpy.array [bool] to facilitate interfacing with C++ bindings.

class amici.amici.Constraint(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

negative = -2

non_negative = 1

non_positive = -1

none = 0

positive = 2

class amici.amici.CpuTimer[source]

Tracks elapsed CPU time using std::clock.

__init__()[source]: Constructor

elapsed_milliseconds() → float[source]

Get elapsed CPU time in milliseconds since initialization or last reset

Return type:: float
Returns:: CPU time in milliseconds

elapsed_seconds() → float[source]

Get elapsed CPU time in seconds since initialization or last reset

Return type:: float
Returns:: CPU time in seconds

reset()[source]: Reset the timer

uses_thread_clock = False: Whether the timer uses a thread clock (i.e. provides proper, thread-specific CPU time).

class amici.amici.DoubleVector(*args)[source]: Swig-Generated class templating common python types including Iterable [float] and numpy.array [float] to facilitate interfacing with C++ bindings.

class amici.amici.ExpData(*args)[source]

ExpData carries all information about experimental or condition-specific data.

__init__(*args)[source]

Overload 1:

Default constructor.

Overload 2:

Copy constructor.

Overload 3:

Constructor that only initializes dimensions.

Parameters:

nytrue (int) – Number of observables
nztrue (int) – Number of event outputs
nmaxevent (int) – Maximal number of events to track

Overload 4:

constructor that initializes timepoints from vectors

Parameters:

nytrue (int) – Number of observables
nztrue (int) – Number of event outputs
nmaxevent (int) – Maximal number of events to track
ts (DoubleVector) – Timepoints (dimension: nt)

Overload 5:

constructor that initializes timepoints and fixed parameters from vectors

Parameters:

nytrue (int) – Number of observables
nztrue (int) – Number of event outputs
nmaxevent (int) – Maximal number of events to track
ts (DoubleVector) – Timepoints (dimension: nt)
fixed_parameters (DoubleVector) – Model constants (dimension: nk)

Overload 6:

constructor that initializes timepoints and data from vectors

Parameters:

nytrue (int) – Number of observables
nztrue (int) – Number of event outputs
nmaxevent (int) – Maximal number of events to track
ts (DoubleVector) – Timepoints (dimension: nt)
observed_data (DoubleVector) – observed data (dimension: nt x nytrue, row-major)
observed_data_std_dev (DoubleVector) – standard deviation of observed data (dimension: nt x nytrue, row-major)
observed_events (DoubleVector) – observed events (dimension: nmaxevents x nztrue, row-major)
observed_events_std_dev (DoubleVector) – standard deviation of observed events/roots (dimension: nmaxevents x nztrue, row-major)

Overload 7:

constructor that initializes with Model

Parameters:: model (Model) – pointer to model specification object

Overload 8:

Constructor that initializes with ReturnData, adds normally distributed noise according to specified sigmas.

Parameters:

rdata (ReturnData) – return data pointer with stored simulation results
sigma_y (float) – scalar standard deviations for all observables
sigma_z (float) – scalar standard deviations for all event observables
seed (int, optional) – Seed for the random number generator. If a negative number is passed, a random seed is used.

Overload 9:

Constructor that initializes with ReturnData, adds normally distributed noise according to specified sigmas.

Parameters:

rdata (ReturnData) – return data pointer with stored simulation results
sigma_y (float) – scalar standard deviations for all observables
sigma_z (float) – scalar standard deviations for all event observables
seed – Seed for the random number generator. If a negative number is passed, a random seed is used.

Overload 10:

Constructor that initializes with ReturnData, adds normally distributed noise according to specified sigmas.

Parameters:

rdata (ReturnData) – return data pointer with stored simulation results
sigma_y (DoubleVector) – vector of standard deviations for observables (dimension: nytrue or nt x nytrue, row-major)
sigma_z (DoubleVector) – vector of standard deviations for event observables (dimension: nztrue or nmaxevent x nztrue, row-major)
seed (int, optional) – Seed for the random number generator. If a negative number is passed, a random seed is used.

Overload 11:

Constructor that initializes with ReturnData, adds normally distributed noise according to specified sigmas.

Parameters:

rdata (ReturnData) – return data pointer with stored simulation results
sigma_y (DoubleVector) – vector of standard deviations for observables (dimension: nytrue or nt x nytrue, row-major)
sigma_z (DoubleVector) – vector of standard deviations for event observables (dimension: nztrue or nmaxevent x nztrue, row-major)
seed – Seed for the random number generator. If a negative number is passed, a random seed is used.

clear_observations()[source]

Set all observations and their standard deviations to NaN.

Useful, e.g., after calling ExpData::setTimepoints.

property fixed_parameters

Model constants

Vector of size Model::nk() or empty

property fixed_parameters_pre_equilibration

Model constants for pre-equilibration

Vector of size Model::nk() or empty.

property fixed_parameters_presimulation

Model constants for pre-simulation

Vector of size Model::nk() or empty.

get_observed_data() → Sequence[float][source]

Get all measurements.

Return type:: collections.abc.Sequence[float]
Returns:: observed data (dimension: nt x nytrue, row-major)

get_observed_data_std_dev() → Sequence[float][source]

Get measurement standard deviations.

Return type:: collections.abc.Sequence[float]
Returns:: standard deviation of observed data

get_observed_events() → Sequence[float][source]

Get observed event data.

Return type:: collections.abc.Sequence[float]
Returns:: observed event data

get_observed_events_ptr(ie: int) → float[source]

Get pointer to observed data at ie-th occurrence.

Parameters:: ie (int) – event occurrence
Return type:: float
Returns:: pointer to observed event data at ie-th occurrence

get_observed_events_std_dev() → Sequence[float][source]

Get standard deviation of observed event data.

Return type:: collections.abc.Sequence[float]
Returns:: standard deviation of observed event data

get_observed_events_std_dev_ptr(ie: int) → float[source]

Get pointer to standard deviation of observed event data at ie-th occurrence.

Parameters:: ie (int) – event occurrence
Return type:: float
Returns:: pointer to standard deviation of observed event data at ie-th occurrence

get_timepoint(it: int) → float[source]

Get timepoint for the given index

Parameters:: it (int) – timepoint index
Return type:: float
Returns:: timepoint timepoint at index

get_timepoints() → Sequence[float][source]

Get output timepoints.

Return type:: collections.abc.Sequence[float]
Returns:: ExpData::ts

property id: Arbitrary (not necessarily unique) identifier.

is_set_observed_data(it: int, iy: int) → bool[source]

Whether there is a measurement for the given time- and observable- index.

Parameters:

it (int) – time index
iy (int) – observable index

Return type:

bool

Returns:

boolean specifying if data was set

is_set_observed_data_std_dev(it: int, iy: int) → bool[source]

Whether standard deviation for a measurement at specified timepoint- and observable index has been set.

Parameters:

it (int) – time index
iy (int) – observable index

Return type:

bool

Returns:

boolean specifying if standard deviation of data was set

is_set_observed_events(ie: int, iz: int) → bool[source]

Check whether event data at specified indices has been set.

Parameters:

ie (int) – event index
iz (int) – event observable index

Return type:

bool

Returns:

boolean specifying if data was set

is_set_observed_events_std_dev(ie: int, iz: int) → bool[source]

Check whether standard deviation of event data at specified indices has been set.

Parameters:

ie (int) – event index
iz (int) – event observable index

Return type:

bool

Returns:

boolean specifying if standard deviation of event data was set

nmaxevent() → int[source]

maximal number of events to track

Return type:: int
Returns:: maximal number of events to track

nt() → int[source]

number of timepoints

Return type:: int
Returns:: number of timepoints

nytrue() → int[source]

number of observables of the non-augmented model

Return type:: int
Returns:: number of observables of the non-augmented model

nztrue() → int[source]

number of event observables of the non-augmented model

Return type:: int
Returns:: number of event observables of the non-augmented model

property parameters

Model parameters

Vector of size Model::np() or empty with parameter scaled according to SimulationParameter::pscale.

property plist: Parameter indices w.r.t. which to compute sensitivities

property pscale

Parameter scales

Vector of parameter scale of size Model::np(), indicating how/if each parameter is to be scaled.

property reinitialization_state_idxs_presim: Indices of states to be reinitialized based on provided presimulation constants / fixed parameters.

property reinitialization_state_idxs_sim: Indices of states to be reinitialized based on provided constants / fixed parameters.

reinitialize_all_fixed_parameter_dependent_initial_states(nx_rdata: int)

Set reinitialization of all states based on model constants for all simulation phases.

Convenience function to populate reinitialization_state_idxs_presim and reinitialization_state_idxs_sim

Parameters:: nx_rdata (int) – Number of states (Model::nx_rdata)

reinitialize_all_fixed_parameter_dependent_initial_states_for_presimulation(nx_rdata: int)

Set reinitialization of all states based on model constants for presimulation (only meaningful if preequilibration is performed).

Convenience function to populate reinitialization_state_idxs_presim and reinitialization_state_idxs_sim

Parameters:: nx_rdata (int) – Number of states (Model::nx_rdata)

reinitialize_all_fixed_parameter_dependent_initial_states_for_simulation(nx_rdata: int)

Set reinitialization of all states based on model constants for the ‘main’ simulation (only meaningful if presimulation or preequilibration is performed).

Convenience function to populate reinitialization_state_idxs_presim and reinitialization_state_idxs_sim

Parameters:: nx_rdata (int) – Number of states (Model::nx_rdata)

property reinitialize_fixed_parameter_initial_states: Flag indicating whether reinitialization of states depending on fixed parameters is activated

set_observed_data(*args)[source]

Overload 1:

Set all measurements.

Parameters:: observed_data (DoubleVector) – observed data (dimension: nt x nytrue, row-major)

Overload 2:

Set measurements for a given observable index

Parameters:

observed_data (DoubleVector) – observed data (dimension: nt)
iy (int) – observed data index

set_observed_data_std_dev(*args)[source]

Overload 1:

Set standard deviations for measurements.

Parameters:: observed_data_std_dev (DoubleVector) – standard deviation of observed data (dimension: nt x nytrue, row-major)

Overload 2:

Set identical standard deviation for all measurements.

Parameters:: stdDev (float) – standard deviation (dimension: scalar)

Overload 3:

Set standard deviations of observed data for a specific observable index.

Parameters:

observedDataStdDev (DoubleVector) – standard deviation of observed data (dimension: nt)
iy (int) – observed data index

Overload 4:

Set all standard deviation for a given observable index to the input value.

Parameters:

stdDev (float) – standard deviation (dimension: scalar)
iy (int) – observed data index

set_observed_events(*args)[source]

Overload 1:

Set observed event data.

Parameters:: observedEvents (DoubleVector) – observed data (dimension: nmaxevent x nztrue, row-major)

Overload 2:

Set observed event data for specific event observable.

Parameters:

observedEvents (DoubleVector) – observed data (dimension: nmaxevent)
iz (int) – observed event data index

set_observed_events_std_dev(*args)[source]

Overload 1:

Set standard deviation of observed event data.

Parameters:: observedEventsStdDev (DoubleVector) – standard deviation of observed event data

Overload 2:

Set standard deviation of observed event data.

Parameters:: stdDev (float) – standard deviation (dimension: scalar)

Overload 3:

Set standard deviation of observed data for a specific observable.

Parameters:

observedEventsStdDev (DoubleVector) – standard deviation of observed data (dimension: nmaxevent)
iz (int) – observed data index

Overload 4:

Set all standard deviations of a specific event-observable.

Parameters:

stdDev (float) – standard deviation (dimension: scalar)
iz (int) – observed data index

set_timepoints(ts: Sequence[float])[source]

Set output ts.

If the number of timepoint increases, this will grow the observation/sigma matrices and fill new entries with NaN. If the number of ts decreases, this will shrink the observation/sigma matrices.

Note that the mapping from ts to measurements will not be preserved. E.g., say there are measurements at t = 2, and this function is called with [1, 2], then the old measurements will belong to t = 1.

Parameters:: ts (collections.abc.Sequence[float]) – ts

property sx0

Initial state sensitivities

Dimensions: Model::nx() * Model::nplist(), Model::nx() * ExpData::plist.size(), if ExpData::plist is not empty, or empty

property t_presim

Duration of pre-simulation.

If this is > 0, presimulation will be performed from (model->t0 - t_presim) to model->t0 using the fixedParameters in fixedParametersPresimulation

property t_start

Starting time of the simulation.

Output timepoints are absolute timepoints, independent of \(t_{start}\). For output timepoints \(t < t_{start}\), the initial state will be returned.

property t_start_preeq

The initial time for pre-equilibration..

NAN indicates that tstart_ should be used.

property timepoints

Timepoints for which model state/outputs/… are requested

Vector of timepoints.

property x0

Initial state

Vector of size Model::nx() or empty

class amici.amici.ExpDataPtr(*args)[source]

Swig-Generated class that implements smart pointers to ExpData as objects.

property fixed_parameters

Model constants

Vector of size Model::nk() or empty

property fixed_parameters_pre_equilibration

Model constants for pre-equilibration

Vector of size Model::nk() or empty.

property fixed_parameters_presimulation

Model constants for pre-simulation

Vector of size Model::nk() or empty.

property id: Arbitrary (not necessarily unique) identifier.

property parameters

Model parameters

Vector of size Model::np() or empty with parameter scaled according to SimulationParameter::pscale.

property plist: Parameter indices w.r.t. which to compute sensitivities

property pscale

Parameter scales

Vector of parameter scale of size Model::np(), indicating how/if each parameter is to be scaled.

property reinitialization_state_idxs_presim: Indices of states to be reinitialized based on provided presimulation constants / fixed parameters.

property reinitialization_state_idxs_sim: Indices of states to be reinitialized based on provided constants / fixed parameters.

property reinitialize_fixed_parameter_initial_states: Flag indicating whether reinitialization of states depending on fixed parameters is activated

property sx0

Initial state sensitivities

Dimensions: Model::nx() * Model::nplist(), Model::nx() * ExpData::plist.size(), if ExpData::plist is not empty, or empty

property t_presim

Duration of pre-simulation.

If this is > 0, presimulation will be performed from (model->t0 - t_presim) to model->t0 using the fixedParameters in fixedParametersPresimulation

property t_start

Starting time of the simulation.

Output timepoints are absolute timepoints, independent of \(t_{start}\). For output timepoints \(t < t_{start}\), the initial state will be returned.

property t_start_preeq

The initial time for pre-equilibration..

NAN indicates that tstart_ should be used.

property timepoints

Timepoints for which model state/outputs/… are requested

Vector of timepoints.

property x0

Initial state

Vector of size Model::nx() or empty

class amici.amici.ExpDataPtrVector(*args)[source]: Swig-Generated class templating common python types including Iterable [amici.amici.ExpData] and numpy.array [amici.amici.ExpData] to facilitate interfacing with C++ bindings.

class amici.amici.FixedParameterContext(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

preequilibration = 1

presimulation = 2

simulation = 0

class amici.amici.IntVector(*args)[source]: Swig-Generated class templating common python types including Iterable [int] and numpy.array [int] to facilitate interfacing with C++ bindings.

class amici.amici.InternalSensitivityMethod(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

simultaneous = 1

staggered = 2

staggered1 = 3

class amici.amici.InterpolationType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

hermite = 1

polynomial = 2

class amici.amici.LinearMultistepMethod(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

BDF = 2

__init__(*args, **kwds)

adams = 1

class amici.amici.LinearSolver(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

KLU = 9

LAPACKBand = 4

LAPACKDense = 3

SPBCG = 7

SPGMR = 6

SPTFQMR = 8

SuperLUMT = 10

__init__(*args, **kwds)

band = 2

dense = 1

diag = 5

class amici.amici.LogItem(*args)[source]

A log item.

__init__(*args)[source]

Overload 1:

Default ctor.

Overload 2:

Construct a LogItem

Parameters:

severity (int)
identifier (str)
message (str)

property identifier: Short identifier for the logged event

property message: A more detailed and readable message

property severity: Severity level

class amici.amici.LogItemVector(*args)[source]

class amici.amici.LogSeverity(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

debug = 2

error = 0

warning = 1

class amici.amici.Model(*args, **kwargs)[source]

The Model class represents an AMICI ODE/DAE model.

The model can compute various model related quantities based on symbolically generated code.

__init__(*args, **kwargs)[source]

clone()[source]: Clone the model instance.

create_solver() → Solver

Creates a solver instance to simulate this model.

Return type:: amici.amici.Solver
Returns:: The Solver instance

get_add_sigma_residuals() → bool[source]

Checks whether residuals should be added to account for parameter dependent sigma.

Return type:: bool
Returns:: sigma_res

get_always_check_finite() → bool[source]

Get setting of whether the result of every call to Model::f* should be checked for finiteness.

Return type:: bool
Returns:: that

get_amici_commit() → str

Returns the AMICI commit that was used to generate the model

Return type:: str
Returns:: AMICI commit string

get_amici_version() → str

Returns the AMICI version that was used to generate the model

Return type:: str
Returns:: AMICI version string

get_any_state_nonnegative() → bool[source]

Whether there is at least one state variable for which non-negativity is to be enforced.

Return type:: bool
Returns:: Vector of all events.

get_expression_ids() → Sequence[str][source]

Get IDs of the expression.

Return type:: collections.abc.Sequence[str]
Returns:: Expression IDs

get_expression_names() → Sequence[str][source]

Get names of the expressions.

Return type:: collections.abc.Sequence[str]
Returns:: Expression names

get_fixed_parameter_by_id(par_id: str) → float[source]

Get value of fixed parameter with the specified ID.

Parameters:: par_id (str) – Parameter ID
Return type:: float
Returns:: Parameter value

get_fixed_parameter_by_name(par_name: str) → float[source]

Get value of fixed parameter with the specified name.

If multiple parameters have the same name, the first parameter with matching name is returned.

Parameters:: par_name (str) – Parameter name
Return type:: float
Returns:: Parameter value

get_fixed_parameter_ids() → Sequence[str][source]

Get IDs of the fixed model parameters.

Return type:: collections.abc.Sequence[str]
Returns:: Fixed parameter IDs

get_fixed_parameter_names() → Sequence[str][source]

Get names of the fixed model parameters.

Return type:: collections.abc.Sequence[str]
Returns:: Fixed parameter names

get_fixed_parameters() → Sequence[float][source]

Get values of fixed parameters.

Return type:: collections.abc.Sequence[float]
Returns:: Vector of fixed parameters with same ordering as in Model::getFixedParameterIds

get_id_list() → Sequence[float][source]

Get flag array for DAE equations

Return type:: collections.abc.Sequence[float]
Returns:: Flag array for DAE equations

get_initial_state(*args)[source]

Overload 1:

Get the initial state.

Parameters:: t0 (float) – Custom t0 for which to get initial states.
Return type:: DoubleVector
Returns:: Initial state vector, before any events are executed.

Overload 2:

Get the initial state for Model::t0()`.

Return type:: DoubleVector
Returns:: Initial state vector, before any events are executed.

get_initial_state_sensitivities(*args)[source]

Overload 1:

Get the initial state sensitivities.

Return type:: DoubleVector
Returns:: vector of initial state sensitivities

Overload 2:

Get the initial states sensitivities.

Parameters:: t0 (float) – Custom t0 for which to get initial states.
Return type:: DoubleVector
Returns:: vector of initial state sensitivities

get_minimum_sigma_residuals() → float[source]

Gets the specified estimated lower boundary for sigma_y.

Return type:: float
Returns:: lower boundary

get_name() → str[source]

Get the model name.

Return type:: str
Returns:: Model name

get_observable_ids() → Sequence[str][source]

Get IDs of the observables.

Return type:: collections.abc.Sequence[str]
Returns:: Observable IDs

get_observable_names() → Sequence[str][source]

Get names of the observables.

Return type:: collections.abc.Sequence[str]
Returns:: Observable names

get_observable_scaling(iy: int) → int[source]

Get scaling type for observable

Parameters:: iy (int) – observable index
Return type:: int
Returns:: scaling type

get_parameter_by_id(par_id: str) → float[source]

Get value of first model parameter with the specified ID.

Parameters:: par_id (str) – Parameter ID
Return type:: float
Returns:: Parameter value

get_parameter_by_name(par_name: str) → float[source]

Get value of first model parameter with the specified name.

Parameters:: par_name (str) – Parameter name
Return type:: float
Returns:: Parameter value

get_parameter_ids() → Sequence[str][source]

Get IDs of the model parameters.

Return type:: collections.abc.Sequence[str]
Returns:: Parameter IDs

get_parameter_list() → Sequence[int][source]

Get the list of parameters for which sensitivities are computed.

Return type:: collections.abc.Sequence[int]
Returns:: List of parameter indices

get_parameter_names() → Sequence[str][source]

Get names of the model parameters.

Return type:: collections.abc.Sequence[str]
Returns:: The parameter names

get_parameter_scale() → ParameterScalingVector[source]

Get parameter scale for each parameter.

Return type:: amici.amici.ParameterScalingVector
Returns:: Vector of parameter scales

get_parameters() → Sequence[float][source]

Get parameter vector.

Return type:: collections.abc.Sequence[float]
Returns:: The user-set parameters (see also Model::getUnscaledParameters)

get_reinitialization_state_idxs() → Sequence[int][source]

Return indices of states to be reinitialized based on provided constants / fixed parameters

Return type:: collections.abc.Sequence[int]
Returns:: Those indices.

get_reinitialize_fixed_parameter_initial_states() → bool[source]

Get whether initial states depending on fixedParameters are to be reinitialized after preequilibration and presimulation.

Return type:: bool
Returns:: flag true / false

get_second_order_mode() → int[source]

Get second-order sensitivity mode.

Return type:: int
Returns:: Flag indicating whether for SensitivityOrder::second directional or full second order derivative will be computed

get_state_ids() → Sequence[str][source]

Get IDs of the model states.

Return type:: collections.abc.Sequence[str]
Returns:: State IDs

get_state_ids_solver() → Sequence[str][source]

Get IDs of the solver states.

Return type:: collections.abc.Sequence[str]
Returns:: State IDs

get_state_is_non_negative() → Sequence[bool][source]

Get flags indicating whether states should be treated as non-negative.

Return type:: collections.abc.Sequence[bool]
Returns:: Vector of flags

get_state_names() → Sequence[str][source]

Get names of the model states.

Return type:: collections.abc.Sequence[str]
Returns:: State names

get_state_names_solver() → Sequence[str][source]

Get names of the solver states.

Return type:: collections.abc.Sequence[str]
Returns:: State names

get_steady_state_computation_mode() → int[source]

Gets the mode how steady state is computed in the steadystate simulation.

Return type:: int
Returns:: Mode

get_steady_state_sensitivity_mode() → SteadyStateSensitivityMode[source]

Gets the mode how sensitivities are computed in the steady-state simulation.

Return type:: amici.amici.SteadyStateSensitivityMode
Returns:: Mode

get_steadystate_mask() → Sequence[float][source]

Get steady-state mask as std::vector.

See set_steadystate_mask for details.

Return type:: collections.abc.Sequence[float]
Returns:: Steady-state mask

get_timepoint(it: int) → float[source]

Get simulation timepoint for time index it.

Parameters:: it (int) – Time index
Return type:: float
Returns:: Timepoint

get_timepoints() → Sequence[float][source]

Get the timepoint vector.

Return type:: collections.abc.Sequence[float]
Returns:: Timepoint vector

get_trigger_timepoints() → Sequence[float][source]

Get trigger times for events that don’t require root-finding.

To be called only after Model::initialize.

Return type:: collections.abc.Sequence[float]
Returns:: List of unique trigger points for events that don’t require root-finding (i.e. that trigger at predetermined timepoints), in ascending order.

get_unscaled_parameters() → Sequence[float][source]

Get parameters with transformation according to parameter scale applied.

Return type:: collections.abc.Sequence[float]
Returns:: Unscaled parameters

has_custom_initial_state() → bool[source]

Return whether custom initial state have been set.

Return type:: bool
Returns:: true if has custom initial state, otherwise false

has_custom_initial_state_sensitivities() → bool[source]

Return whether custom initial state sensitivities have been set.

Return type:: bool
Returns:: true if has custom initial state sensitivities, otherwise false.

has_expression_ids() → bool[source]

Report whether the model has expression IDs set.

Return type:: bool
Returns:: Boolean indicating whether expression ids were set. Also returns true if the number of corresponding variables is just zero.

has_expression_names() → bool[source]

Report whether the model has expression names set.

Return type:: bool
Returns:: Boolean indicating whether expression names were set. Also returns true if the number of corresponding variables is just zero.

has_fixed_parameter_ids() → bool[source]

Report whether the model has fixed parameter IDs set.

Return type:: bool
Returns:: Boolean indicating whether fixed parameter IDs were set. Also returns true if the number of corresponding variables is just zero.

has_fixed_parameter_names() → bool[source]

Report whether the model has fixed parameter names set.

Return type:: bool
Returns:: Boolean indicating whether fixed parameter names were set. Also returns true if the number of corresponding variables is just zero.

has_observable_ids() → bool[source]

Report whether the model has observable IDs set.

Return type:: bool
Returns:: Boolean indicating whether observable ids were set. Also returns true if the number of corresponding variables is just zero.

has_observable_names() → bool[source]

Report whether the model has observable names set.

Return type:: bool
Returns:: Boolean indicating whether observable names were set. Also returns true if the number of corresponding variables is just zero.

has_parameter_ids() → bool[source]

Report whether the model has parameter IDs set.

Return type:: bool
Returns:: Boolean indicating whether parameter IDs were set. Also returns true if the number of corresponding variables is just zero.

has_parameter_names() → bool[source]

Report whether the model has parameter names set.

Return type:: bool
Returns:: Boolean indicating whether parameter names were set. Also returns true if the number of corresponding variables is just zero.

has_quadratic_llh() → bool[source]

Checks whether the defined noise model is Gaussian, i.e., the nllh is quadratic

Return type:: bool
Returns:: boolean flag

has_state_ids() → bool[source]

Report whether the model has state IDs set.

Return type:: bool
Returns:: Boolean indicating whether state IDs were set. Also returns true if the number of corresponding variables is just zero.

has_state_names() → bool[source]

Report whether the model has state names set.

Return type:: bool
Returns:: Boolean indicating whether state names were set. Also returns true if the number of corresponding variables is just zero.

is_fixed_parameter_state_reinitialization_allowed() → bool

Function indicating whether reinitialization of states depending on fixed parameters is permissible

Return type:: bool
Returns:: flag indicating whether reinitialization of states depending on fixed parameters is permissible

k() → float[source]

Get fixed parameters.

Return type:: float
Returns:: Pointer to constants array

property lbw: Lower bandwidth of the Jacobian

property nJ: Dimension of the augmented objective function for 2nd order ASA

n_max_event() → int[source]

Get maximum number of events that may occur for each type.

Return type:: int
Returns:: Maximum number of events that may occur for each type

ncl() → int[source]

Get number of conservation laws.

Return type:: int
Returns:: Number of conservation laws (i.e., difference between nx_rdata and nx_solver).

property ndJydy: Number of nonzero elements in the \(y\) derivative of \(dJy\) (dimension nytrue)

property ndtotal_cldx_rdata: Number of nonzero elements in the \(x_rdata\) derivative of \(total_cl\)

property ndwdp: Number of nonzero elements in the p derivative of the repeating elements

property ndwdw: Number of nonzero elements in the w derivative of the repeating elements

property ndwdx: Number of nonzero elements in the x derivative of the repeating elements

property ndxdotdp_explicit: Number of nonzero elements in dxdotdp_explicit

property ndxdotdw: Number of nonzero elements in the \(w\) derivative of \(xdot\)

property ndxdotdx_explicit: Number of nonzero elements in dxdotdx_explicit

property ndxrdatadtcl: Number of nonzero elements in the \(tcl\) derivative of \(x_rdata\)

property ndxrdatadxsolver: Number of nonzero elements in the \(x\) derivative of \(x_rdata\)

property ne: Number of events

property ne_solver: Number of events that require root-finding

nk() → int[source]

Get number of constants

Return type:: int
Returns:: Length of constant vector

property nnz: Number of nonzero entries in Jacobian

np() → int[source]

Get total number of model parameters.

Return type:: int
Returns:: Length of parameter vector

nplist() → int[source]

Get number of parameters wrt to which sensitivities are computed.

Return type:: int
Returns:: Length of sensitivity index vector

property nspl: Number of spline functions in the model

nt() → int[source]

Get number of timepoints.

Return type:: int
Returns:: Number of timepoints

property nw: Number of common expressions

property nx_rdata: Number of state variables

nx_reinit() → int[source]

Get number of solver states subject to reinitialization.

Return type:: int
Returns:: Model member nx_solver_reinit

property nx_solver: Number of state variables with conservation laws applied

property nx_solver_reinit: Number of solver state variables subject to reinitialization

property nxtrue_rdata: Number of state variables in the unaugmented system

property nxtrue_solver: Number of state variables in the unaugmented system with conservation laws applied

property ny: Number of observables

property nytrue: Number of observables in the unaugmented system

property nz: Number of event outputs

property nztrue: Number of event outputs in the unaugmented system

plist(pos: int) → int[source]

Get entry in parameter list by index.

Parameters:: pos (int) – Index in sensitivity parameter list
Return type:: int
Returns:: Index in parameter list

require_sensitivities_for_all_parameters()[source]

Require computation of sensitivities for all parameters p [0..np[ in natural order.

NOTE: Resets initial state sensitivities.

set_add_sigma_residuals(sigma_res: bool)[source]

Specifies whether residuals should be added to account for parameter dependent sigma.

If set to true, additional residuals of the form \(\sqrt{\log(\sigma) +C}\) will be added. This enables least-squares optimization for variables with Gaussian noise assumption and parameter dependent standard deviation sigma. The constant \(C\) can be set via setMinimumSigmaResiduals().

Parameters:: sigma_res (bool) – if true, additional residuals are added

set_all_states_non_negative()[source]: Set flags indicating that all states should be treated as non-negative.

set_always_check_finite(alwaysCheck: bool)[source]

Set whether the result of every call to Model::f* should be checked for finiteness.

Parameters:: alwaysCheck (bool)

set_fixed_parameter_by_id(par_id: str, value: float)[source]

Set value of first fixed parameter with the specified ID.

Parameters:

par_id (str) – Fixed parameter id
value (float) – Fixed parameter value

set_fixed_parameter_by_name(par_name: str, value: float)[source]

Set value of first fixed parameter with the specified name.

Parameters:

par_name (str) – Fixed parameter ID
value (float) – Fixed parameter value

set_fixed_parameters(k: Sequence[float])[source]

Set values for constants.

Parameters:: k (collections.abc.Sequence[float]) – Vector of fixed parameters

set_fixed_parameters_by_id_regex(par_id_regex: str, value: float) → int[source]

Set values of all fixed parameters with the ID matching the specified regex.

Parameters:

par_id_regex (str) – Fixed parameter name regex
value (float) – Fixed parameter value

Return type:

int

Returns:

Number of fixed parameter IDs that matched the regex

set_fixed_parameters_by_name_regex(par_name_regex: str, value: float) → int[source]

Set value of all fixed parameters with name matching the specified regex.

Parameters:

par_name_regex (str) – Fixed parameter name regex
value (float) – Fixed parameter value

Return type:

int

Returns:

Number of fixed parameter names that matched the regex

set_initial_state(x0: Sequence[float])[source]

Set the pre-event initial state.

Parameters:: x0 (collections.abc.Sequence[float]) – Initial state vector

set_initial_state_sensitivities(sx0: Sequence[float])[source]

Set the initial state sensitivities.

Parameters:: sx0 (collections.abc.Sequence[float]) – vector of initial state sensitivities with chain rule applied. This could be a slice of ReturnData::sx or ReturnData::sx0

set_minimum_sigma_residuals(min_sigma: float)[source]

Sets the estimated lower boundary for sigma_y. When setAddSigmaResiduals() is activated, this lower boundary must ensure that log(sigma) + min_sigma > 0.

Parameters:: min_sigma (float) – lower boundary

set_n_max_event(nmaxevent: int)[source]

Set maximum number of events that may occur for each type.

Parameters:: nmaxevent (int) – Maximum number of events that may occur for each type

set_parameter_by_id(*args)[source]

Overload 1:

Set model parameters according to the parameter IDs and mapped values.

Parameters:

p (StringDoubleMap) – Map of parameters IDs and values
ignoreErrors (boolean, optional) – Ignore errors such as parameter IDs in p which are not model parameters

Overload 2:

Set value of first model parameter with the specified ID.

Parameters:

par_id (str) – Parameter ID
value (float) – Parameter value

set_parameter_by_name(*args)[source]

Overload 1:

Set value of first model parameter with the specified name.

Parameters:

par_name (str) – Parameter name
value (float) – Parameter value

Overload 2:

Set model parameters according to the parameter name and mapped values.

Parameters:

p (StringDoubleMap) – Map of parameters names and values
ignoreErrors (boolean, optional) – Ignore errors such as parameter names in p which are not model parameters

Overload 3:

Set model parameters according to the parameter name and mapped values.

Parameters:

p (StringDoubleMap) – Map of parameters names and values
ignoreErrors – Ignore errors such as parameter names in p which are not model parameters

set_parameter_list(plist: Sequence[int])[source]

Set the list of parameters for which sensitivities are to be computed.

NOTE: Resets initial state sensitivities.

Parameters:: plist (collections.abc.Sequence[int]) – List of parameter indices

set_parameter_scale(*args)[source]

Overload 1:

Set parameter scale for each parameter.

NOTE: Resets initial state sensitivities.

Parameters:: pscale (int) – Scalar parameter scale to be set for all parameters

Overload 2:

Set parameter scale for each parameter.

NOTE: Resets initial state sensitivities.

Parameters:: pscaleVec (ParameterScalingVector) – Vector of parameter scales

set_parameters(p: Sequence[float])[source]

Set the parameter vector.

Parameters:: p (collections.abc.Sequence[float]) – Vector of parameters

set_parameters_by_id_regex(par_id_regex: str, value: float) → int[source]

Set all values of model parameters with IDs matching the specified regular expression.

Parameters:

par_id_regex (str) – Parameter ID regex
value (float) – Parameter value

Return type:

int

Returns:

Number of parameter IDs that matched the regex

set_parameters_by_name_regex(par_name_regex: str, value: float) → int[source]

Set all values of all model parameters with names matching the specified regex.

Parameters:

par_name_regex (str) – Parameter name regex
value (float) – Parameter value

Return type:

int

Returns:

Number of fixed parameter names that matched the regex

set_reinitialization_state_idxs(idxs: Sequence[int])[source]

Set indices of states to be reinitialized based on provided constants / fixed parameters

Parameters:: idxs (collections.abc.Sequence[int]) – Array of state indices

set_reinitialize_fixed_parameter_initial_states(flag: bool)[source]

Set whether initial states depending on fixed parameters are to be reinitialized after preequilibration and presimulation.

Parameters:: flag (bool) – Fixed parameters reinitialized?

set_state_is_non_negative(stateIsNonNegative: Sequence[bool])[source]

Set flags indicating whether states should be treated as non-negative.

Parameters:: stateIsNonNegative (collections.abc.Sequence[bool]) – Vector of flags

set_steady_state_computation_mode(mode: int)[source]

Set the mode how steady state is computed in the steady state simulation.

Parameters:: mode (int) – Steady state computation mode

set_steady_state_sensitivity_mode(mode: SteadyStateSensitivityMode)[source]

Set the mode how sensitivities are computed in the steady-state simulation.

Parameters:: mode (amici.amici.SteadyStateSensitivityMode) – Steady-state sensitivity mode

set_steadystate_mask(mask: Sequence[float])[source]

Set steady-state mask.

The mask is used to exclude certain state variables from the steady-state convergence check. Positive values indicate that the corresponding state variable should be included in the convergence check, while non-positive values indicate that the corresponding state variable should be excluded. An empty mask is interpreted as including all state variables.

Parameters:: mask (collections.abc.Sequence[float]) – Mask of length nx_solver.

set_t0(t0: float)[source]

Set simulation start time.

Output timepoints are absolute timepoints, independent of \(t_{0}\). For output timepoints \(t < t_{0}\), the initial state will be returned.

Parameters:: t0 (float) – Simulation start time

set_t0_preeq(t0_preeq: float)[source]

Set the initial time to use for pre-equilibration.

Parameters:: t0_preeq (float) – The initial time for pre-equilibration or NAN to use the model’s t0.

set_timepoints(ts: Sequence[float])[source]

Set the timepoint vector.

Parameters:: ts (collections.abc.Sequence[float]) – New timepoint vector

set_unscaled_initial_state_sensitivities(sx0: Sequence[float])[source]

Set the initial state sensitivities.

Parameters:: sx0 (collections.abc.Sequence[float]) – Vector of initial state sensitivities without chain rule applied. This could be the read-in from a model.sx0data saved to HDF5.

Simulate model with given solver and experimental data.

Parameters:

solver (amici.amici.Solver | None) – Solver to use for simulation. Defaults to Model.get_solver().
edata (typing.Union[amici.amici.ExpData, amici.amici.ExpDataPtr, amici.amici.ExpDataPtrVector, collections.abc.Sequence[typing.Union[amici.amici.ExpData, amici.amici.ExpDataPtr]], None]) – Experimental data to use for simulation. A single ExpData instance or a sequence of such instances. If None, no experimental data is used and the model is simulated as is.
sensi_method (amici.amici.SensitivityMethod | str) – Sensitivity method to use for simulation. If None, the solver’s current sensitivity method is used.
sensi_order (amici.amici.SensitivityOrder | str) – Sensitivity order to use for simulation. If None, the solvers’s current sensitivity order is used.
failfast (bool) – Whether to stop simulations on first failure. Only relevant if edata is a sequence of ExpData instances.
num_threads (int) – Number of threads to use for simulation. Only relevant if AMICI was compiled with OpenMP support and if edata is a sequence of ExpData instances.

Return type:

amici.numpy.ReturnDataView | list[amici.numpy.ReturnDataView]

Returns:

A single ReturnDataView instance containing the simulation results if edata is a single ExpData instance or None. If edata is a sequence of ExpData instances, a list of ReturnDataView instances is returned.

t0() → float[source]

Get simulation start time.

Return type:: float
Returns:: Simulation start time

t0_preeq() → float[source]

Get the initial time to use for pre-equilibration.

Return type:: float
Returns:: Initial time, or NAN to use the model’s t0.

property ubw: Upper bandwidth of the Jacobian

validate(): Validate dimensions.

property w_recursion_depth: Recursion depth of fw

class amici.amici.ModelDimensions[source]

Container for model dimensions.

Holds number of state variables, observables, etc.

__init__()[source]

property lbw: Lower bandwidth of the Jacobian

property nJ: Dimension of the augmented objective function for 2nd order ASA

property ndJydy: Number of nonzero elements in the \(y\) derivative of \(dJy\) (dimension nytrue)

property ndtotal_cldx_rdata: Number of nonzero elements in the \(x_rdata\) derivative of \(total_cl\)

property ndwdp: Number of nonzero elements in the p derivative of the repeating elements

property ndwdw: Number of nonzero elements in the w derivative of the repeating elements

property ndwdx: Number of nonzero elements in the x derivative of the repeating elements

property ndxdotdp_explicit: Number of nonzero elements in dxdotdp_explicit

property ndxdotdw: Number of nonzero elements in the \(w\) derivative of \(xdot\)

property ndxdotdx_explicit: Number of nonzero elements in dxdotdx_explicit

property ndxrdatadtcl: Number of nonzero elements in the \(tcl\) derivative of \(x_rdata\)

property ndxrdatadxsolver: Number of nonzero elements in the \(x\) derivative of \(x_rdata\)

property ne: Number of events

property ne_solver: Number of events that require root-finding

property nk: Number of constants

property nnz: Number of nonzero entries in Jacobian

property np: Number of parameters

property nspl: Number of spline functions in the model

property nw: Number of common expressions

property nx_rdata: Number of state variables

property nx_solver: Number of state variables with conservation laws applied

property nx_solver_reinit: Number of solver state variables subject to reinitialization

property nxtrue_rdata: Number of state variables in the unaugmented system

property nxtrue_solver: Number of state variables in the unaugmented system with conservation laws applied

property ny: Number of observables

property nytrue: Number of observables in the unaugmented system

property nz: Number of event outputs

property nztrue: Number of event outputs in the unaugmented system

property ubw: Upper bandwidth of the Jacobian

validate()[source]: Validate dimensions.

property w_recursion_depth: Recursion depth of fw

class amici.amici.ModelPtr(*args)[source]

Swig-Generated class that implements smart pointers to Model as objects.

property lbw: Lower bandwidth of the Jacobian

property nJ: Dimension of the augmented objective function for 2nd order ASA

property ndJydy: Number of nonzero elements in the \(y\) derivative of \(dJy\) (dimension nytrue)

property ndtotal_cldx_rdata: Number of nonzero elements in the \(x_rdata\) derivative of \(total_cl\)

property ndwdp: Number of nonzero elements in the p derivative of the repeating elements

property ndwdw: Number of nonzero elements in the w derivative of the repeating elements

property ndwdx: Number of nonzero elements in the x derivative of the repeating elements

property ndxdotdp_explicit: Number of nonzero elements in dxdotdp_explicit

property ndxdotdw: Number of nonzero elements in the \(w\) derivative of \(xdot\)

property ndxdotdx_explicit: Number of nonzero elements in dxdotdx_explicit

property ndxrdatadtcl: Number of nonzero elements in the \(tcl\) derivative of \(x_rdata\)

property ndxrdatadxsolver: Number of nonzero elements in the \(x\) derivative of \(x_rdata\)

property ne: Number of events

property ne_solver: Number of events that require root-finding

property nnz: Number of nonzero entries in Jacobian

property nspl: Number of spline functions in the model

property nw: Number of common expressions

property nx_rdata: Number of state variables

property nx_solver: Number of state variables with conservation laws applied

property nx_solver_reinit: Number of solver state variables subject to reinitialization

property nxtrue_rdata: Number of state variables in the unaugmented system

property nxtrue_solver: Number of state variables in the unaugmented system with conservation laws applied

property ny: Number of observables

property nytrue: Number of observables in the unaugmented system

property nz: Number of event outputs

property nztrue: Number of event outputs in the unaugmented system

property ubw: Upper bandwidth of the Jacobian

property w_recursion_depth: Recursion depth of fw

class amici.amici.NewtonDampingFactorMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

off = 0

on = 1

class amici.amici.NonlinearSolverIteration(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

fixedpoint = 1

newton = 2

class amici.amici.ObservableScaling(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

lin = 0

log = 1

log10 = 2

class amici.amici.ParameterScaling(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

ln = 1

log10 = 2

none = 0

class amici.amici.ParameterScalingVector(*args)[source]

class amici.amici.RDataReporting(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

full = 0

likelihood = 2

observables_likelihood = 3

residuals = 1

class amici.amici.ReturnData(*args)[source]

Stores all data to be returned by amici.amici.runAmiciSimulation().

NOTE: multi-dimensional arrays are stored in row-major order (C-style)

property FIM: Fisher information matrix (shape nplist x nplist, row-major)

property J

Jacobian of differential equation right hand side.

The Jacobian of differential equation right hand side (shape nx_solver x nx_solver, row-major) evaluated at t_last.

The corresponding state variable IDs can be obtained from Model::getStateIdsSolver().

__init__(*args)[source]

Overload 1:

Default constructor

Overload 2:

Constructor

Parameters:

ts (DoubleVector) – see amici::SimulationParameters::ts
model_dimensions (ModelDimensions) – Model dimensions
nmaxevent (int) – see amici::ModelDimensions::nmaxevent
newton_maxsteps (int) – see amici::Solver::newton_maxsteps
plist (IntVector) – see amici::Model::getParameterList
pscale (ParameterScalingVector) – see amici::SimulationParameters::pscale
o2mode (int) – see amici::SimulationParameters::o2mode
sensi (SensitivityOrder) – see amici::Solver::sensi
sensi_meth (SensitivityMethod) – see amici::Solver::sensi_meth
rdrm (RDataReporting) – see amici::Solver::rdata_reporting
quadratic_llh (boolean) – whether model defines a quadratic nllh and computing res, sres and FIM makes sense
sigma_res (boolean) – indicates whether additional residuals are to be added for each sigma
sigma_offset (float) – offset to ensure real-valuedness of sigma residuals

Overload 3:

constructor that uses information from model and solver to appropriately initialize fields

Parameters:

solver (Solver) – solver instance
model (Model) – model instance

property chi2: \(\chi^2\) value

property cpu_time: Computation time of forward solve [ms]

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property cpu_time_b: Computation time of backward solve [ms]

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property cpu_time_total: Total CPU time from entering runAmiciSimulation until exiting [ms]

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property id: Arbitrary (not necessarily unique) identifier.

property lbw: Lower bandwidth of the Jacobian

property llh: Log-likelihood value

property messages: Log messages.

property nJ: Dimension of the augmented objective function for 2nd order ASA

property ndJydy: Number of nonzero elements in the \(y\) derivative of \(dJy\) (dimension nytrue)

property ndtotal_cldx_rdata: Number of nonzero elements in the \(x_rdata\) derivative of \(total_cl\)

property ndwdp: Number of nonzero elements in the p derivative of the repeating elements

property ndwdw: Number of nonzero elements in the w derivative of the repeating elements

property ndwdx: Number of nonzero elements in the x derivative of the repeating elements

property ndxdotdp_explicit: Number of nonzero elements in dxdotdp_explicit

property ndxdotdw: Number of nonzero elements in the \(w\) derivative of \(xdot\)

property ndxdotdx_explicit: Number of nonzero elements in dxdotdx_explicit

property ndxrdatadtcl: Number of nonzero elements in the \(tcl\) derivative of \(x_rdata\)

property ndxrdatadxsolver: Number of nonzero elements in the \(x\) derivative of \(x_rdata\)

property ne: Number of events

property ne_solver: Number of events that require root-finding

property newton_maxsteps: maximal number of newton iterations for steady state calculation

property nk: Number of constants

property nmaxevent: Maximal number of occurring events (for every event type)

property nnz: Number of nonzero entries in Jacobian

property np: Number of parameters

property nplist: Number of parameters w.r.t. which sensitivities were requested

property nspl: Number of spline functions in the model

property nt: Number of output timepoints (length of ReturnData::ts).

property num_err_test_fails: Number of error test failures forward problem (shape nt)

property num_err_test_fails_b: Number of error test failures backward problem (shape nt)

property num_non_lin_solv_conv_fails: Number of linear solver convergence failures forward problem (shape nt)

property num_non_lin_solv_conv_fails_b: Number of linear solver convergence failures backward problem (shape nt)

property num_rhs_evals: Number of right hand side evaluations forward problem (shape nt)

property num_rhs_evals_b: Number of right hand side evaluations backward problem (shape nt)

property numsteps

Number of solver steps for the forward problem.

Cumulative number of integration steps for the forward problem for each output timepoint in ReturnData::ts (shape nt).

property numsteps_b

Number of solver steps for the backward problem.

Cumulative number of integration steps for the backward problem for each output timepoint in ReturnData::ts (shape nt).

property nw: Number of common expressions

property nx_rdata: Number of state variables

property nx_solver: Number of state variables with conservation laws applied

property nx_solver_reinit: Number of solver state variables subject to reinitialization

property nxtrue_rdata: Number of state variables in the unaugmented system

property nxtrue_solver: Number of state variables in the unaugmented system with conservation laws applied

property ny: Number of observables

property nytrue: Number of observables in the unaugmented system

property nz: Number of event outputs

property nztrue: Number of event outputs in the unaugmented system

property o2mode: Flag indicating whether second-order sensitivities were requested.

property order: Employed order forward problem (shape nt)

property plist

Indices of the parameters w.r.t. which sensitivities were computed.

The indices refer to parameter IDs in Model::getParameterIds().

property posteq_cpu_time: Computation time of the steady-state solver [ms] (postequilibration)

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property posteq_cpu_time_b: Computation time of the steady-state solver of the backward problem [ms] (postequilibration)

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property posteq_numsteps: Number of Newton steps for post-equilibration [newton, simulation, newton].

property posteq_numsteps_b: Number of simulation steps for the post-equilibration backward simulation [== 0 if analytical solution worked, > 0 otherwise]

property posteq_status: Flags indicating success of steady-state solver (postequilibration)

property posteq_t: Model time at which the post-equilibration steady state was reached via simulation.

property posteq_wrms: Weighted root-mean-square of the rhs at post-equilibration steady state.

property preeq_cpu_time: Computation time of the steady state solver [ms] (pre-equilibration)

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property preeq_cpu_time_b: Computation time of the steady state solver of the backward problem [ms] (pre-equilibration)

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property preeq_numsteps

Number of Newton steps for pre-equilibration.

[newton, simulation, newton] (length = 3)

property preeq_numsteps_b: Number of simulation steps for adjoint pre-equilibration problem [== 0 if analytical solution worked, > 0 otherwise]

property preeq_status: Flags indicating success of steady-state solver (preequilibration)

property preeq_t: Model time at which the pre-equilibration steady state was reached via simulation.

property preeq_wrms: Weighted root-mean-square of the rhs at pre-equilibration steady state.

property pscale: Scaling of model parameters.

property rdata_reporting: Reporting mode.

property res: Residuals (shape nt*ny, row-major)

property rz: Event trigger output (shape nmaxevent x nz, row-major)

property s2llh: Second-order parameter derivative of log-likelihood (shape nJ-1 x nplist, row-major)

property s2rz: Second-order parameter derivative of event trigger output (shape nmaxevent x nztrue x nplist x nplist, row-major)

property sensi: Sensitivity order.

property sensi_meth: Sensitivity method.

property sigma_res: Boolean indicating whether residuals for standard deviations have been added.

property sigmay: Observable standard deviation (shape nt x ny, row-major)

property sigmaz: Event output sigma standard deviation (shape nmaxevent x nz, row-major)

property sllh: Parameter derivative of log-likelihood (shape nplist)

property sres: Parameter derivative of residual (shape nt*ny x nplist, row-major)

property srz: Parameter derivative of event trigger output (shape nmaxevent x nplist x nz, row-major)

property ssigmay: Parameter derivative of observable standard deviation (shape nt x nplist x ny, row-major)

property ssigmaz: Parameter derivative of event output standard deviation (shape nmaxevent x nplist x nz, row-major)

property status

Simulation status code.

One of:

AMICI_SUCCESS, indicating successful simulation
AMICI_MAX_TIME_EXCEEDED, indicating that the simulation did not finish within the allowed time (see Solver.{set,get}MaxTime)
AMICI_ERROR, indicating that some error occurred during simulation (a more detailed error message will have been printed).
AMICI_NOT_RUN, if no simulation was started

property sx

State sensitivities.

The derivative of the model state with respect to the chosen parameters (see Model::getParameterList() or ExpData::plist) at timepoints ReturnData::ts (shape nt x nplist x nx_rdata, row-major).

The corresponding state variable IDs can be obtained from Model::getStateIds().

property sx0

Initial state sensitivities for the main simulation.

(shape nplist x nx_rdata, row-major).

property sx_ss

Pre-equilibration steady state sensitivities.

Sensitivities of the pre-equilibration steady state with respect to the selected parameters. (shape nplist x nx_rdata, row-major)

property sy

Observable sensitivities.

The derivative of the observables with respect to the chosen parameters (see Model::getParameterList() or ExpData::plist) at timepoints ReturnData::ts (shape nt x nplist x ny, row-major).

The corresponding observable IDs can be obtained from Model::getObservableIds().

property sz: Parameter derivative of event output (shape nmaxevent x nplist x nz, row-major)

property t_last: The final internal time of the solver.

property ts: Output or measurement timepoints (shape nt)

property ubw: Upper bandwidth of the Jacobian

validate(): Validate dimensions.

property w

Model expression values.

Values of model expressions (recurring terms in xdot, for imported SBML models from Python, this contains, e.g., the flux vector) at timepoints ReturnData::ts (shape nt x nw, row major).

The corresponding expression IDs can be obtained from Model::getExpressionIds().

property w_recursion_depth: Recursion depth of fw

property x

Model state.

The model state at timepoints ReturnData::ts (shape nt x nx_rdata, row-major).

The corresponding state variable IDs can be obtained from Model::getStateIds().

property x0

Initial state of the main simulation (shape nx_rdata).

The corresponding state variable IDs can be obtained from Model::getStateIds().

property x_ss

Pre-equilibration steady state.

The values of the state variables at the pre-equilibration steady state (shape nx_rdata). The corresponding state variable IDs can be obtained from Model::getStateIds().

property xdot: time derivative (shape nx_solver) evaluated at t_last.

property y

Observables.

The values of the observables at timepoints ReturnData::ts (shape nt x ny, row-major).

The corresponding observable IDs can be obtained from Model::getObservableIds().

property z: Event output (shape nmaxevent x nz, row-major)

class amici.amici.ReturnDataPtr(*args)[source]

Swig-Generated class that implements smart pointers to ReturnData as objects.

property FIM: Fisher information matrix (shape nplist x nplist, row-major)

property J

Jacobian of differential equation right hand side.

The Jacobian of differential equation right hand side (shape nx_solver x nx_solver, row-major) evaluated at t_last.

The corresponding state variable IDs can be obtained from Model::getStateIdsSolver().

property chi2: \(\chi^2\) value

property cpu_time: Computation time of forward solve [ms]

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property cpu_time_b: Computation time of backward solve [ms]

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property cpu_time_total: Total CPU time from entering runAmiciSimulation until exiting [ms]

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property id: Arbitrary (not necessarily unique) identifier.

property lbw: Lower bandwidth of the Jacobian

property llh: Log-likelihood value

property messages: Log messages.

property nJ: Dimension of the augmented objective function for 2nd order ASA

property ndJydy: Number of nonzero elements in the \(y\) derivative of \(dJy\) (dimension nytrue)

property ndtotal_cldx_rdata: Number of nonzero elements in the \(x_rdata\) derivative of \(total_cl\)

property ndwdp: Number of nonzero elements in the p derivative of the repeating elements

property ndwdw: Number of nonzero elements in the w derivative of the repeating elements

property ndwdx: Number of nonzero elements in the x derivative of the repeating elements

property ndxdotdp_explicit: Number of nonzero elements in dxdotdp_explicit

property ndxdotdw: Number of nonzero elements in the \(w\) derivative of \(xdot\)

property ndxdotdx_explicit: Number of nonzero elements in dxdotdx_explicit

property ndxrdatadtcl: Number of nonzero elements in the \(tcl\) derivative of \(x_rdata\)

property ndxrdatadxsolver: Number of nonzero elements in the \(x\) derivative of \(x_rdata\)

property ne: Number of events

property ne_solver: Number of events that require root-finding

property newton_maxsteps: maximal number of newton iterations for steady state calculation

property nk: Number of constants

property nmaxevent: Maximal number of occurring events (for every event type)

property nnz: Number of nonzero entries in Jacobian

property np: Number of parameters

property nplist: Number of parameters w.r.t. which sensitivities were requested

property nspl: Number of spline functions in the model

property nt: Number of output timepoints (length of ReturnData::ts).

property num_err_test_fails: Number of error test failures forward problem (shape nt)

property num_err_test_fails_b: Number of error test failures backward problem (shape nt)

property num_non_lin_solv_conv_fails: Number of linear solver convergence failures forward problem (shape nt)

property num_non_lin_solv_conv_fails_b: Number of linear solver convergence failures backward problem (shape nt)

property num_rhs_evals: Number of right hand side evaluations forward problem (shape nt)

property num_rhs_evals_b: Number of right hand side evaluations backward problem (shape nt)

property numsteps

Number of solver steps for the forward problem.

Cumulative number of integration steps for the forward problem for each output timepoint in ReturnData::ts (shape nt).

property numsteps_b

Number of solver steps for the backward problem.

Cumulative number of integration steps for the backward problem for each output timepoint in ReturnData::ts (shape nt).

property nw: Number of common expressions

property nx_rdata: Number of state variables

property nx_solver: Number of state variables with conservation laws applied

property nx_solver_reinit: Number of solver state variables subject to reinitialization

property nxtrue_rdata: Number of state variables in the unaugmented system

property nxtrue_solver: Number of state variables in the unaugmented system with conservation laws applied

property ny: Number of observables

property nytrue: Number of observables in the unaugmented system

property nz: Number of event outputs

property nztrue: Number of event outputs in the unaugmented system

property o2mode: Flag indicating whether second-order sensitivities were requested.

property order: Employed order forward problem (shape nt)

property plist

Indices of the parameters w.r.t. which sensitivities were computed.

The indices refer to parameter IDs in Model::getParameterIds().

property posteq_cpu_time: Computation time of the steady-state solver [ms] (postequilibration)

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property posteq_cpu_time_b: Computation time of the steady-state solver of the backward problem [ms] (postequilibration)

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property posteq_numsteps: Number of Newton steps for post-equilibration [newton, simulation, newton].

property posteq_numsteps_b: Number of simulation steps for the post-equilibration backward simulation [== 0 if analytical solution worked, > 0 otherwise]

property posteq_status: Flags indicating success of steady-state solver (postequilibration)

property posteq_t: Model time at which the post-equilibration steady state was reached via simulation.

property posteq_wrms: Weighted root-mean-square of the rhs at post-equilibration steady state.

property preeq_cpu_time: Computation time of the steady state solver [ms] (pre-equilibration)

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property preeq_cpu_time_b: Computation time of the steady state solver of the backward problem [ms] (pre-equilibration)

Warning

If AMICI was built without boost, this tracks the CPU-time of the current process. Therefore, in a multi-threaded context, this value may be incorrect.

property preeq_numsteps

Number of Newton steps for pre-equilibration.

[newton, simulation, newton] (length = 3)

property preeq_numsteps_b: Number of simulation steps for adjoint pre-equilibration problem [== 0 if analytical solution worked, > 0 otherwise]

property preeq_status: Flags indicating success of steady-state solver (preequilibration)

property preeq_t: Model time at which the pre-equilibration steady state was reached via simulation.

property preeq_wrms: Weighted root-mean-square of the rhs at pre-equilibration steady state.

property pscale: Scaling of model parameters.

property rdata_reporting: Reporting mode.

property res: Residuals (shape nt*ny, row-major)

property rz: Event trigger output (shape nmaxevent x nz, row-major)

property s2llh: Second-order parameter derivative of log-likelihood (shape nJ-1 x nplist, row-major)

property s2rz: Second-order parameter derivative of event trigger output (shape nmaxevent x nztrue x nplist x nplist, row-major)

property sensi: Sensitivity order.

property sensi_meth: Sensitivity method.

property sigma_res: Boolean indicating whether residuals for standard deviations have been added.

property sigmay: Observable standard deviation (shape nt x ny, row-major)

property sigmaz: Event output sigma standard deviation (shape nmaxevent x nz, row-major)

property sllh: Parameter derivative of log-likelihood (shape nplist)

property sres: Parameter derivative of residual (shape nt*ny x nplist, row-major)

property srz: Parameter derivative of event trigger output (shape nmaxevent x nplist x nz, row-major)

property ssigmay: Parameter derivative of observable standard deviation (shape nt x nplist x ny, row-major)

property ssigmaz: Parameter derivative of event output standard deviation (shape nmaxevent x nplist x nz, row-major)

property status

Simulation status code.

One of:

AMICI_SUCCESS, indicating successful simulation
AMICI_MAX_TIME_EXCEEDED, indicating that the simulation did not finish within the allowed time (see Solver.{set,get}MaxTime)
AMICI_ERROR, indicating that some error occurred during simulation (a more detailed error message will have been printed).
AMICI_NOT_RUN, if no simulation was started

property sx

State sensitivities.

The derivative of the model state with respect to the chosen parameters (see Model::getParameterList() or ExpData::plist) at timepoints ReturnData::ts (shape nt x nplist x nx_rdata, row-major).

The corresponding state variable IDs can be obtained from Model::getStateIds().

property sx0

Initial state sensitivities for the main simulation.

(shape nplist x nx_rdata, row-major).

property sx_ss

Pre-equilibration steady state sensitivities.

Sensitivities of the pre-equilibration steady state with respect to the selected parameters. (shape nplist x nx_rdata, row-major)

property sy

Observable sensitivities.

The derivative of the observables with respect to the chosen parameters (see Model::getParameterList() or ExpData::plist) at timepoints ReturnData::ts (shape nt x nplist x ny, row-major).

The corresponding observable IDs can be obtained from Model::getObservableIds().

property sz: Parameter derivative of event output (shape nmaxevent x nplist x nz, row-major)

property t_last: The final internal time of the solver.

property ts: Output or measurement timepoints (shape nt)

property ubw: Upper bandwidth of the Jacobian

property w

Model expression values.

Values of model expressions (recurring terms in xdot, for imported SBML models from Python, this contains, e.g., the flux vector) at timepoints ReturnData::ts (shape nt x nw, row major).

The corresponding expression IDs can be obtained from Model::getExpressionIds().

property w_recursion_depth: Recursion depth of fw

property x

Model state.

The model state at timepoints ReturnData::ts (shape nt x nx_rdata, row-major).

The corresponding state variable IDs can be obtained from Model::getStateIds().

property x0

Initial state of the main simulation (shape nx_rdata).

The corresponding state variable IDs can be obtained from Model::getStateIds().

property x_ss

Pre-equilibration steady state.

The values of the state variables at the pre-equilibration steady state (shape nx_rdata). The corresponding state variable IDs can be obtained from Model::getStateIds().

property xdot: time derivative (shape nx_solver) evaluated at t_last.

property y

Observables.

The values of the observables at timepoints ReturnData::ts (shape nt x ny, row-major).

The corresponding observable IDs can be obtained from Model::getObservableIds().

property z: Event output (shape nmaxevent x nz, row-major)

class amici.amici.SecondOrderMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

directional = 2

full = 1

none = 0

class amici.amici.SensitivityMethod(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

adjoint = 2

forward = 1

none = 0

amici.amici.SensitivityMethod_adjoint = 2: Adjoint sensitivity analysis.

amici.amici.SensitivityMethod_forward = 1: Forward sensitivity analysis.

amici.amici.SensitivityMethod_none = 0: Don’t compute sensitivities.

class amici.amici.SensitivityOrder(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

first = 1

none = 0

second = 2

amici.amici.SensitivityOrder_first = 1: First-order sensitivities.

amici.amici.SensitivityOrder_none = 0: Don’t compute sensitivities.

amici.amici.SensitivityOrder_second = 2: Second-order sensitivities.

class amici.amici.SimulationParameters(*args)[source]

Container for various simulation parameters.

__init__(*args)[source]

Overload 1:

Constructor

Parameters:: timepoints (DoubleVector) – Timepoints for which simulation results are requested

Overload 2:

Constructor

Parameters:

fixedParameters (DoubleVector) – Model constants
parameters (DoubleVector) – Model parameters

property fixed_parameters

Model constants

Vector of size Model::nk() or empty

property fixed_parameters_pre_equilibration

Model constants for pre-equilibration

Vector of size Model::nk() or empty.

property fixed_parameters_presimulation

Model constants for pre-simulation

Vector of size Model::nk() or empty.

property parameters

Model parameters

Vector of size Model::np() or empty with parameter scaled according to SimulationParameter::pscale.

property plist: Parameter indices w.r.t. which to compute sensitivities

property pscale

Parameter scales

Vector of parameter scale of size Model::np(), indicating how/if each parameter is to be scaled.

property reinitialization_state_idxs_presim: Indices of states to be reinitialized based on provided presimulation constants / fixed parameters.

property reinitialization_state_idxs_sim: Indices of states to be reinitialized based on provided constants / fixed parameters.

reinitialize_all_fixed_parameter_dependent_initial_states(nx_rdata: int)[source]

Set reinitialization of all states based on model constants for all simulation phases.

Convenience function to populate reinitialization_state_idxs_presim and reinitialization_state_idxs_sim

Parameters:: nx_rdata (int) – Number of states (Model::nx_rdata)

reinitialize_all_fixed_parameter_dependent_initial_states_for_presimulation(nx_rdata: int)[source]

Set reinitialization of all states based on model constants for presimulation (only meaningful if preequilibration is performed).

Convenience function to populate reinitialization_state_idxs_presim and reinitialization_state_idxs_sim

Parameters:: nx_rdata (int) – Number of states (Model::nx_rdata)

reinitialize_all_fixed_parameter_dependent_initial_states_for_simulation(nx_rdata: int)[source]

Set reinitialization of all states based on model constants for the ‘main’ simulation (only meaningful if presimulation or preequilibration is performed).

Convenience function to populate reinitialization_state_idxs_presim and reinitialization_state_idxs_sim

Parameters:: nx_rdata (int) – Number of states (Model::nx_rdata)

property reinitialize_fixed_parameter_initial_states: Flag indicating whether reinitialization of states depending on fixed parameters is activated

property sx0

Initial state sensitivities

Dimensions: Model::nx() * Model::nplist(), Model::nx() * ExpData::plist.size(), if ExpData::plist is not empty, or empty

property t_presim

Duration of pre-simulation.

If this is > 0, presimulation will be performed from (model->t0 - t_presim) to model->t0 using the fixedParameters in fixedParametersPresimulation

property t_start

Starting time of the simulation.

Output timepoints are absolute timepoints, independent of \(t_{start}\). For output timepoints \(t < t_{start}\), the initial state will be returned.

property t_start_preeq

The initial time for pre-equilibration..

NAN indicates that tstart_ should be used.

property timepoints

Timepoints for which model state/outputs/… are requested

Vector of timepoints.

property x0

Initial state

Vector of size Model::nx() or empty

class amici.amici.Solver(*args, **kwargs)[source]

The Solver class provides a generic interface to CVODES and IDAS solvers, individual realizations are realized in the CVodeSolver and the IDASolver class. All transient private/protected members (CVODES/IDAS memory, interface variables and status flags) are specified as mutable and not included in serialization or equality checks. No solver setting parameter should be marked mutable.

__init__(*args, **kwargs)[source]

clone() → Solver[source]

Clone this instance

Return type:: amici.amici.Solver
Returns:: The clone

computing_asa() → bool[source]

check if ASA is being computed

Return type:: bool
Returns:: flag

computing_fsa() → bool[source]

check if FSA is being computed

Return type:: bool
Returns:: flag

get_absolute_tolerance() → float[source]

Get the absolute tolerances for the forward problem

Same tolerance is used for the backward problem if not specified differently via setAbsoluteToleranceASA.

Return type:: float
Returns:: absolute tolerances

get_absolute_tolerance_b() → float[source]

Returns the absolute tolerances for the backward problem for adjoint sensitivity analysis

Return type:: float
Returns:: absolute tolerances

get_absolute_tolerance_fsa() → float[source]

Returns the absolute tolerances for the forward sensitivity problem

Return type:: float
Returns:: absolute tolerances

get_absolute_tolerance_quadratures() → float[source]

returns the absolute tolerance for the quadrature problem

Return type:: float
Returns:: absolute tolerance

get_absolute_tolerance_steady_state() → float[source]

returns the absolute tolerance for the steady state problem

Return type:: float
Returns:: absolute tolerance

get_absolute_tolerance_steady_state_sensi() → float[source]

returns the absolute tolerance for the sensitivities of the steady state problem

Return type:: float
Returns:: absolute tolerance

get_class_name() → str[source]

Get the name of this class.

Return type:: str
Returns:: Class name.

get_constraints() → Sequence[float][source]

Get constraints on the model state.

Return type:: collections.abc.Sequence[float]
Returns:: constraints

get_internal_sensitivity_method() → InternalSensitivityMethod[source]

returns the internal sensitivity method

Return type:: amici.amici.InternalSensitivityMethod
Returns:: internal sensitivity method

get_interpolation_type() → InterpolationType[source]

Return type:: amici.amici.InterpolationType
Returns:

get_linear_multistep_method() → LinearMultistepMethod[source]

returns the linear system multistep method

Return type:: amici.amici.LinearMultistepMethod
Returns:: linear system multistep method

get_linear_solver() → LinearSolver[source]

Return type:: amici.amici.LinearSolver
Returns:

get_max_conv_fails() → int[source]

Get the maximum number of nonlinear solver convergence failures permitted per step.

Return type:: int
Returns:: maximum number of nonlinear solver convergence

get_max_nonlin_iters() → int[source]

Get the maximum number of nonlinear solver iterations permitted per step.

Return type:: int
Returns:: maximum number of nonlinear solver iterations

get_max_step_size() → float[source]

Get the maximum step size

Return type:: float
Returns:: maximum step size

get_max_steps() → int[source]

returns the maximum number of solver steps for the forward problem

Return type:: int
Returns:: maximum number of solver steps

get_max_steps_backward_problem() → int[source]

returns the maximum number of solver steps for the backward problem

Return type:: int
Returns:: maximum number of solver steps

get_max_time() → float[source]

Returns the maximum time allowed for integration

Return type:: float
Returns:: Time in seconds

get_newton_damping_factor_lower_bound() → float[source]

Get a lower bound of the damping factor used in the Newton solver

Return type:: float
Returns:

get_newton_damping_factor_mode() → NewtonDampingFactorMode[source]

Get a state of the damping factor used in the Newton solver

Return type:: amici.amici.NewtonDampingFactorMode
Returns:

get_newton_max_steps() → int[source]

Get maximum number of allowed Newton steps for steady state computation

Return type:: int
Returns:

get_newton_step_steady_state_check() → bool[source]

Returns how convergence checks for steadystate computation are performed. If activated, convergence checks are limited to every 25 steps in the simulation solver to limit performance impact.

Return type:: bool
Returns:: boolean flag indicating newton step (true) or the right hand side (false)

get_non_linear_solver_iteration() → NonlinearSolverIteration[source]

returns the nonlinear system solution method

Return type:: amici.amici.NonlinearSolverIteration
Returns:

get_relative_tolerance() → float[source]

Get the relative tolerances for the forward problem

Same tolerance is used for the backward problem if not specified differently via setRelativeToleranceASA.

Return type:: float
Returns:: relative tolerances

get_relative_tolerance_b() → float[source]

Returns the relative tolerances for the adjoint sensitivity problem

Return type:: float
Returns:: relative tolerances

get_relative_tolerance_fsa() → float[source]

Returns the relative tolerances for the forward sensitivity problem

Return type:: float
Returns:: relative tolerances

get_relative_tolerance_quadratures() → float[source]

Returns the relative tolerance for the quadrature problem

Return type:: float
Returns:: relative tolerance

get_relative_tolerance_steady_state() → float[source]

returns the relative tolerance for the steady state problem

Return type:: float
Returns:: relative tolerance

get_relative_tolerance_steady_state_sensi() → float[source]

returns the relative tolerance for the sensitivities of the steady state problem

Return type:: float
Returns:: relative tolerance

get_return_data_reporting_mode() → RDataReporting[source]

returns the ReturnData reporting mode

Return type:: amici.amici.RDataReporting
Returns:: ReturnData reporting mode

get_sensi_steady_state_check() → bool[source]

Returns how convergence checks for steadystate computation are performed.

Return type:: bool
Returns:: boolean flag indicating state and sensitivity equations (true) or only state variables (false).

get_sensitivity_method() → SensitivityMethod[source]

Return current sensitivity method

Return type:: amici.amici.SensitivityMethod
Returns:: method enum

get_sensitivity_method_pre_equilibration() → SensitivityMethod[source]

Return current sensitivity method during preequilibration

Return type:: amici.amici.SensitivityMethod
Returns:: method enum

get_sensitivity_order() → SensitivityOrder[source]

Get sensitivity order

Return type:: amici.amici.SensitivityOrder
Returns:: sensitivity order

get_stability_limit_flag() → bool[source]

returns stability limit detection mode

Return type:: bool
Returns:: stldet can be false (deactivated) or true (activated)

get_state_ordering() → int[source]

Gets KLU / SuperLUMT state ordering mode

Return type:: int
Returns:: State-ordering as integer according to SUNLinSolKLU::StateOrdering or SUNLinSolSuperLUMT::StateOrdering (which differ).

get_steady_state_sensi_tolerance_factor() → float[source]

returns the steady state sensitivity simulation tolerance factor.

Steady state sensitivity simulation tolerances are the product of the sensitivity simulation tolerances and this factor, unless manually set with set(Absolute/Relative)ToleranceSteadyStateSensi().

Return type:: float
Returns:: steady state simulation tolerance factor

get_steady_state_tolerance_factor() → float[source]

returns the steady state simulation tolerance factor.

Steady state simulation tolerances are the product of the simulation tolerances and this factor, unless manually set with set(Absolute/Relative)ToleranceSteadyState().

Return type:: float
Returns:: steady state simulation tolerance factor

get_t() → float[source]

current solver timepoint

Return type:: float
Returns:: t

nplist() → int[source]

number of parameters with which the solver was initialized

Return type:: int
Returns:: sx.getLength()

nquad() → int[source]

number of quadratures with which the solver was initialized

Return type:: int
Returns:: xQB.getLength()

nx() → int[source]

number of states with which the solver was initialized

Return type:: int
Returns:: x.getLength()

set_absolute_tolerance(atol: float)[source]

Sets the absolute tolerances for the forward problem

Same tolerance is used for the backward problem if not specified differently via setAbsoluteToleranceASA.

Parameters:: atol (float) – absolute tolerance (non-negative number)

set_absolute_tolerance_b(atol: float)[source]

Sets the absolute tolerances for the backward problem for adjoint sensitivity analysis

Parameters:: atol (float) – absolute tolerance (non-negative number)

set_absolute_tolerance_fsa(atol: float)[source]

Sets the absolute tolerances for the forward sensitivity problem

Parameters:: atol (float) – absolute tolerance (non-negative number)

set_absolute_tolerance_quadratures(atol: float)[source]

sets the absolute tolerance for the quadrature problem

Parameters:: atol (float) – absolute tolerance (non-negative number)

set_absolute_tolerance_steady_state(atol: float)[source]

sets the absolute tolerance for the steady state problem

Parameters:: atol (float) – absolute tolerance (non-negative number)

set_absolute_tolerance_steady_state_sensi(atol: float)[source]

sets the absolute tolerance for the sensitivities of the steady state problem

Parameters:: atol (float) – absolute tolerance (non-negative number)

set_constraints(constraints: Sequence[float])[source]

Set constraints on the model state.

See https://sundials.readthedocs.io/en/latest/cvode/Usage/index.html#c.CVodeSetConstraints.

Parameters:: constraints (collections.abc.Sequence[float])

set_internal_sensitivity_method(ism: InternalSensitivityMethod)[source]

sets the internal sensitivity method

Parameters:: ism (amici.amici.InternalSensitivityMethod) – internal sensitivity method

set_interpolation_type(interpType: InterpolationType)[source]

sets the interpolation of the forward solution that is used for the backwards problem

Parameters:: interpType (amici.amici.InterpolationType) – interpolation type

set_linear_multistep_method(lmm: LinearMultistepMethod)[source]

sets the linear system multistep method

Parameters:: lmm (amici.amici.LinearMultistepMethod) – linear system multistep method

set_linear_solver(linsol: LinearSolver)[source]

Parameters:: linsol (amici.amici.LinearSolver)

set_max_conv_fails(max_conv_fails: int)[source]

Set the maximum number of nonlinear solver convergence failures permitted per step.

Parameters:: max_conv_fails (int) – maximum number of nonlinear solver convergence

set_max_nonlin_iters(max_nonlin_iters: int)[source]

Set the maximum number of nonlinear solver iterations permitted per step.

Parameters:: max_nonlin_iters (int) – maximum number of nonlinear solver iterations

set_max_step_size(max_step_size: float)[source]

Set the maximum step size

Parameters:: max_step_size (float) – maximum step size. 0.0 means no limit.

set_max_steps(maxsteps: int)[source]

sets the maximum number of solver steps for the forward problem

Parameters:: maxsteps (int) – maximum number of solver steps (positive number)

set_max_steps_backward_problem(maxsteps: int)[source]

sets the maximum number of solver steps for the backward problem

Parameters:: maxsteps (int) – maximum number of solver steps (non-negative number)

Notes: default behaviour (100 times the value for the forward problem) can be restored by passing maxsteps=0

set_max_time(maxtime: float)[source]

Set the maximum CPU time allowed for integration

Parameters:: maxtime (float) – Time in seconds. Zero means infinite time.

set_newton_damping_factor_lower_bound(dampingFactorLowerBound: float)[source]

Set a lower bound of the damping factor in the Newton solver

Parameters:: dampingFactorLowerBound (float)

set_newton_damping_factor_mode(dampingFactorMode: NewtonDampingFactorMode)[source]

Turn on/off a damping factor in the Newton method

Parameters:: dampingFactorMode (amici.amici.NewtonDampingFactorMode)

set_newton_max_steps(newton_maxsteps: int)[source]

Set maximum number of allowed Newton steps for steady state computation

Parameters:: newton_maxsteps (int)

set_newton_step_steady_state_check(flag: bool)[source]

Sets how convergence checks for steadystate computation are performed.

Parameters:: flag (bool) – boolean flag to pick newton step (true) or the right hand side (false, default)

set_non_linear_solver_iteration(iter: NonlinearSolverIteration)[source]

sets the nonlinear system solution method

Parameters:: iter (amici.amici.NonlinearSolverIteration) – nonlinear system solution method

set_relative_tolerance(rtol: float)[source]

Sets the relative tolerances for the forward problem

Same tolerance is used for the backward problem if not specified differently via setRelativeToleranceASA.

Parameters:: rtol (float) – relative tolerance (non-negative number)

set_relative_tolerance_b(rtol: float)[source]

Sets the relative tolerances for the adjoint sensitivity problem

Parameters:: rtol (float) – relative tolerance (non-negative number)

set_relative_tolerance_fsa(rtol: float)[source]

Sets the relative tolerances for the forward sensitivity problem

Parameters:: rtol (float) – relative tolerance (non-negative number)

set_relative_tolerance_quadratures(rtol: float)[source]

sets the relative tolerance for the quadrature problem

Parameters:: rtol (float) – relative tolerance (non-negative number)

set_relative_tolerance_steady_state(rtol: float)[source]

sets the relative tolerance for the steady state problem

Parameters:: rtol (float) – relative tolerance (non-negative number)

set_relative_tolerance_steady_state_sensi(rtol: float)[source]

sets the relative tolerance for the sensitivities of the steady state problem

Parameters:: rtol (float) – relative tolerance (non-negative number)

set_return_data_reporting_mode(rdrm: RDataReporting)[source]

sets the ReturnData reporting mode

Parameters:: rdrm (amici.amici.RDataReporting) – ReturnData reporting mode

set_sensi_steady_state_check(flag: bool)[source]

Sets for which variables convergence checks for steadystate computation are performed.

Parameters:: flag (bool) – boolean flag to pick state and sensitivity equations (true, default) or only state variables (false).

set_sensitivity_method(sensi_meth: SensitivityMethod)[source]

Set sensitivity method

Parameters:: sensi_meth (amici.amici.SensitivityMethod)

set_sensitivity_method_pre_equilibration(sensi_meth_preeq: SensitivityMethod)[source]

Set sensitivity method for preequilibration

Parameters:: sensi_meth_preeq (amici.amici.SensitivityMethod)

set_sensitivity_order(sensi: SensitivityOrder)[source]

Set the sensitivity order

Parameters:: sensi (amici.amici.SensitivityOrder) – sensitivity order

set_stability_limit_flag(stldet: bool)[source]

set stability limit detection mode

Parameters:: stldet (bool) – can be false (deactivated) or true (activated)

set_state_ordering(ordering: int)[source]

Sets KLU / SuperLUMT state ordering mode

This only applies when linsol is set to LinearSolver::KLU or LinearSolver::SuperLUMT. Mind the difference between SUNLinSolKLU::StateOrdering and SUNLinSolSuperLUMT::StateOrdering.

Parameters:: ordering (int) – state ordering

set_steady_state_sensi_tolerance_factor(factor: float)[source]

set the steady state sensitivity simulation tolerance factor.

Steady state sensitivity simulation tolerances are the product of the sensitivity simulation tolerances and this factor, unless manually set with set(Absolute/Relative)ToleranceSteadyStateSensi().

Parameters:: factor (float) – tolerance factor (non-negative number)

set_steady_state_tolerance_factor(factor: float)[source]

set the steady state simulation tolerance factor.

Steady state simulation tolerances are the product of the simulation tolerances and this factor, unless manually set with set(Absolute/Relative)ToleranceSteadyState().

Parameters:: factor (float) – tolerance factor (non-negative number)

start_timer()[source]: Start timer for tracking integration time

switch_forward_sensis_off()[source]: Disable forward sensitivity integration (used in steady state sim)

time_exceeded(interval: int = 1) → bool[source]

Check whether maximum integration time was exceeded

Parameters:: interval (int) – Only check the time every interval ths call to avoid potentially relatively expensive syscalls
Return type:: bool
Returns:: True if the maximum integration time was exceeded, false otherwise.

class amici.amici.SolverPtr(*args)[source]: Swig-Generated class that implements smart pointers to Solver as objects.

class amici.amici.SteadyStateComputationMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

integrateIfNewtonFails = 2

integrationOnly = 1

newtonOnly = 0

class amici.amici.SteadyStateSensitivityMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

integrateIfNewtonFails = 2

integrationOnly = 1

newtonOnly = 0

class amici.amici.SteadyStateStatus(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

failed = -1

failed_convergence = -2

failed_damping = -4

failed_factorization = -3

failed_too_long_simulation = -5

not_run = 0

success = 1

class amici.amici.SteadyStateStatusVector(*args)[source]

class amici.amici.StringDoubleMap(*args)[source]: Swig-Generated class templating Dict [str, float] to facilitate interfacing with C++ bindings.

class amici.amici.StringVector(*args)[source]: Swig-Generated class templating common python types including Iterable [str] and numpy.array [str] to facilitate interfacing with C++ bindings.

amici.amici.compiled_with_openmp()[source]: AMICI extension was compiled with OpenMP?

amici.amici.get_backtrace_string(maxFrames: int, first_frame: int = 0) → str[source]

Returns the current backtrace as std::string

Parameters:

maxFrames (int) – Number of frames to include
first_frame (int) – Index of first frame to include

Return type:

str

Returns:

Backtrace

amici.amici.parameter_scaling_from_int_vector(int_vec)[source]: Swig-Generated class, which, in contrast to other Vector classes, does not allow for simple interoperability with common Python types, but must be created using amici.amici.parameter_scaling_from_int_vector()

amici.amici.read_exp_data_from_hdf5(hdf5Filename: str, hdf5Root: str, model: Model) → ExpData[source]

Read AMICI ExpData data from HDF5 file.

Parameters:

hdf5Filename (str) – Name of HDF5 file
hdf5Root (str) – Path inside the HDF5 file to object having ExpData
model (amici.amici.Model) – The model for which data is to be read

Return type:

amici.amici.ExpData

Returns:

ExpData created from data in the given location

amici.amici.read_model_data_from_hdf5(*args)[source]

Overload 1:

Read model data from HDF5 file.

Parameters:

hdffile (str) – Name of HDF5 file
model (Model) – Model to set data on
datasetPath (str) – Path inside the HDF5 file

Overload 2:

Read model data from HDF5 file.

Parameters:

file (H5::H5File) – HDF5 file handle to read from
model (Model) – Model to set data on
datasetPath (str) – Path inside the HDF5 file

amici.amici.read_solver_settings_from_hdf5(*args)[source]

Overload 1:

Read solver options from HDF5 file.

Parameters:

file (H5::H5File) – HDF5 file to read from
solver (Solver) – Solver to set options on
datasetPath (str) – Path inside the HDF5 file

Overload 2:

Read solver options from HDF5 file.

Parameters:

hdffile (str) – Name of HDF5 file
solver (Solver) – Solver to set options on
datasetPath (str) – Path inside the HDF5 file

amici.amici.run_simulation(solver: Solver, edata: ExpData, model: Model, rethrow: bool = False) → ReturnData[source]

Core integration routine. Initializes the solver and runs the forward and backward problem.

Parameters:

solver (amici.amici.Solver) – Solver instance
edata (amici.amici.ExpData) – pointer to experimental data object
model (amici.amici.Model) – model specification object
rethrow (bool) – rethrow integration exceptions?

Return type:

amici.amici.ReturnData

Returns:

rdata pointer to return data object

amici.amici.run_simulations(solver: Solver, edatas: ExpDataPtrVector, model: Model, failfast: bool, num_threads: int) → Iterable[ReturnData][source]

Same as run_simulation, but for multiple ExpData instances. When compiled with OpenMP support, this function runs multi-threaded.

Parameters:

solver (amici.amici.Solver) – Solver instance
edatas (amici.amici.ExpDataPtrVector) – experimental data objects
model (amici.amici.Model) – model specification object
failfast (bool) – flag to allow early termination
num_threads (int) – number of threads for parallel execution

Return type:

typing.Iterable[amici.amici.ReturnData]

Returns:

vector of pointers to return data objects

amici.amici.scale_parameter(unscaledParameter: float, scaling: int) → float[source]

Apply parameter scaling according to scaling

Parameters:

unscaledParameter (float)
scaling (int) – parameter scaling

Return type:

float

Returns:

Scaled parameter

amici.amici.simulation_status_to_str(status: int) → str[source]

Get the string representation of the given simulation status code (see ReturnData::status).

Parameters:: status (int) – Status code
Return type:: str
Returns:: Name of the variable representing this status code.

amici.amici.unscale_parameter(scaledParameter: float, scaling: int) → float[source]

Remove parameter scaling according to scaling

Parameters:

scaledParameter (float) – scaled parameter
scaling (int) – parameter scaling

Return type:

float

Returns:

Unscaled parameter

amici.amici.write_exp_data_to_hdf5(*args)[source]

Overload 1:

Write AMICI experimental data to HDF5 file.

Parameters:

edata (ExpData) – The experimental data which is to be written
file (H5::H5File) – HDF5 file
hdf5Location (str) – Path inside the HDF5 file

Overload 2:

Write AMICI experimental data to HDF5 file.

Parameters:

edata (ExpData) – The experimental data which is to be written
filepath (str) – Name of HDF5 file
hdf5Location (str) – Path inside the HDF5 file

amici.amici.write_return_data_to_hdf5(*args)[source]

Overload 1:

Write ReturnData to HDF5 file.

Parameters:

rdata (ReturnData) – Data to write
file (H5::H5File) – HDF5 file to write to
hdf5Location (str) – Full dataset path inside the HDF5 file (will be created)

Overload 2:

Write ReturnData to HDF5 file.

Parameters:

rdata (ReturnData) – Data to write
hdf5Filename (str) – Filename of HDF5 file
hdf5Location (str) – Full dataset path inside the HDF5 file (will be created)

amici.amici.write_solver_settings_to_hdf5(*args)[source]

Overload 1:

Write solver options to HDF5 file.

Parameters:

hdf5Filename (str) – Name of HDF5 file to write to
solver (Solver) – Solver to write options from
hdf5Location (str) – Path inside the HDF5 file

Overload 2:

Write solver options to HDF5 file.

Parameters:

file (H5::H5File) – File to read from
solver (Solver) – Solver to write options from
hdf5Location (str) – Path inside the HDF5 file