Parameter sensitivity¶

class
myokit.
PSimulation
(model, protocol=None, variables=None, parameters=None)¶ Runs a forwardEuler based simulation and calculates the partial derivatives of the model variables with respect to a given set of parameters.
This class is deprecated. Sensitivities with respect to parameters can now be calculated with the
Simulation
class.The simulation is based on automatic differentiation implemented using a C++ data type that replaces a single scalar float with a float and a list of partial derivatives. Any operations on this pair update both the float and the set of derivatives.
The resulting output is a set of logged variables plus a matrix of derivatives
dy/dp
wherey
is a nonconstant variable andp
is a constant parameter. The variables and parameters to track can be specified usingmyokit.Variable
objects or by their names. The parameters should be given as a listparameters
while the variablesy
should be given in the listvariables
.N.B. Partial derivatives can not be calculated for the functions
floor
,ceil
andabs
or for quotients and remainders. If these are encountered the resulting derivatives will be yielded asNaN
.A protocol can be passed in as
protocol
or set later usingset_protocol()
.The model and protocol passed to the simulation are cloned and stored internally. Any changes to the original model or protocol will not affect the simulation.
Simulations maintain an internal state consisting of
 the current simulation time
 the current state
 the partial derivatives of the current state with respect to the parameters
When a simulation is created, the simulation time is set to 0 and the state is obtained from the given model. The derivatives matrix is initialised as a matrix of size
(n, m)
with a row for each of then
states and a column for each ofm
parameters.After each call to
run()
the time, state and derivative variables are updated so that each successive call to run continues where the previous one left off. Areset()
method is provided that will set the time back to 0, revert the current state to the default state and reset the calculated derivatives.The simulation provides two inputs a variable can bind to:
time
 This variable contains the simulation time.
pace
 This variable contains the current value of the pacing variable as given by the protocol passed to the Simulation.
No labeled variables are required.

block
(log, derivatives)¶ Takes the output of a simulation (a simulation log and a list of derivatives) and combines it into a single
DataBlock2d
object.Each entry in the log is converted to a 0d entry in the block. The calculated derivatives are stored as the 2d field
derivatives
.

default_state
()¶ Returns the default state.

derivatives
()¶ Return the partial derivatives of the current state with respect to the parameters. Only works once the simulation has been run!

reset
()¶ Resets the simulation:
 The time variable is set to 0
 The state is set back to the default state
 The derivatives are set to zero

run
(duration, log=None, log_interval=1, progress=None, msg='Running PSimulation')¶ Runs a simulation and returns the logged results. Running a simulation has the following effects:
 The internal state is updated to the last state in the simulation.
 The simulation’s time variable is updated to reflect the time elapsed during the simulation.
The number of time units to simulate can be set with
duration
.The variables to log can be indicated using the
log
argument. There are several options for its value:None
(default), to log all states. An integer flag or a combination of flags. Options:
myokit.LOG_NONE
,myokit.LOG_STATE
,myokit.LOG_INTER
,myokit.LOG_BOUND
.  A list of qnames or variable objects
 A
myokit.DataLog
obtained from a previous simulation. In this case, the newly logged data will be appended to the existing log.
For more details on the
log
argument, see the functionmyokit.prepare_log()
.The method returns a
myokit.DataLog
and a 3d numpy array. In the returned array, the first axis represents the time, the second axis is a tracked variable y and the third is a parameter p such that the point(t, y, p)
representsdy/dp
at timet
. For example, ifd
is the array of derivatives, to get the derivative of variables0
with respect to parameter 2, used[:,0,2]
.A log entry is created every time at least
log_interval
time units have passed. Iflog_interval <= 0
every step taken is logged.To obtain feedback on the simulation progress, an object implementing the
myokit.ProgressReporter
interface can be passed in. passed in asprogress
. An optional description of the current simulation to use in the ProgressReporter can be passed in as msg.

set_constant
(var, value)¶ Changes a model constant. Only literal constants (constants not dependent on any other variable) can be changed. Constants set as parameters cannot be changed with this method but may be set using
set_parameters()
.The constant
var
can be given as aVariable
or a string containing a variable qname. Thevalue
should be given as a float.

set_parameters
(values)¶ Changes the values of the parameters under investigation.
The argument
values
must either be an ordered sequence containing the values for every parameter, or a mapping from one or more parameter names to their new values.N.B. Calling this method will reset the simulation.

set_protocol
(protocol=None)¶ Changes the pacing protocol used by this simulation.

set_step_size
(dt=0.01)¶ Sets the step size used in the forward Euler solving routine.

state
()¶ Returns the current state.

time
()¶ Returns the current simulation time.