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.
NonlinearSolverIteration_fixedpoint	deprecated

Functions

compiledWithOpenMP()	AMICI extension was compiled with OpenMP?
enum(prefix)
getScaledParameter(unscaledParameter, scaling)	Apply parameter scaling according to scaling
getUnscaledParameter(scaledParameter, scaling)	Remove parameter scaling according to scaling
parameterScalingFromIntVector(intVec)	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.parameterScalingFromIntVector()
runAmiciSimulation(solver, edata, model[, ...])	Core integration routine.
runAmiciSimulations(solver, edatas, model, ...)	Same as runAmiciSimulation, but for multiple ExpData instances.
simulation_status_to_str(status)	Get the string representation of the given simulation status code (see ReturnData::status).

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)
Model(*args, **kwargs)	The Model class represents an AMICI ODE/DAE model.
ModelDimensions(*args)	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)

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=None, *, 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

Tracks elapsed CPU time using std::clock.

__init__()

Constructor

elapsed_milliseconds() → float

Get elapsed CPU time in milliseconds since initialization or last reset

Return type:

float

Returns:

CPU time in milliseconds

elapsed_seconds() → float

Get elapsed CPU time in seconds since initialization or last reset

Return type:

float

Returns:

CPU time in seconds

reset()

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)

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)

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

__init__(*args)

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)

• fixedParameters (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)

• observedData (DoubleVector) – observed data (dimension: nt x nytrue, row-major)

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

• observedEvents (DoubleVector) – observed events (dimension: nmaxevents x nztrue, row-major)

• observedEventsStdDev (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 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

Overload 9:

constructor that initializes with returnData, adds 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)

clear_observations()

Set all observations and their standard deviations to NaN.

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

property fixedParameters

Model constants

Vector of size Model::nk() or empty

property fixedParametersPreequilibration

Model constants for pre-equilibration

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

property fixedParametersPresimulation

Model constants for pre-simulation

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

getObservedData() → Sequence[float]

Get all measurements.

Return type:

typing.Sequence[float]

Returns:

observed data (dimension: nt x nytrue, row-major)

getObservedDataPtr(it: int) → float

Get measurements for a given timepoint index.

Parameters:

it (int) – timepoint index

Return type:

float

Returns:

pointer to observed data at index (dimension: nytrue)

getObservedDataStdDev() → Sequence[float]

Get measurement standard deviations.

Return type:

typing.Sequence[float]

Returns:

standard deviation of observed data

getObservedDataStdDevPtr(it: int) → float

Get pointer to measurement standard deviations.

Parameters:

it (int) – timepoint index

Return type:

float

Returns:

pointer to standard deviation of observed data at index

getObservedEvents() → Sequence[float]

Get observed event data.

Return type:

typing.Sequence[float]

Returns:

observed event data

getObservedEventsPtr(ie: int) → float

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

getObservedEventsStdDev() → Sequence[float]

Get standard deviation of observed event data.

Return type:

typing.Sequence[float]

Returns:

standard deviation of observed event data

getObservedEventsStdDevPtr(ie: int) → float

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

getTimepoint(it: int) → float

Get timepoint for the given index

Parameters:

it (int) – timepoint index

Return type:

float

Returns:

timepoint timepoint at index

getTimepoints() → Sequence[float]

Get output timepoints.

Return type:

typing.Sequence[float]

Returns:

ExpData::ts

property id

Arbitrary (not necessarily unique) identifier.

isSetObservedData(it: int, iy: int) → bool

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

isSetObservedDataStdDev(it: int, iy: int) → bool

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

isSetObservedEvents(ie: int, iz: int) → bool

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

isSetObservedEventsStdDev(ie: int, iz: int) → bool

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

maximal number of events to track

Return type:

int

Returns:

maximal number of events to track

nt() → int

number of timepoints

Return type:

int

Returns:

number of timepoints

nytrue() → int

number of observables of the non-augmented model

Return type:

int

Returns:

number of observables of the non-augmented model

nztrue() → int

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.

reinitializeAllFixedParameterDependentInitialStates(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)

reinitializeAllFixedParameterDependentInitialStatesForPresimulation(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)

reinitializeAllFixedParameterDependentInitialStatesForSimulation(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 reinitializeFixedParameterInitialStates

Flag indicating whether reinitialization of states depending on fixed parameters is activated

setObservedData(*args)

Overload 1:

Set all measurements.

Parameters:

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

Overload 2:

Set measurements for a given observable index

Parameters:

• observedData (DoubleVector) – observed data (dimension: nt)

• iy (int) – observed data index

setObservedDataStdDev(*args)

Overload 1:

Set standard deviations for measurements.

Parameters:

observedDataStdDev (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

setObservedEvents(*args)

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

setObservedEventsStdDev(*args)

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

setTimepoints(ts: Sequence[float])

Set output timepoints.

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

Note that the mapping from timepoints 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 (typing.Sequence[float]) – timepoints

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 ts_

Timepoints for which model state/outputs/… are requested

Vector of timepoints.

property tstart_

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 x0

Initial state

Vector of size Model::nx() or empty

class amici.amici.ExpDataPtr(*args)

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

property fixedParameters

Model constants

Vector of size Model::nk() or empty

property fixedParametersPreequilibration

Model constants for pre-equilibration

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

property fixedParametersPresimulation

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 reinitializeFixedParameterInitialStates

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 ts_

Timepoints for which model state/outputs/… are requested

Vector of timepoints.

property tstart_

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 x0

Initial state

Vector of size Model::nx() or empty

class amici.amici.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.

class amici.amici.FixedParameterContext(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

preequilibration = 1

presimulation = 2

simulation = 0

class amici.amici.IntVector(*args)

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=None, *, 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=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

hermite = 1

polynomial = 2

class amici.amici.LinearMultistepMethod(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

BDF = 2

__init__(*args, **kwds)

adams = 1

class amici.amici.LinearSolver(value, names=None, *, 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)

A log item.

__init__(*args)

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)

class amici.amici.Model(*args, **kwargs)

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)

Overload 1:

Default ctor

Overload 2:

Constructor with model dimensions

Parameters:

• nx_rdata (int) – Number of state variables

• nxtrue_rdata (int) – Number of state variables of the non-augmented model

• nx_solver (int) – Number of state variables with conservation laws applied

• nxtrue_solver (int) – Number of state variables of the non-augmented model with conservation laws applied

• nx_solver_reinit (int) – Number of state variables with conservation laws subject to reinitialization

• np (int) – Number of parameters

• nk (int) – Number of constants

• ny (int) – Number of observables

• nytrue (int) – Number of observables of the non-augmented model

• nz (int) – Number of event observables

• nztrue (int) – Number of event observables of the non-augmented model

• ne (int) – Number of events

• ne_solver (int) – Number of events that require root-finding

• nspl (int) – Number of splines

• nJ (int) – Number of objective functions

• nw (int) – Number of repeating elements

• ndwdx (int) – Number of nonzero elements in the x derivative of the repeating elements

• ndwdp (int) – Number of nonzero elements in the p derivative of the repeating elements

• ndwdw (int) – Number of nonzero elements in the w derivative of the repeating elements

• ndxdotdw (int) – Number of nonzero elements in the \(w\) derivative of \(xdot\)

• ndJydy (IntVector) – Number of nonzero elements in the \(y\) derivative of \(dJy\) (shape nytrue)

• ndxrdatadxsolver (int) – Number of nonzero elements in the \(x\) derivative of \(x_rdata\)

• ndxrdatadtcl (int) – Number of nonzero elements in the \(tcl\) derivative of \(x_rdata\)

• ndtotal_cldx_rdata (int) – Number of nonzero elements in the \(x_rdata\) derivative of \(total_cl\)

• nnz (int) – Number of nonzero elements in Jacobian

• ubw (int) – Upper matrix bandwidth in the Jacobian

• lbw (int) – Lower matrix bandwidth in the Jacobian

clone() → Model

Clone this instance.

Return type:

amici.amici.Model

Returns:

The clone

fdsigmaydy(dsigmaydy: float, t: float, p: float, k: float, y: float)

Model-specific implementation of fsigmay

Parameters:

• dsigmaydy (float) – partial derivative of standard deviation of measurements w.r.t. model outputs

• t (float) – current time

• p (float) – parameter vector

• k (float) – constant vector

• y (float) – model output at timepoint t

fdspline_slopesdp(dspline_slopesdp: float, p: float, k: float, ip: int)

Model-specific implementation the parametric derivatives of slopevalues at spline nodes

Parameters:

• dspline_slopesdp (float) – vector to which derivatives will be written

• p (float) – parameter vector

• k (float) – constants vector

• ip (int) – Sensitivity index

fdspline_valuesdp(dspline_valuesdp: float, p: float, k: float, ip: int)

Model-specific implementation the parametric derivatives of spline node values

Parameters:

• dspline_valuesdp (float) – vector to which derivatives will be written

• p (float) – parameter vector

• k (float) – constants vector

• ip (int) – Sensitivity index

fdtotal_cldp(dtotal_cldp: float, x_rdata: float, p: float, k: float, ip: int)

Compute dtotal_cl / dp

Parameters:

• dtotal_cldp (float) – dtotal_cl / dp

• x_rdata (float) – State variables with conservation laws applied

• p (float) – parameter vector

• k (float) – constant vector

• ip (int) – Sensitivity index

fdtotal_cldx_rdata(dtotal_cldx_rdata: float, x_rdata: float, p: float, k: float, tcl: float)

Compute dtotal_cl / dx_rdata

Parameters:

• dtotal_cldx_rdata (float) – dtotal_cl / dx_rdata

• x_rdata (float) – State variables with conservation laws applied

• p (float) – parameter vector

• k (float) – constant vector

• tcl (float) – Total abundances for conservation laws

fdx_rdatadp(dx_rdatadp: float, x: float, tcl: float, p: float, k: float, ip: int)

Compute dx_rdata / dp

Parameters:

• dx_rdatadp (float) – dx_rdata / dp

• p (float) – parameter vector

• k (float) – constant vector

• x (float) – State variables with conservation laws applied

• tcl (float) – Total abundances for conservation laws

• ip (int) – Sensitivity index

fdx_rdatadtcl(dx_rdatadtcl: float, x: float, tcl: float, p: float, k: float)

Compute dx_rdata / dtcl

Parameters:

• dx_rdatadtcl (float) – dx_rdata / dtcl

• p (float) – parameter vector

• k (float) – constant vector

• x (float) – State variables with conservation laws applied

• tcl (float) – Total abundances for conservation laws

fdx_rdatadx_solver(dx_rdatadx_solver: float, x: float, tcl: float, p: float, k: float)

Compute dx_rdata / dx_solver

Parameters:

• dx_rdatadx_solver (float) – dx_rdata / dx_solver

• p (float) – parameter vector

• k (float) – constant vector

• x (float) – State variables with conservation laws applied

• tcl (float) – Total abundances for conservation laws

getAddSigmaResiduals() → bool

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

Return type:

bool

Returns:

sigma_res

getAlwaysCheckFinite() → bool

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

Return type:

bool

Returns:

that

getAmiciCommit() → str

Returns the AMICI commit that was used to generate the model

Return type:

str

Returns:

AMICI commit string

getAmiciVersion() → str

Returns the AMICI version that was used to generate the model

Return type:

str

Returns:

AMICI version string

getExpressionIds() → Sequence[str]

Get IDs of the expression.

Return type:

typing.Sequence[str]

Returns:

Expression IDs

getExpressionNames() → Sequence[str]

Get names of the expressions.

Return type:

typing.Sequence[str]

Returns:

Expression names

getFixedParameterById(par_id: str) → float

Get value of fixed parameter with the specified ID.

Parameters:

par_id (str) – Parameter ID

Return type:

float

Returns:

Parameter value

getFixedParameterByName(par_name: str) → float

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

getFixedParameterIds() → Sequence[str]

Get IDs of the fixed model parameters.

Return type:

typing.Sequence[str]

Returns:

Fixed parameter IDs

getFixedParameterNames() → Sequence[str]

Get names of the fixed model parameters.

Return type:

typing.Sequence[str]

Returns:

Fixed parameter names

getFixedParameters() → Sequence[float]

Get values of fixed parameters.

Return type:

typing.Sequence[float]

Returns:

Vector of fixed parameters with same ordering as in Model::getFixedParameterIds

getInitialStateSensitivities() → Sequence[float]

Get the initial states sensitivities.

Return type:

typing.Sequence[float]

Returns:

vector of initial state sensitivities

getInitialStates() → Sequence[float]

Get the initial states.

Return type:

typing.Sequence[float]

Returns:

Initial state vector

getMinimumSigmaResiduals() → float

Gets the specified estimated lower boundary for sigma_y.

Return type:

float

Returns:

lower boundary

getName() → str

Get the model name.

Return type:

str

Returns:

Model name

getObservableIds() → Sequence[str]

Get IDs of the observables.

Return type:

typing.Sequence[str]

Returns:

Observable IDs

getObservableNames() → Sequence[str]

Get names of the observables.

Return type:

typing.Sequence[str]

Returns:

Observable names

getObservableScaling(iy: int) → int

Get scaling type for observable

Parameters:

iy (int) – observable index

Return type:

int

Returns:

scaling type

getParameterById(par_id: str) → float

Get value of first model parameter with the specified ID.

Parameters:

par_id (str) – Parameter ID

Return type:

float

Returns:

Parameter value

getParameterByName(par_name: str) → float

Get value of first model parameter with the specified name.

Parameters:

par_name (str) – Parameter name

Return type:

float

Returns:

Parameter value

getParameterIds() → Sequence[str]

Get IDs of the model parameters.

Return type:

typing.Sequence[str]

Returns:

Parameter IDs

getParameterList() → Sequence[int]

Get the list of parameters for which sensitivities are computed.

Return type:

typing.Sequence[int]

Returns:

List of parameter indices

getParameterNames() → Sequence[str]

Get names of the model parameters.

Return type:

typing.Sequence[str]

Returns:

The parameter names

getParameterScale() → ParameterScalingVector

Get parameter scale for each parameter.

Return type:

amici.amici.ParameterScalingVector

Returns:

Vector of parameter scales

getParameters() → Sequence[float]

Get parameter vector.

Return type:

typing.Sequence[float]

Returns:

The user-set parameters (see also Model::getUnscaledParameters)

getReinitializationStateIdxs() → Sequence[int]

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

Return type:

typing.Sequence[int]

Returns:

Those indices.

getReinitializeFixedParameterInitialStates() → bool

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

Return type:

bool

Returns:

flag true / false

getSolver() → Solver

Retrieves the solver object

Return type:

amici.amici.Solver

Returns:

The Solver instance

getStateIds() → Sequence[str]

Get IDs of the model states.

Return type:

typing.Sequence[str]

Returns:

State IDs

getStateIdsSolver() → Sequence[str]

Get IDs of the solver states.

Return type:

typing.Sequence[str]

Returns:

State IDs

getStateIsNonNegative() → Sequence[bool]

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

Return type:

typing.Sequence[bool]

Returns:

Vector of flags

getStateNames() → Sequence[str]

Get names of the model states.

Return type:

typing.Sequence[str]

Returns:

State names

getStateNamesSolver() → Sequence[str]

Get names of the solver states.

Return type:

typing.Sequence[str]

Returns:

State names

getSteadyStateComputationMode() → int

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

Return type:

int

Returns:

Mode

getSteadyStateSensitivityMode() → SteadyStateSensitivityMode

Gets the mode how sensitivities are computed in the steadystate simulation.

Return type:

amici.amici.SteadyStateSensitivityMode

Returns:

Mode

getTimepoint(it: int) → float

Get simulation timepoint for time index it.

Parameters:

it (int) – Time index

Return type:

float

Returns:

Timepoint

getTimepoints() → Sequence[float]

Get the timepoint vector.

Return type:

typing.Sequence[float]

Returns:

Timepoint vector

getUnscaledParameters() → Sequence[float]

Get parameters with transformation according to parameter scale applied.

Return type:

typing.Sequence[float]

Returns:

Unscaled parameters

get_trigger_timepoints() → Sequence[float]

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

Return type:

typing.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.

hasCustomInitialStateSensitivities() → bool

Return whether custom initial state sensitivities have been set.

Return type:

bool

Returns:

true if has custom initial state sensitivities, otherwise false.

hasCustomInitialStates() → bool

Return whether custom initial states have been set.

Return type:

bool

Returns:

true if has custom initial states, otherwise false

hasExpressionIds() → bool

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.

hasExpressionNames() → bool

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.

hasFixedParameterIds() → bool

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.

hasFixedParameterNames() → bool

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.

hasObservableIds() → bool

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.

hasObservableNames() → bool

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.

hasParameterIds() → bool

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.

hasParameterNames() → bool

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.

hasQuadraticLLH() → bool

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

Return type:

bool

Returns:

boolean flag

hasStateIds() → bool

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.

hasStateNames() → bool

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.

property idlist

Flag array for DAE equations

initializeSplineSensitivities()

Initialization of spline sensitivity functions

initializeSplines()

Initialization of spline functions

isFixedParameterStateReinitializationAllowed() → 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

Get fixed parameters.

Return type:

float

Returns:

Pointer to constants array

property lbw

Lower bandwidth of the Jacobian

property logger

Logger

property nJ

Dimension of the augmented objective function for 2nd order ASA

nMaxEvent() → int

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

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 ndxdotdw

Number of nonzero elements in the \(w\) derivative of \(xdot\)

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

Get number of constants

Return type:

int

Returns:

Length of constant vector

property nnz

Number of nonzero entries in Jacobian

np() → int

Get total number of model parameters.

Return type:

int

Returns:

Length of parameter vector

nplist() → int

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

Get number of timepoints.

Return type:

int

Returns:

Number of timepoints

property nw

Number of common expressions

property nx_rdata

Number of states

nx_reinit() → int

Get number of solver states subject to reinitialization.

Return type:

int

Returns:

Model member nx_solver_reinit

property nx_solver

Number of states with conservation laws applied

property nx_solver_reinit

Number of solver states subject to reinitialization

property nxtrue_rdata

Number of states in the unaugmented system

property nxtrue_solver

Number of states 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 for amici::Solver::sensi_ == amici::SensitivityOrder::second directional or full second order derivative will be computed

plist(pos: int) → int

Get entry in parameter list by index.

Parameters:

pos (int) – Index in sensitivity parameter list

Return type:

int

Returns:

Index in parameter list

property pythonGenerated

Flag indicating Matlab- or Python-based model generation

requireSensitivitiesForAllParameters()

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

NOTE: Resets initial state sensitivities.

setAddSigmaResiduals(sigma_res: bool)

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

setAllStatesNonNegative()

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

setAlwaysCheckFinite(alwaysCheck: bool)

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

Parameters:

alwaysCheck (bool)

setFixedParameterById(par_id: str, value: float)

Set value of first fixed parameter with the specified ID.

Parameters:

• par_id (str) – Fixed parameter id

• value (float) – Fixed parameter value

setFixedParameterByName(par_name: str, value: float)

Set value of first fixed parameter with the specified name.

Parameters:

• par_name (str) – Fixed parameter ID

• value (float) – Fixed parameter value

setFixedParameters(k: Sequence[float])

Set values for constants.

Parameters:

k (typing.Sequence[float]) – Vector of fixed parameters

setFixedParametersByIdRegex(par_id_regex: str, value: float) → int

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

setFixedParametersByNameRegex(par_name_regex: str, value: float) → int

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

setInitialStateSensitivities(sx0: Sequence[float])

Set the initial state sensitivities.

Parameters:

sx0 (typing.Sequence[float]) – vector of initial state sensitivities with chainrule applied. This could be a slice of ReturnData::sx or ReturnData::sx0

setInitialStates(x0: Sequence[float])

Set the initial states.

Parameters:

x0 (typing.Sequence[float]) – Initial state vector

setMinimumSigmaResiduals(min_sigma: float)

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

setNMaxEvent(nmaxevent: int)

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

Parameters:

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

setParameterById(*args)

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

setParameterByName(*args)

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

setParameterList(plist: Sequence[int])

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

NOTE: Resets initial state sensitivities.

Parameters:

plist (typing.Sequence[int]) – List of parameter indices

setParameterScale(*args)

setParameters(p: Sequence[float])

Set the parameter vector.

Parameters:

p (typing.Sequence[float]) – Vector of parameters

setParametersByIdRegex(par_id_regex: str, value: float) → int

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

setParametersByNameRegex(par_name_regex: str, value: float) → int

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

setReinitializationStateIdxs(idxs: Sequence[int])

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

Parameters:

idxs (typing.Sequence[int]) – Array of state indices

setReinitializeFixedParameterInitialStates(flag: bool)

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

Parameters:

flag (bool) – Fixed parameters reinitialized?

setStateIsNonNegative(stateIsNonNegative: Sequence[bool])

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

Parameters:

stateIsNonNegative (typing.Sequence[bool]) – Vector of flags

setSteadyStateComputationMode(mode: int)

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

Parameters:

mode (int) – Steadystate computation mode

setSteadyStateSensitivityMode(mode: SteadyStateSensitivityMode)

Set the mode how sensitivities are computed in the steadystate simulation.

Parameters:

mode (amici.amici.SteadyStateSensitivityMode) – Steadystate sensitivity mode

setT0(t0: float)

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

setTimepoints(ts: Sequence[float])

Set the timepoint vector.

Parameters:

ts (typing.Sequence[float]) – New timepoint vector

setUnscaledInitialStateSensitivities(sx0: Sequence[float])

Set the initial state sensitivities.

Parameters:

sx0 (typing.Sequence[float]) – Vector of initial state sensitivities without chainrule applied. This could be the readin from a model.sx0data saved to HDF5.

property state_independent_events_

Map of trigger timepoints to event indices for events that don’t require root-finding.

t0() → float

Get simulation start time.

Return type:

float

Returns:

Simulation start time

property ubw

Upper bandwidth of the Jacobian

class amici.amici.ModelDimensions(*args)

Container for model dimensions.

Holds number of states, observables, etc.

__init__(*args)

Overload 1:

Default ctor

Overload 2:

Constructor with model dimensions

Parameters:

• nx_rdata (int) – Number of state variables

• nxtrue_rdata (int) – Number of state variables of the non-augmented model

• nx_solver (int) – Number of state variables with conservation laws applied

• nxtrue_solver (int) – Number of state variables of the non-augmented model with conservation laws applied

• nx_solver_reinit (int) – Number of state variables with conservation laws subject to reinitialization

• np (int) – Number of parameters

• nk (int) – Number of constants

• ny (int) – Number of observables

• nytrue (int) – Number of observables of the non-augmented model

• nz (int) – Number of event observables

• nztrue (int) – Number of event observables of the non-augmented model

• ne (int) – Number of events

• ne_solver (int) – Number of events that require root-finding

• nspl (int) – Number of splines

• nJ (int) – Number of objective functions

• nw (int) – Number of repeating elements

• ndwdx (int) – Number of nonzero elements in the x derivative of the repeating elements

• ndwdp (int) – Number of nonzero elements in the p derivative of the repeating elements

• ndwdw (int) – Number of nonzero elements in the w derivative of the repeating elements

• ndxdotdw (int) – Number of nonzero elements in the \(w\) derivative of \(xdot\)

• ndJydy (IntVector) – Number of nonzero elements in the \(y\) derivative of \(dJy\) (shape nytrue)

• ndxrdatadxsolver (int) – Number of nonzero elements in the \(x\) derivative of \(x_rdata\)

• ndxrdatadtcl (int) – Number of nonzero elements in the \(tcl\) derivative of \(x_rdata\)

• ndtotal_cldx_rdata (int) – Number of nonzero elements in the \(x_rdata\) derivative of \(total_cl\)

• nnz (int) – Number of nonzero elements in Jacobian

• ubw (int) – Upper matrix bandwidth in the Jacobian

• lbw (int) – Lower matrix bandwidth in the Jacobian

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 ndxdotdw

Number of nonzero elements in the \(w\) derivative of \(xdot\)

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 states

property nx_solver

Number of states with conservation laws applied

property nx_solver_reinit

Number of solver states subject to reinitialization

property nxtrue_rdata

Number of states in the unaugmented system

property nxtrue_solver

Number of states 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

class amici.amici.ModelPtr(*args)

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

property idlist

Flag array for DAE equations

property lbw

Lower bandwidth of the Jacobian

property logger

Logger

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 ndxdotdw

Number of nonzero elements in the \(w\) derivative of \(xdot\)

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 states

property nx_solver

Number of states with conservation laws applied

property nx_solver_reinit

Number of solver states subject to reinitialization

property nxtrue_rdata

Number of states in the unaugmented system

property nxtrue_solver

Number of states 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 for amici::Solver::sensi_ == amici::SensitivityOrder::second directional or full second order derivative will be computed

property pythonGenerated

Flag indicating Matlab- or Python-based model generation

property state_independent_events_

Map of trigger timepoints to event indices for events that don’t require root-finding.

property ubw

Upper bandwidth of the Jacobian

class amici.amici.NewtonDampingFactorMode(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

off = 0

on = 1

class amici.amici.NonlinearSolverIteration(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

fixedpoint = 1

functional = 1

newton = 2

amici.amici.NonlinearSolverIteration_fixedpoint = 1

deprecated

class amici.amici.ObservableScaling(value, names=None, *, 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=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

ln = 1

log10 = 2

none = 0

class amici.amici.ParameterScalingVector(*args)

class amici.amici.RDataReporting(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__init__(*args, **kwds)

full = 0

likelihood = 2

residuals = 1

class amici.amici.ReturnData(*args)

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 (shape nx x nx, row-major) evaluated at t_last.

__init__(*args)

Overload 1:

Default constructor

Overload 2:

Constructor

Parameters:

• ts (DoubleVector) – see amici::SimulationParameters::ts

• model_dimensions (ModelDimensions) – Model dimensions

• nplist (int) – see amici::ModelDimensions::nplist

• nmaxevent (int) – see amici::ModelDimensions::nmaxevent

• nt (int) – see amici::ModelDimensions::nt

• newton_maxsteps (int) – see amici::Solver::newton_maxsteps

• 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_timeB

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 ndxdotdw

Number of nonzero elements in the \(w\) derivative of \(xdot\)

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 parameter for which sensitivities were requested

property nspl

Number of spline functions in the model

property nt

number of considered timepoints

property numerrtestfails

number of error test failures forward problem (shape nt)

property numerrtestfailsB

number of error test failures backward problem (shape nt)

property numnonlinsolvconvfails

number of linear solver convergence failures forward problem (shape nt)

property numnonlinsolvconvfailsB

number of linear solver convergence failures backward problem (shape nt)

property numrhsevals

number of right hand side evaluations forward problem (shape nt)

property numrhsevalsB

number of right hand side evaluations backward problem (shape nt)

property numsteps

number of integration steps forward problem (shape nt)

property numstepsB

number of integration steps backward problem (shape nt)

property nw

Number of common expressions

property nx

number of states (alias nx_rdata, kept for backward compatibility)

property nx_rdata

Number of states

property nx_solver

Number of states with conservation laws applied

property nx_solver_reinit

Number of solver states subject to reinitialization

property nxtrue

number of states in the unaugmented system (alias nxtrue_rdata, kept for backward compatibility)

property nxtrue_rdata

Number of states in the unaugmented system

property nxtrue_solver

Number of states 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 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_timeB

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 steady state problem (preequilibration) [newton, simulation, newton] (shape 3) (postequilibration)

property posteq_numstepsB

number of simulation steps for adjoint steady state problem (postequilibration) [== 0 if analytical solution worked, > 0 otherwise]

property posteq_status

flags indicating success of steady state solver (postequilibration)

property posteq_t

time when steadystate was reached via simulation (postequilibration)

property posteq_wrms

weighted root-mean-square of the rhs when steadystate was reached (postequilibration)

property preeq_cpu_time

computation time of the steady state solver [ms] (preequilibration)

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_timeB

computation time of the steady state solver of the backward problem [ms] (preequilibration)

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 steady state problem (preequilibration) [newton, simulation, newton] (length = 3)

property preeq_numstepsB

number of simulation steps for adjoint steady state problem (preequilibration) [== 0 if analytical solution worked, > 0 otherwise]

property preeq_status

flags indicating success of steady state solver (preequilibration)

property preeq_t

time when steadystate was reached via simulation (preequilibration)

property preeq_wrms

weighted root-mean-square of the rhs when steadystate was reached (preequilibration)

property pscale

scaling of parameterization

property rdata_reporting

reporting mode

property res

observable (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

parameter derivative of state (shape nt x nplist x nx, row-major)

property sx0

initial sensitivities (shape nplist x nx, row-major)

property sx_ss

preequilibration sensitivities (shape nplist x nx, row-major)

property sy

parameter derivative of observable (shape nt x nplist x ny, row-major)

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

timepoints (shape nt)

property ubw

Upper bandwidth of the Jacobian

property w

w data from the model (recurring terms in xdot, for imported SBML models from python, this contains the flux vector) (shape nt x nw, row major)

property x

state (shape nt x nx, row-major)

property x0

initial state (shape nx)

property x_ss

preequilibration steady state (shape nx)

property xdot

time derivative (shape nx) evaluated at t_last.

property y

observable (shape nt x ny, row-major)

property z

event output (shape nmaxevent x nz, row-major)

class amici.amici.ReturnDataPtr(*args)

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 (shape nx x nx, row-major) evaluated at t_last.

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_timeB

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 ndxdotdw

Number of nonzero elements in the \(w\) derivative of \(xdot\)

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 parameter for which sensitivities were requested

property nspl

Number of spline functions in the model

property nt

number of considered timepoints

property numerrtestfails

number of error test failures forward problem (shape nt)

property numerrtestfailsB

number of error test failures backward problem (shape nt)

property numnonlinsolvconvfails

number of linear solver convergence failures forward problem (shape nt)

property numnonlinsolvconvfailsB

number of linear solver convergence failures backward problem (shape nt)

property numrhsevals

number of right hand side evaluations forward problem (shape nt)

property numrhsevalsB

number of right hand side evaluations backward problem (shape nt)

property numsteps

number of integration steps forward problem (shape nt)

property numstepsB

number of integration steps backward problem (shape nt)

property nw

Number of common expressions

property nx

number of states (alias nx_rdata, kept for backward compatibility)

property nx_rdata

Number of states

property nx_solver

Number of states with conservation laws applied

property nx_solver_reinit

Number of solver states subject to reinitialization

property nxtrue

number of states in the unaugmented system (alias nxtrue_rdata, kept for backward compatibility)

property nxtrue_rdata

Number of states in the unaugmented system

property nxtrue_solver

Number of states 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 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_timeB

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 steady state problem (preequilibration) [newton, simulation, newton] (shape 3) (postequilibration)

property posteq_numstepsB

number of simulation steps for adjoint steady state problem (postequilibration) [== 0 if analytical solution worked, > 0 otherwise]

property posteq_status

flags indicating success of steady state solver (postequilibration)

property posteq_t

time when steadystate was reached via simulation (postequilibration)

property posteq_wrms

weighted root-mean-square of the rhs when steadystate was reached (postequilibration)

property preeq_cpu_time

computation time of the steady state solver [ms] (preequilibration)

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_timeB

computation time of the steady state solver of the backward problem [ms] (preequilibration)

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 steady state problem (preequilibration) [newton, simulation, newton] (length = 3)

property preeq_numstepsB

number of simulation steps for adjoint steady state problem (preequilibration) [== 0 if analytical solution worked, > 0 otherwise]

property preeq_status

flags indicating success of steady state solver (preequilibration)

property preeq_t

time when steadystate was reached via simulation (preequilibration)

property preeq_wrms

weighted root-mean-square of the rhs when steadystate was reached (preequilibration)

property pscale

scaling of parameterization

property rdata_reporting

reporting mode

property res

observable (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

parameter derivative of state (shape nt x nplist x nx, row-major)

property sx0

initial sensitivities (shape nplist x nx, row-major)

property sx_ss

preequilibration sensitivities (shape nplist x nx, row-major)

property sy

parameter derivative of observable (shape nt x nplist x ny, row-major)

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

timepoints (shape nt)

property ubw

Upper bandwidth of the Jacobian

property w

w data from the model (recurring terms in xdot, for imported SBML models from python, this contains the flux vector) (shape nt x nw, row major)

property x

state (shape nt x nx, row-major)

property x0

initial state (shape nx)

property x_ss

preequilibration steady state (shape nx)

property xdot

time derivative (shape nx) evaluated at t_last.

property y

observable (shape nt x ny, row-major)

property z

event output (shape nmaxevent x nz, row-major)

class amici.amici.SecondOrderMode(value, names=None, *, 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=None, *, 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=None, *, 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)

Container for various simulation parameters.

__init__(*args)

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 fixedParameters

Model constants

Vector of size Model::nk() or empty

property fixedParametersPreequilibration

Model constants for pre-equilibration

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

property fixedParametersPresimulation

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.

reinitializeAllFixedParameterDependentInitialStates(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)

reinitializeAllFixedParameterDependentInitialStatesForPresimulation(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)

reinitializeAllFixedParameterDependentInitialStatesForSimulation(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 reinitializeFixedParameterInitialStates

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 ts_

Timepoints for which model state/outputs/… are requested

Vector of timepoints.

property tstart_

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 x0

Initial state

Vector of size Model::nx() or empty

class amici.amici.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. 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.

NOTE: Any changes in data members here must be propagated to copy ctor, equality operator, serialization functions in serialization.h, and amici::hdf5::(read/write)SolverSettings(From/To)HDF5 in hdf5.cpp.

__init__(*args, **kwargs)

clone() → Solver

Clone this instance

Return type:

amici.amici.Solver

Returns:

The clone

computingASA() → bool

check if ASA is being computed

Return type:

bool

Returns:

flag

computingFSA() → bool

check if FSA is being computed

Return type:

bool

Returns:

flag

getAbsoluteTolerance() → float

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

getAbsoluteToleranceB() → float

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

Return type:

float

Returns:

absolute tolerances

getAbsoluteToleranceFSA() → float

Returns the absolute tolerances for the forward sensitivity problem

Return type:

float

Returns:

absolute tolerances

getAbsoluteToleranceQuadratures() → float

returns the absolute tolerance for the quadrature problem

Return type:

float

Returns:

absolute tolerance

getAbsoluteToleranceSteadyState() → float

returns the absolute tolerance for the steady state problem

Return type:

float

Returns:

absolute tolerance

getAbsoluteToleranceSteadyStateSensi() → float

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

Return type:

float

Returns:

absolute tolerance

getConstraints() → Sequence[float]

Get constraints on the model state.

Return type:

typing.Sequence[float]

Returns:

constraints

getInternalSensitivityMethod() → InternalSensitivityMethod

returns the internal sensitivity method

Return type:

amici.amici.InternalSensitivityMethod

Returns:

internal sensitivity method

getInterpolationType() → InterpolationType

Return type:

amici.amici.InterpolationType

Returns:

getLinearMultistepMethod() → LinearMultistepMethod

returns the linear system multistep method

Return type:

amici.amici.LinearMultistepMethod

Returns:

linear system multistep method

getLinearSolver() → LinearSolver

Return type:

amici.amici.LinearSolver

Returns:

getMaxConvFails() → int

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

Return type:

int

Returns:

maximum number of nonlinear solver convergence

getMaxNonlinIters() → int

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

Return type:

int

Returns:

maximum number of nonlinear solver iterations

getMaxStepSize() → float

Get the maximum step size

Return type:

float

Returns:

maximum step size

getMaxSteps() → int

returns the maximum number of solver steps for the forward problem

Return type:

int

Returns:

maximum number of solver steps

getMaxStepsBackwardProblem() → int

returns the maximum number of solver steps for the backward problem

Return type:

int

Returns:

maximum number of solver steps

getMaxTime() → float

Returns the maximum time allowed for integration

Return type:

float

Returns:

Time in seconds

getNewtonDampingFactorLowerBound() → float

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

Return type:

float

Returns:

getNewtonDampingFactorMode() → NewtonDampingFactorMode

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

Return type:

amici.amici.NewtonDampingFactorMode

Returns:

getNewtonMaxSteps() → int

Get maximum number of allowed Newton steps for steady state computation

Return type:

int

Returns:

getNewtonStepSteadyStateCheck() → bool

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)

getNonlinearSolverIteration() → NonlinearSolverIteration

returns the nonlinear system solution method

Return type:

amici.amici.NonlinearSolverIteration

Returns:

getRelativeTolerance() → float

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

getRelativeToleranceB() → float

Returns the relative tolerances for the adjoint sensitivity problem

Return type:

float

Returns:

relative tolerances

getRelativeToleranceFSA() → float

Returns the relative tolerances for the forward sensitivity problem

Return type:

float

Returns:

relative tolerances

getRelativeToleranceQuadratures() → float

Returns the relative tolerance for the quadrature problem

Return type:

float

Returns:

relative tolerance

getRelativeToleranceSteadyState() → float

returns the relative tolerance for the steady state problem

Return type:

float

Returns:

relative tolerance

getRelativeToleranceSteadyStateSensi() → float

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

Return type:

float

Returns:

relative tolerance

getReturnDataReportingMode() → RDataReporting

returns the ReturnData reporting mode

Return type:

amici.amici.RDataReporting

Returns:

ReturnData reporting mode

getSensiSteadyStateCheck() → bool

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

getSensitivityMethod() → SensitivityMethod

Return current sensitivity method

Return type:

amici.amici.SensitivityMethod

Returns:

method enum

getSensitivityMethodPreequilibration() → SensitivityMethod

Return current sensitivity method during preequilibration

Return type:

amici.amici.SensitivityMethod

Returns:

method enum

getSensitivityOrder() → SensitivityOrder

Get sensitivity order

Return type:

amici.amici.SensitivityOrder

Returns:

sensitivity order

getStabilityLimitFlag() → bool

returns stability limit detection mode

Return type:

bool

Returns:

stldet can be false (deactivated) or true (activated)

getStateOrdering() → int

Gets KLU / SuperLUMT state ordering mode

Return type:

int

Returns:

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

getSteadyStateSensiToleranceFactor() → float

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

getSteadyStateToleranceFactor() → float

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

property logger

nplist() → int

number of parameters with which the solver was initialized

Return type:

int

Returns:

sx.getLength()

nquad() → int

number of quadratures with which the solver was initialized

Return type:

int

Returns:

xQB.getLength()

nx() → int

number of states with which the solver was initialized

Return type:

int

Returns:

x.getLength()

setAbsoluteTolerance(atol: float)

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)

setAbsoluteToleranceB(atol: float)

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

Parameters:

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

setAbsoluteToleranceFSA(atol: float)

Sets the absolute tolerances for the forward sensitivity problem

Parameters:

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

setAbsoluteToleranceQuadratures(atol: float)

sets the absolute tolerance for the quadrature problem

Parameters:

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

setAbsoluteToleranceSteadyState(atol: float)

sets the absolute tolerance for the steady state problem

Parameters:

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

setAbsoluteToleranceSteadyStateSensi(atol: float)

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

Parameters:

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

setConstraints(constraints: Sequence[float])

Set constraints on the model state.

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

Parameters:

constraints (typing.Sequence[float])

setInternalSensitivityMethod(ism: InternalSensitivityMethod)

sets the internal sensitivity method

Parameters:

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

setInterpolationType(interpType: InterpolationType)

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

Parameters:

interpType (amici.amici.InterpolationType) – interpolation type

setLinearMultistepMethod(lmm: LinearMultistepMethod)

sets the linear system multistep method

Parameters:

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

setLinearSolver(linsol: LinearSolver)

Parameters:

linsol (amici.amici.LinearSolver)

setMaxConvFails(max_conv_fails: int)

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

Parameters:

max_conv_fails (int) – maximum number of nonlinear solver convergence

setMaxNonlinIters(max_nonlin_iters: int)

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

Parameters:

max_nonlin_iters (int) – maximum number of nonlinear solver iterations

setMaxStepSize(max_step_size: float)

Set the maximum step size

Parameters:

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

setMaxSteps(maxsteps: int)

sets the maximum number of solver steps for the forward problem

Parameters:

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

setMaxStepsBackwardProblem(maxsteps: int)

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

setMaxTime(maxtime: float)

Set the maximum CPU time allowed for integration

Parameters:

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

setNewtonDampingFactorLowerBound(dampingFactorLowerBound: float)

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

Parameters:

dampingFactorLowerBound (float)

setNewtonDampingFactorMode(dampingFactorMode: NewtonDampingFactorMode)

Turn on/off a damping factor in the Newton method

Parameters:

dampingFactorMode (amici.amici.NewtonDampingFactorMode)

setNewtonMaxSteps(newton_maxsteps: int)

Set maximum number of allowed Newton steps for steady state computation

Parameters:

newton_maxsteps (int)

setNewtonStepSteadyStateCheck(flag: bool)

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)

setNonlinearSolverIteration(iter: NonlinearSolverIteration)

sets the nonlinear system solution method

Parameters:

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

setRelativeTolerance(rtol: float)

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)

setRelativeToleranceB(rtol: float)

Sets the relative tolerances for the adjoint sensitivity problem

Parameters:

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

setRelativeToleranceFSA(rtol: float)

Sets the relative tolerances for the forward sensitivity problem

Parameters:

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

setRelativeToleranceQuadratures(rtol: float)

sets the relative tolerance for the quadrature problem

Parameters:

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

setRelativeToleranceSteadyState(rtol: float)

sets the relative tolerance for the steady state problem

Parameters:

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

setRelativeToleranceSteadyStateSensi(rtol: float)

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

Parameters:

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

setReturnDataReportingMode(rdrm: RDataReporting)

sets the ReturnData reporting mode

Parameters:

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

setSensiSteadyStateCheck(flag: bool)

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

setSensitivityMethod(sensi_meth: SensitivityMethod)

Set sensitivity method

Parameters:

sensi_meth (amici.amici.SensitivityMethod)

setSensitivityMethodPreequilibration(sensi_meth_preeq: SensitivityMethod)

Set sensitivity method for preequilibration

Parameters:

sensi_meth_preeq (amici.amici.SensitivityMethod)

setSensitivityOrder(sensi: SensitivityOrder)

Set the sensitivity order

Parameters:

sensi (amici.amici.SensitivityOrder) – sensitivity order

setStabilityLimitFlag(stldet: bool)

set stability limit detection mode

Parameters:

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

setStateOrdering(ordering: int)

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

setSteadyStateSensiToleranceFactor(factor: float)

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)

setSteadyStateToleranceFactor(factor: float)

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)

class amici.amici.SolverPtr(*args)

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

property logger

class amici.amici.SteadyStateComputationMode(value, names=None, *, 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=None, *, 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=None, *, 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)

class amici.amici.StringDoubleMap(*args)

Swig-Generated class templating Dict [str, float] to facilitate interfacing with C++ bindings.

class amici.amici.StringVector(*args)

Swig-Generated class templating common python types including Iterable [str] and numpy.array [str] to facilitate interfacing with C++ bindings.

amici.amici.compiledWithOpenMP() → bool

AMICI extension was compiled with OpenMP?

Return type:

bool

amici.amici.getScaledParameter(unscaledParameter: float, scaling: int) → float

Apply parameter scaling according to scaling

Parameters:

• unscaledParameter (float)

• scaling (int) – parameter scaling

Return type:

float

Returns:

Scaled parameter

amici.amici.getUnscaledParameter(scaledParameter: float, scaling: int) → float

Remove parameter scaling according to scaling

Parameters:

• scaledParameter (float) – scaled parameter

• scaling (int) – parameter scaling

Return type:

float

Returns:

Unscaled parameter

amici.amici.parameterScalingFromIntVector(intVec: Sequence[int]) → tuple[ParameterScaling]

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.parameterScalingFromIntVector()

Return type:

tuple[amici.amici.ParameterScaling]

amici.amici.runAmiciSimulation(solver: Solver, edata: ExpData, model: Model, rethrow: bool = False) → ReturnData

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.runAmiciSimulations(solver: Solver, edatas: ExpDataPtrVector, model: Model, failfast: bool, num_threads: int) → Iterable[ReturnData]

Same as runAmiciSimulation, 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.simulation_status_to_str(status: int) → str

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.