myokit 1.33.9__py3-none-any.whl → 1.35.0__py3-none-any.whl

myokit/_sim/cvodessim.py

@@ -5,9 +5,6 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import os
 import platform
 import tempfile
@@ -85,7 +82,7 @@ class Simulation(myokit.CModule):
         determined using the protocol passed into the Simulation.
     ``evaluations``
         This input provides the number of rhs evaluations used at each point in
-        time and can be used to gain some insight into the solver's behaviour.
+        time and can be used to gain some insight into the solver's behavior.
     ``realtime``
         This input provides the elapsed system time at each logged point.
 
@@ -99,8 +96,8 @@ class Simulation(myokit.CModule):
 
     Each time a simulation is created, a C module is compiled, imported, and
     deleted in the background. This means that part of a ``Simulation`` object
-    is a reference to an imported C extension, and cannot be serialised. When
-    using ``pickle`` to serialise the simulation, this compiled part is not
+    is a reference to an imported C extension, and cannot be serialized. When
+    using ``pickle`` to serialize the simulation, this compiled part is not
     stored. Instead, when the pickled simulation is read from disk the
     compilation is repeated. Unpickling simulations also restores their state:
     variables such as model state, simulation time, and tolerance are preserved
@@ -122,8 +119,11 @@ class Simulation(myokit.CModule):
     ``model``
         The model to simulate
     ``protocol``
-        An optional :class:`myokit.Protocol` to use as input for variables
-        bound to ``pace``.
+        A :class:`myokit.Protocol` or :class:`myokit.TimeSeriesProtocol` to use
+        for the variable with binding ``pace``. Atlernatively, a dictionary
+        mapping binding labels to :class:`myokit.Protocol` objects can be used
+        to run with multiple protocols. Finally, can be ``None`` to run without
+        a protocol.
     ``sensitivities``
         An optional tuple ``(dependents, independents)`` where ``dependents``
         is a list of variables or expressions to take derivatives of (``y`` in
@@ -149,7 +149,7 @@ class Simulation(myokit.CModule):
     _index = 0  # Simulation id
 
     def __init__(self, model, protocol=None, sensitivities=None, path=None):
-        super(Simulation, self).__init__()
+        super().__init__()
 
         # Require a valid model
         if not model.is_valid():
@@ -158,15 +158,34 @@ class Simulation(myokit.CModule):
         del model
 
         # Set protocol
-        self._protocol = None
-        self._fixed_form_protocol = None
-        self.set_protocol(protocol)
-        del protocol
+        self._protocols = []
+        self._pacing_labels = []
+        if isinstance(protocol, (myokit.Protocol, myokit.TimeSeriesProtocol)):
+            protocol = {'pace': protocol}
+        elif protocol is None:
+            # TODO: This can be an empty dict once #320 is resolved
+            protocol = {'pace': None}
+        for label, protocol in protocol.items():
+            self._pacing_labels.append(label)
+            self._protocols.append(myokit.Protocol())
+            self.set_protocol(protocol, label)
 
         # Generate C Model code, get sensitivity and constants info
-        cmodel = myokit.CModel(self._model, sensitivities)
+        cmodel = myokit.CModel(self._model, self._pacing_labels, sensitivities)
         if cmodel.has_sensitivities:
             self._sensitivities = (cmodel.dependents, cmodel.independents)
+
+            # Check for sensitivities w.r.t. variables used in initial state
+            # expressions. This is not implemented yet.
+            inits = self._model.initial_values()
+            for i in self._sensitivities[1]:  # Expressions
+                if isinstance(i, myokit.Name):
+                    for e in inits:
+                        if e.depends_on(i, deep=True):
+                            raise NotImplementedError(
+                                'Sensitivities with respect to parameters used'
+                                ' in initial conditions is not implemented ('
+                                + e.code() + ' depends on ' + i.code() + ').')
         else:
             self._sensitivities = None
 
@@ -186,19 +205,19 @@ class Simulation(myokit.CModule):
         del cmodel
 
         # Get state and default state from model
-        self._state = self._model.state()
+        self._state = self._model.initial_values(as_floats=True)
         self._default_state = list(self._state)
 
         # Set state and default state for sensitivities
         self._s_state = self._s_default_state = None
         if self._sensitivities:
-            # Outer indice: number of independent variables
-            # Inner indice: number of states
+            # Outer index: number of independent variables
+            # Inner index: number of states
             self._s_state = []
             for expr in self._sensitivities[1]:
                 row = [0.0] * len(self._state)
                 if isinstance(expr, myokit.InitialValue):
-                    row[expr.var().indice()] = 1.0
+                    row[expr.var().index()] = 1.0
                 self._s_state.append(row)
             self._s_default_state = [list(x) for x in self._s_state]
 
@@ -281,13 +300,14 @@ class Simulation(myokit.CModule):
             if self._sensitivities:
                 sens_arg = [[x.code() for x in y] for y in self._sensitivities]
 
-            # Store serialised name and constructor args
+            # Store serialized name and constructor args
             fname = os.path.join(d_build, '_simulation.pickle')
             import pickle
             with open(fname, 'wb') as f:
                 pickle.dump(str(name), f)
                 pickle.dump(self._model, f)
-                pickle.dump(self._protocol, f)
+                pickle.dump(self._protocols, f)
+                pickle.dump(self._pacing_labels, f)
                 pickle.dump(sens_arg, f)
 
             # Zip it all in
@@ -327,13 +347,14 @@ class Simulation(myokit.CModule):
             with zipfile.ZipFile(path, 'r', zipfile.ZIP_DEFLATED) as f:
                 f.extractall(d_build)
 
-            # Load serialised name and constructor args
+            # Load serialized name and constructor args
             fname = os.path.join(d_build, '_simulation.pickle')
             import pickle
             with open(fname, 'rb') as f:
                 name = pickle.load(f)
                 model = pickle.load(f)
-                protocol = pickle.load(f)
+                protocols = pickle.load(f)
+                pacing_labels = pickle.load(f)
                 sensitivities = pickle.load(f)
 
             # Load module
@@ -341,7 +362,12 @@ class Simulation(myokit.CModule):
             module = load_module(name, d_build)
 
             # Create and return simulation
-            return Simulation(model, protocol, sensitivities, (path, module))
+            labeled_protocols = {
+                k: v for k, v in zip(pacing_labels, protocols)
+            }
+            return Simulation(
+                model, labeled_protocols, sensitivities, (path, module)
+            )
 
         finally:
             myokit.tools.rmtree(d_build, silent=True)
@@ -372,12 +398,16 @@ class Simulation(myokit.CModule):
         """
         return list(self._error_state) if self._error_state else None
 
-    def eval_derivatives(self, y=None):
+    def eval_derivatives(self, y=None, pacing=None):
         """
         Evaluates and returns the state derivatives.
 
         The state to evaluate for can be given as ``y``. If no state is given
         the current simulation state is used.
+
+        An optional dict ``pacing`` can be passed in that maps labels to
+        numerical values. If a label is used but not provided in ``pacing``,
+        it's value will be set to 0.
         """
         # Get state
         if y is None:
@@ -385,6 +415,15 @@ class Simulation(myokit.CModule):
         else:
             y = self._model.map_to_state(y)
 
+        pacing_values = [0.0] * len(self._pacing_labels)
+        if pacing is not None:
+            for k, v in pacing.items():
+                try:
+                    ki = self._pacing_labels.index(k)
+                    pacing_values[ki] = float(v)
+                except ValueError:
+                    pass
+
         # Create space to store derivatives
         dy = list(self._state)
 
@@ -393,7 +432,7 @@ class Simulation(myokit.CModule):
             # 0. Time
             0,
             # 1. Pace
-            0,
+            pacing_values,
             # 2. State
             y,
             # 3. Space to store the state derivatives
@@ -467,7 +506,7 @@ class Simulation(myokit.CModule):
             for i, expr in enumerate(self._sensitivities[1]):
                 if isinstance(expr, myokit.InitialValue):
                     self._s_state[i] = [0.0] * len(self._state)
-                    self._s_state[i][expr.var().indice()] = 1.0
+                    self._s_state[i][expr.var().index()] = 1.0
             # Update default state
             self._s_default_state = [list(x) for x in self._s_state]
 
@@ -484,16 +523,19 @@ class Simulation(myokit.CModule):
             # etc.
             sens_arg = [[x.code() for x in y] for y in self._sensitivities]
 
+        protocols = {
+            k: p for k, p in zip(self._pacing_labels, self._protocols)
+        }
+
         return (
             self.__class__,
-            (self._model, self._protocol, sens_arg),
+            (self._model, protocols, sens_arg),
             (
                 self._time,
                 self._state,
                 self._default_state,
                 self._s_state,
                 self._s_default_state,
-                self._fixed_form_protocol,  # Can't be set in constructor
                 self._tolerance,
                 self._dtmin,
                 self._dtmax,
@@ -601,8 +643,8 @@ class Simulation(myokit.CModule):
 
         However, if sensitivity calculations are enabled a tuple is returned,
         where the first entry is the :class:`myokit.DataLog` and the second
-        entry is a matrix of sensitivities ``dy/dx``, where the first indice
-        specifies the dependent variable ``y``, and the second indice specifies
+        entry is a matrix of sensitivities ``dy/dx``, where the first index
+        specifies the dependent variable ``y``, and the second index specifies
         the independent variable ``x``.
 
         Finally, if APD calculation is enabled, the method returns a tuple
@@ -671,7 +713,7 @@ class Simulation(myokit.CModule):
 
         # APD measuring
         root_list = None
-        root_indice = 0
+        root_index = 0
         root_threshold = 0
         if apd_variable is None:
             if apd_threshold is not None:
@@ -688,7 +730,7 @@ class Simulation(myokit.CModule):
 
             # Set up root finding
             root_list = []
-            root_indice = apd_variable.indice()
+            root_index = apd_variable.index()
             root_threshold = float(apd_threshold)
 
         # Get progress indication function (if any)
@@ -721,7 +763,7 @@ class Simulation(myokit.CModule):
                 s_state = [list(x) for x in self._s_state]
 
             # List to store final bound variables in (for debugging)
-            bound = [0, 0, 0, 0]
+            bound = [0, 0, 0] + [0] * len(self._pacing_labels)
 
             # Initialize
             if myokit.DEBUG_SP:
@@ -741,30 +783,28 @@ class Simulation(myokit.CModule):
                 list(self._literals.values()),
                 # 6. Parameter values
                 list(self._parameters.values()),
-                # 7. An event-based pacing protocol
-                self._protocol,
-                # 8. A fixed-form protocol
-                self._fixed_form_protocol,
-                # 9. A DataLog
+                # 7. Pacing protocols
+                self._protocols,
+                # 8. A DataLog
                 log,
-                # 10. The log interval, or 0
+                # 9. The log interval, or 0
                 log_interval,
-                # 11. A list of predetermind logging times, or None
+                # 10. A list of predetermind logging times, or None
                 log_times,
-                # 12. A list to store calculated sensitivities in
+                # 11. A list to store calculated sensitivities in
                 sensitivities,
-                # 13. The state variable indice for root finding (only used if
+                # 12. The state variable index for root finding (only used if
                 #     root_list is a list)
-                root_indice,
-                # 14. The threshold for root crossing (can be 0 too, only used
+                root_index,
+                # 13. The threshold for root crossing (can be 0 too, only used
                 #     if root_list is a list).
                 root_threshold,
-                # 15. A list to store calculated root crossing times and
+                # 14. A list to store calculated root crossing times and
                 #     directions in, or None
                 root_list,
-                # 16. A myokit.tools.Benchmarker or None (if not used)
+                # 15. A myokit.tools.Benchmarker or None (if not used)
                 b,
-                # 17. Boolean/int: 1 if we are logging realtime
+                # 16. Boolean/int: 1 if we are logging realtime
                 int(self._model.binding('realtime') is not None),
             )
             t = tmin
@@ -800,9 +840,12 @@ class Simulation(myokit.CModule):
                             in self._model.format_state(state).splitlines()])
                 txt.append('Inputs for binding:')
                 txt.append('  time        = ' + myokit.float.str(bound[0]))
-                txt.append('  pace        = ' + myokit.float.str(bound[1]))
-                txt.append('  realtime    = ' + myokit.float.str(bound[2]))
-                txt.append('  evaluations = ' + myokit.float.str(bound[3]))
+                txt.append('  realtime    = ' + myokit.float.str(bound[1]))
+                txt.append('  evaluations = ' + myokit.float.str(bound[2]))
+                for i, label in enumerate(self._pacing_labels):
+                    txt.append(
+                        '  ' + label + ' = ' + myokit.float.str(bound[3 + i])
+                    )
                 txt.append(str(e))
 
                 # Check if state derivatives can be evaluated in Python, if
@@ -903,7 +946,7 @@ class Simulation(myokit.CModule):
 
     def set_default_state(self, state):
         """
-        Allows you to manually set the default state.
+        Change the default state to ``state``.
         """
         self._default_state = self._model.map_to_state(state)
 
@@ -939,66 +982,51 @@ class Simulation(myokit.CModule):
 
     def set_fixed_form_protocol(self, times=None, values=None):
         """
-        Configures this simulation to run with a predetermined protocol
-        instead of the usual event-based mechanism.
-
-        A 1D time-series should be given as input. During the simulation, the
-        value of the pacing variable will be determined by linearly
-        interpolating between the two nearest points in the series. If the
-        simulation time is outside the bounds of the time-series, the first or
-        last value in the series will be used.
-
-        Setting a predetermined protocol clears any previously set (event-based
-        or pre-determined) protocol. To clear all protocols, call this method
-        with `times=None`. When a simulation is run without any protocol, the
-        value of any variables bound to `pace` will be set to 0.
-
-        Arguments:
-
-        ``times``
-            A non-decreasing array of times. If any times appear more than
-            once, only the value at the highest index will be used.
-        ``values``
-            An array of values for the pacing variable. Must have the same size
-            as ``times``.
+        Sets a :class:`TimeSeriesProtocol` specified by ``times`` and
+        ``values`` for the label ``pace``.
 
+        This method is provided for backwards compatibility with older
+        versions, please use :meth:`set_protocol` and the
+        :class:`TimeSeriesProtocol` class instead.
         """
-        # Check input
-        if times is None:
-            if values is not None:
-                raise ValueError('Values array given, but no times array.')
-        else:
-            if values is None:
-                raise ValueError('Times array given, but no values array.')
-            if len(times) != len(values):
-                raise ValueError('Times and values array must have same size.')
-
-        # Clear event-based protocol, if set
-        self._protocol = None
+        # Deprecated on 2023-06-02
+        import warnings
+        warnings.warn(
+            'The method `myokit.Simulation.set_fixed_form_protocol` is '
+            'deprecated. It will be removed in future versions of Myokit.'
+        )
 
-        # Set new protocol
+        if times is None and values is None:
+            self.set_protocol(None)
+            return
         if times is None:
-            # Clear predetermined protocol
-            self._fixed_form_protocol = None
-        else:
-            # Copy data and set
-            self._fixed_form_protocol = (list(times), list(values))
+            raise ValueError('No times given.')
+        if values is None:
+            raise ValueError('No values given.')
+
+        self.set_protocol(myokit.TimeSeriesProtocol(times, values))
 
-    def set_protocol(self, protocol=None):
+    def set_protocol(self, protocol, label='pace'):
         """
-        Sets the pacing :class:`Protocol` used by this simulation.
+        Set an event-based pacing :class:`Protocol` or a :class:`FixedProtocol`
+        for the given ``label``.
 
-        To run without pacing call this method with ``protocol = None``. In
-        this case, the value of any variables bound to `pace` will be set to 0.
+        To remove a previously set binding call this method with ``protocol =
+        None``. In this case, the value of any variables bound to ``label``
+        will be set to 0.
+
+        The label must be one of the pacing labels set in the constructor.
         """
-        # Clear predetermined protocol, if set
-        self._fixed_form_protocol = None
+        try:
+            index = self._pacing_labels.index(label)
+        except ValueError:
+            raise ValueError('Unknown pacing label: ' + str(label))
 
         # Set new protocol
         if protocol is None:
-            self._protocol = None
+            self._protocols[index] = myokit.Protocol()
         else:
-            self._protocol = protocol.clone()
+            self._protocols[index] = protocol.clone()
 
     def __setstate__(self, state):
         """
@@ -1012,13 +1040,12 @@ class Simulation(myokit.CModule):
         self._default_state = state[2]
         self._s_state = state[3]
         self._s_default_state = state[4]
-        self._fixed_form_protocol = state[5]
 
         # The following properties need to be set on the internal simulation
         # object
-        self.set_tolerance(*state[6])
-        self.set_min_step_size(state[7])
-        self.set_max_step_size(state[8])
+        self.set_tolerance(*state[5])
+        self.set_min_step_size(state[6])
+        self.set_max_step_size(state[7])
 
     def set_state(self, state):
         """

myokit/_sim/differential.hpp

@@ -18,8 +18,8 @@
  *
  *   // Create a and b as differentials. Both have derivative 1 with respect to
  *   // themselves. This can be indicated explicitly or, as in this example,
- *   // using the constructor arguments (value, indice) where indice is the
- *   // indice of this variable in the list of derivatives.
+ *   // using the constructor arguments (value, index) where index is the
+ *   // index of this variable in the list of derivatives.
  *   Diff a = Diff(2, 0);
  *   Diff b = Diff(3, 1);
  *   Diff x = 5 * a + pow(b, 2);
@@ -67,8 +67,8 @@
     static const unsigned long __nan[2] = {0xffffffff, 0x7fffffff};
     #define NAN (*(const float *) __nan)
 #endif
- 
- 
+
+
 /*
  * Covector. A tiny, fixed size array class that allows addition and scalar
  * multiplication.

myokit/_sim/fiber_tissue.c

@@ -542,9 +542,7 @@ sim_init(PyObject* self, PyObject* args)
     for(i=0; i < nfx * nfy * n_state_f; i++) {
         flt = PyList_GetItem(state_in_f, i);    // Don't decref!
         if(!PyFloat_Check(flt)) {
-            char errstr[200];
-            sprintf(errstr, "Item %u in fiber state vector is not a float.", (unsigned int)i);
-            PyErr_SetString(PyExc_Exception, errstr);
+            PyErr_Format(PyExc_Exception, "Item %u in fiber state vector is not a float.", (unsigned int)i);
             return sim_clean();
         }
         rvec_state_f[i] = (Real)PyFloat_AsDouble(flt);
@@ -558,9 +556,7 @@ sim_init(PyObject* self, PyObject* args)
     for(i=0; i < ntx * nty * n_state_t; i++) {
         flt = PyList_GetItem(state_in_t, i);
         if(!PyFloat_Check(flt)) {
-            char errstr[200];
-            sprintf(errstr, "Item %u in tissue state vector is not a float.", (unsigned int)i);
-            PyErr_SetString(PyExc_Exception, errstr);
+            PyErr_Format(PyExc_Exception, "Item %u in tissue state vector is not a float.", (unsigned int)i);
             return sim_clean();
         }
         rvec_state_t[i] = (Real)PyFloat_AsDouble(flt);
@@ -874,7 +870,7 @@ if var is not None:
 <?
 for var in modelf.states():
     print(3*tab + 'sprintf(log_var_name, "%u.%u.' + var.qname() + '", (unsigned int)j, (unsigned int)i);' )
-    print(3*tab + 'if(log_add(log_dict_f, logs_f, vars_f, k_vars, log_var_name, &rvec_state_f[(i*nfx+j)*n_state_f+' + str(var.indice()) + '])) {')
+    print(3*tab + 'if(log_add(log_dict_f, logs_f, vars_f, k_vars, log_var_name, &rvec_state_f[(i*nfx+j)*n_state_f+' + str(var.index()) + '])) {')
     print(4*tab + 'logging_states_f = 1;')
     print(4*tab + 'k_vars++;')
     print(3*tab + '}')
@@ -945,7 +941,7 @@ if var is not None:
 <?
 for var in modelt.states():
     print(3*tab + 'sprintf(log_var_name, "%u.%u.' + var.qname() + '", (unsigned int)j, (unsigned int)i);' )
-    print(3*tab + 'if(log_add(log_dict_t, logs_t, vars_t, k_vars, log_var_name, &rvec_state_t[(i*ntx+j)*n_state_t+' + str(var.indice()) + '])) {')
+    print(3*tab + 'if(log_add(log_dict_t, logs_t, vars_t, k_vars, log_var_name, &rvec_state_t[(i*ntx+j)*n_state_t+' + str(var.index()) + '])) {')
     print(4*tab + 'logging_states_t = 1;')
     print(4*tab + 'k_vars++;')
     print(3*tab + '}')

myokit/_sim/fiber_tissue.py

@@ -4,13 +4,11 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import os
-import myokit
 import platform
 
+import myokit
+
 # Location of C and OpenCL sources
 SOURCE_FILE = 'fiber_tissue.c'
 KERNEL_FILE = 'openclsim.cl'
@@ -60,7 +58,7 @@ class FiberTissueSimulation(myokit.CModule):
     ``pace`` (per-cell)
         The pacing level, this is set if a protocol was passed in.
     ``diffusion_current`` (per-cell)
-        The current flowing from the cell to its neighbours. This will be
+        The current flowing from the cell to its neighbors. This will be
         positive when the cell is acting as a source, negative when it is
         acting as a sink.
 
@@ -122,7 +120,7 @@ class FiberTissueSimulation(myokit.CModule):
             ncells_fiber=(128, 2), ncells_tissue=(128, 128), nx_paced=5,
             g_fiber=(9, 6), g_tissue=(9, 6), g_fiber_tissue=9,
             dt=0.005, precision=myokit.SINGLE_PRECISION, native_maths=False):
-        super(FiberTissueSimulation, self).__init__()
+        super().__init__()
 
         # Deprecated since 2021-05-28
         # Un-deprecated on 2022-04-20, following Adam's request
@@ -303,19 +301,19 @@ class FiberTissueSimulation(myokit.CModule):
                 ' and the tissue model: ' + str(ucf) + ' vs ' + str(uct) + '.')
 
         # Set state and default state
-        self._statef = self._modelf.state() * self._ntotalf
-        self._statet = self._modelt.state() * self._ntotalt
+        self._statef = self._modelf.initial_values(True) * self._ntotalf
+        self._statet = self._modelt.initial_values(True) * self._ntotalt
         self._default_statef = list(self._statef)
         self._default_statet = list(self._statet)
 
         # Process bindings, remove unsupported bindings, get map of bound
         # variables to internal names.
-        self._bound_variablesf = self._modelf.prepare_bindings({
+        self._bound_variablesf = myokit._prepare_bindings(self._modelf, {
             'time': 'time',
             'pace': 'pace',
             'diffusion_current': 'idiff',
         })
-        self._bound_variablest = self._modelt.prepare_bindings({
+        self._bound_variablest = myokit._prepare_bindings(self._modelt, {
             'time': 'time',
             'pace': 'pace',
             'diffusion_current': 'idiff',
@@ -676,7 +674,7 @@ class FiberTissueSimulation(myokit.CModule):
 
         # Get value causing error
         if var.is_state():
-            value = states[1 if ifirst > 0 else 0][var.indice()]
+            value = states[1 if ifirst > 0 else 0][var.index()]
         else:
             value = bound[1 if ifirst > 0 else 0][var.qname()]
         var = var.qname()
@@ -909,8 +907,8 @@ class FiberTissueSimulation(myokit.CModule):
                 self._ncellsf[1],
                 self._ncellst[0],
                 self._ncellst[1],
-                self._vmf.indice(),
-                self._vmt.indice(),
+                self._vmf.index(),
+                self._vmt.index(),
                 self._gf[0],
                 self._gf[1],
                 self._gt[0],

myokit/_sim/jacobian.cpp

@@ -70,12 +70,12 @@ typedef FirstDifferential Diff;
 <?
 print('// Aliases of state variable derivatives')
 for var in model.states():
-    print('#define ' + v(var.lhs()) + ' deriv[' + str(var.indice()) + ']')
+    print('#define ' + v(var.lhs()) + ' deriv[' + str(var.index()) + ']')
 print('')
 
 print('// Aliases of state variable values')
 for var in model.states():
-    print('#define ' + v(var) + ' state[' + str(var.indice()) + ']')
+    print('#define ' + v(var) + ' state[' + str(var.index()) + ']')
 print('')
 
 print('// Aliases of input variables')

myokit/_sim/jacobian.py

@@ -4,14 +4,13 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import os
-import myokit
-import numpy as np
 import platform
 
+import numpy as np
+
+import myokit
+
 # Location of C source file
 SOURCE_FILE = 'jacobian.cpp'
 
@@ -45,7 +44,7 @@ class JacobianTracer(myokit.CppModule):
     _index = 0  # Unique id
 
     def __init__(self, model):
-        super(JacobianTracer, self).__init__()
+        super().__init__()
 
         # Require a valid model
         model.validate()
@@ -216,13 +215,17 @@ class JacobianCalculator(myokit.CppModule):
     _index = 0  # Unique id
 
     def __init__(self, model):
-        super(JacobianCalculator, self).__init__()
+        super().__init__()
         # Require a valid model
         model.validate()
 
         # Clone model
         self._model = model.clone()
 
+        # Store the initial values (won't be able to access once time binding
+        # is removed).
+        self._state = self._model.initial_values(as_floats=True)
+
         # Unbind all inputs
         for label, var in self._model.bindings():
             var.set_binding(None)
@@ -310,7 +313,7 @@ class JacobianCalculator(myokit.CppModule):
 
         # Get initial state
         if x is None:
-            x = self._model.state()
+            x = self._state
         x = np.array(x)
 
         # Calculate derivatives & jacobian