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

myokit/_sim/cmodel.h

@@ -45,7 +45,8 @@ States:
 State derivatives:
     Calculated by the model.
 Bound variables:
-    External inputs to the model (e.g. time and pacing).
+    External inputs to the model (e.g. time and pacing). There are an arbitrary
+    number of these, and the model stores the current value of each
 Intermediary variables:
     The remaining variables that depend on state variables.
 Constants:
@@ -153,7 +154,7 @@ will be a myokit.DataLog.
 
 Methods:
 
-Model_InitialiseLogging(Model model, PyObject* log_dict)
+Model_InitializeLogging(Model model, PyObject* log_dict)
     Sets up logging for all variables used as keys in log_dict (assuming fully
     qualified names). Will raise an error if the dict contains keys that do not
     correspond to model variables. The values in the dict should implement the
@@ -163,9 +164,9 @@ Model_Log(model)
     If logging has been set up, this will log the current values of variables
     to the sequences in the log dict.
 
-Model_DeInitialiseLogging(model)
-    De-initialises logging. This only needs to be called if logging needs to be
-    set up differently, i.e. before a new call to Model_InitialiseLogging.
+Model_DeInitializeLogging(model)
+    De-initializes logging. This only needs to be called if logging needs to be
+    set up differently, i.e. before a new call to Model_InitializeLogging.
 
 Logging sensitivities
 =====================
@@ -207,13 +208,15 @@ typedef int Model_Flag;
 /* General */
 #define Model_INVALID_MODEL                 -100
 /* Logging */
-#define Model_LOGGING_ALREADY_INITIALISED   -200
-#define Model_LOGGING_NOT_INITIALISED       -201
+#define Model_LOGGING_ALREADY_INITIALIZED   -200
+#define Model_LOGGING_NOT_INITIALIZED       -201
 #define Model_UNKNOWN_VARIABLES_IN_LOG      -202
 #define Model_LOG_APPEND_FAILED             -203
 /* Logging sensitivities */
 #define Model_NO_SENSITIVITIES_TO_LOG       -300
 #define Model_SENSITIVITY_LOG_APPEND_FAILED -303
+/* Pacing */
+#define Model_INVALID_PACING                -400
 
 /* Caching doesn't help much when running without jacobians etc., so disabled
    for now
@@ -240,11 +243,11 @@ Model_SetPyErr(Model_Flag flag)
         PyErr_SetString(PyExc_Exception, "CModel error: Invalid model pointer provided.");
         break;
     /* Logging */
-    case Model_LOGGING_ALREADY_INITIALISED:
-        PyErr_SetString(PyExc_Exception, "CModel error: Logging initialised twice.");
+    case Model_LOGGING_ALREADY_INITIALIZED:
+        PyErr_SetString(PyExc_Exception, "CModel error: Logging initialized twice.");
         break;
-    case Model_LOGGING_NOT_INITIALISED:
-        PyErr_SetString(PyExc_Exception, "CModel error: Logging not initialised.");
+    case Model_LOGGING_NOT_INITIALIZED:
+        PyErr_SetString(PyExc_Exception, "CModel error: Logging not initialized.");
         break;
     case Model_UNKNOWN_VARIABLES_IN_LOG:
         PyErr_SetString(PyExc_Exception, "CModel error: Unknown variables found in logging dictionary.");
@@ -259,7 +262,9 @@ Model_SetPyErr(Model_Flag flag)
     case Model_SENSITIVITY_LOG_APPEND_FAILED:
         PyErr_SetString(PyExc_Exception, "CModel error: Call to append() failed on sensitivity matrix logging list.");
         break;
-
+    case Model_INVALID_PACING:
+        PyErr_SetString(PyExc_Exception, "CModel error: Invalid pacing provided.");
+        break;
     /* Unknown */
     default:
         PyErr_Format(PyExc_Exception, "CModel error: Unlisted error %d", (int)flag);
@@ -277,9 +282,12 @@ struct Model_Memory {
     /* If this model has sensitivities this will be 1, otherwise 0. */
     int has_sensitivities;
 
+    /* Pacing */
+    realtype *pace_values;
+    int n_pace;
+
     /* Bound variables */
     realtype time;
-    realtype pace;
     realtype realtime;
     realtype evaluations;
 
@@ -326,8 +334,8 @@ struct Model_Memory {
     int ns_intermediary;
     realtype* s_intermediary;
 
-    /* Logging initialised? */
-    int logging_initialised;
+    /* Logging initialized? */
+    int logging_initialized;
 
     /* Which variables are we logging? */
     int logging_states;
@@ -444,6 +452,41 @@ Model_ClearCache(Model model)
     return Model_OK;
 }
 
+/*
+ * Sets up (i.e. allocates memory for) array of protocol-determined values
+ *
+ * Arguments
+ *  n_pace: the number of pacing values to use.
+ *
+ * Returns a model flag.
+ *
+ */
+Model_Flag
+Model_SetupPacing(Model model, int n_pace)
+{
+    if (model == NULL) return Model_INVALID_MODEL;
+    if (n_pace < 0) return Model_INVALID_PACING;
+
+    /* Free any existing pacing */
+    if (model->n_pace > 0) {
+        free(model->pace_values);
+    }
+
+    /* Allocate new pacing */
+    model->n_pace = n_pace;
+    model->pace_values = (realtype*)malloc((size_t)n_pace * sizeof(realtype));
+    if (model->pace_values == NULL) {
+        return Model_OUT_OF_MEMORY;
+    }
+
+    /* Clear values */
+    for (int i = 0; i < n_pace; i++) {
+        model->pace_values[i] = 0;
+    }
+
+    return Model_OK;
+}
+
 /*
  * (Re)calculates the values of all constants that are derived from other
  * constants.
@@ -503,14 +546,14 @@ for eq in parameter_derived.values():
  *  literals : An array of size model->n_literals
  *
  * Returns a model flag.
- */
+ *
 Model_Flag
 Model_SetLiteralVariables(Model model, const realtype* literals)
 {
     int i;
     if (model == NULL) return Model_INVALID_MODEL;
 
-    /* Scan for changes */
+    * Scan for changes *
     i = 0;
     #ifdef Model_CACHING
     if (Model__ValidCache(model)) {
@@ -522,7 +565,7 @@ Model_SetLiteralVariables(Model model, const realtype* literals)
     }
     #endif
 
-    /* Update remaining */
+    * Update remaining *
     if (i < model->n_literals) {
         for (; i<model->n_literals; i++) {
             model->literals[i] = literals[i];
@@ -535,7 +578,7 @@ Model_SetLiteralVariables(Model model, const realtype* literals)
     }
 
     return Model_OK;
-}
+}*/
 
 /*
  * Updates the parameter variables to the values given in `parameters`.
@@ -657,25 +700,35 @@ Model_SetParametersFromIndependents(Model model, const realtype* independents)
 Model_Flag
 Model_SetBoundVariables(
     Model model,
-    const realtype time, const realtype pace,
-    const realtype realtime, const realtype evaluations)
+    const realtype time,
+    const realtype *pace_values,
+    const realtype realtime,
+    const realtype evaluations)
 {
+    #ifdef Model_CACHING
     int changed;
+    #endif
     if (model == NULL) return Model_INVALID_MODEL;
 
+    #ifdef Model_CACHING
     changed = 0;
+    #endif
     if (time != model->time) {
         model->time = time;
+        #ifdef Model_CACHING
         changed = 1;
+        #endif
+    }
+
+    for (int i = 0; i < model->n_pace; i++) {
+        if (pace_values[i] != model->pace_values[i]) {
+            model->pace_values[i] = pace_values[i];
+            #ifdef Model_CACHING
+            changed = 1;
+            #endif
+        }
     }
 
-<?
-if model.binding('pace') is not None:
-    print(tab + 'if (pace != model->pace) {')
-    print(tab + '    model->pace = pace;')
-    print(tab + '    changed = 1;')
-    print(tab + '}')
-?>
     #ifdef Model_CACHING
     if (changed) {
         Model__InvalidateCache(model);
@@ -690,7 +743,7 @@ if model.binding('pace') is not None:
 }
 
 /*
- * Updates the state variables to the values given in `states`.
+ * Updates the state variables to the float values given in `states`.
  *
  * If any of the values are changed, the model caches are cleared.
  *
@@ -865,13 +918,11 @@ for eqs in s_output_equations:
  * Private method: Add a variable to the logging lists. Returns 1 if
  * successful.
  *
- * Note: The variable names are all ascii compatible. In Python2, the strings
- * inside log_dict are either unicode or bytes, but they can be matched
- * without conversion.
+ * Note: The variable names are all ascii compatible.
  *
  * Arguments
  *  log_dict : A dictionary mapping variable names to sequences.
- *  i : The next indice to add logs and vars.
+ *  i : The next index to add logs and vars.
  *  name : The name to check.
  *  var : A pointer to the variable.
  *
@@ -893,30 +944,30 @@ Model__AddVariableToLog(
 }
 
 /*
- * Initialises logging, using the given dict. An error is returned if logging
- * is already initialised.
+ * Initializes logging, using the given dict. An error is returned if logging
+ * is already initialized.
  *
  * Arguments
- *  model : The model whose logging system to initialise.
+ *  model : The model whose logging system to initialize.
  *  log_dict : A Python dict mapping fully qualified variable names to sequence
  *             objects to log in.
  *
  * Returns a model flag
  */
 Model_Flag
-Model_InitialiseLogging(Model model, PyObject* log_dict)
+Model_InitializeLogging(Model model, PyObject* log_dict)
 {
     int i, j;
 
     if (model == NULL) return Model_INVALID_MODEL;
-    if (model->logging_initialised) return Model_LOGGING_ALREADY_INITIALISED;
+    if (model->logging_initialized) return Model_LOGGING_ALREADY_INITIALIZED;
 
     /* Number of variables to log */
-    model->n_logged_variables = PyDict_Size(log_dict);
+    model->n_logged_variables = (int)PyDict_Size(log_dict);
 
     /* Allocate pointer lists */
-    model->_log_lists = (PyObject**)malloc(sizeof(PyObject*) * model->n_logged_variables);
-    model->_log_vars = (realtype**)malloc(sizeof(realtype*) * model->n_logged_variables);
+    model->_log_lists = (PyObject**)malloc((size_t)model->n_logged_variables * sizeof(PyObject*));
+    model->_log_vars = (realtype**)malloc((size_t)model->n_logged_variables * sizeof(realtype*));
 
     /* Check states */
     i = 0;
@@ -959,24 +1010,24 @@ for var in model.variables(deep=True, state=False, bound=False, const=False):
     }
 
     /* All done! */
-    model->logging_initialised = 1;
+    model->logging_initialized = 1;
     return Model_OK;
 }
 
 /*
- * De-initialises logging, undoing the effects of Model_InitialiseLogging() and
- * allowing logging to be initialised again.
+ * De-initializes logging, undoing the effects of Model_InitializeLogging() and
+ * allowing logging to be initialized again.
  *
  * Arguments
- *  model : The model whos logging to deinitialise.
+ *  model : The model whos logging to deinitialize.
  *
  * Returns a model flag.
  */
 Model_Flag
-Model_DeInitialiseLogging(Model model)
+Model_DeInitializeLogging(Model model)
 {
     if (model == NULL) return Model_INVALID_MODEL;
-    if (!model->logging_initialised) return Model_LOGGING_NOT_INITIALISED;
+    if (!model->logging_initialized) return Model_LOGGING_NOT_INITIALIZED;
 
     /* Free memory */
     if (model->_log_vars != NULL) {
@@ -989,7 +1040,7 @@ Model_DeInitialiseLogging(Model model)
     }
 
     /* Reset */
-    model->logging_initialised = 0;
+    model->logging_initialized = 0;
     model->n_logged_variables = 0;
     model->logging_states = 0;
     model->logging_derivatives = 0;
@@ -1001,7 +1052,7 @@ Model_DeInitialiseLogging(Model model)
 
 /*
  * Logs the current state of the model to the logging dict passed in to
- * Model_InitialiseLogging.
+ * Model_InitializeLogging.
  *
  * Note: This method does not update the state in any way, e.g. to make sure
  * that what is logged is sensible.
@@ -1018,7 +1069,7 @@ Model_Log(Model model)
     PyObject *val, *ret;
 
     if (model == NULL) return Model_INVALID_MODEL;
-    if (!model->logging_initialised) return Model_LOGGING_NOT_INITIALISED;
+    if (!model->logging_initialized) return Model_LOGGING_NOT_INITIALIZED;
 
     for (i=0; i<model->n_logged_variables; i++) {
         val = PyFloat_FromDouble(*(model->_log_vars[i]));
@@ -1037,8 +1088,8 @@ Model_Log(Model model)
  * Creates a matrix of sensitivities and adds it to a Python sequence.
  *
  * The created matrix is a (Python) tuple of tuples, where the first (outer)
- * indice is for the dependent variable (y in dy/dx) and the second (inner)
- * indice is for the independent variable (x in dy/dx).
+ * index is for the dependent variable (y in dy/dx) and the second (inner)
+ * index is for the independent variable (x in dy/dx).
  *
  * model : The model whose sensitivities to log (must have sensitivity
  *         calculations enabled).
@@ -1050,13 +1101,14 @@ Model_Flag
 Model_LogSensitivityMatrix(Model model, PyObject* list)
 {
     PyObject *l1, *l2;
-    PyObject *val;
     int flag;
+    <?= 'PyObject *val;' if s_dependents else '' ?>
 
     if (model == NULL) return Model_INVALID_MODEL;
 
     /* Create outer tuple */
     l1 = PyTuple_New(model->ns_dependents);
+    l2 = NULL;  /* Removes "may be unitialized" error */
     if (l1 == NULL) goto nomem;
 
     /* Note that PyTuple_SetItem steals a reference */
@@ -1119,24 +1171,28 @@ Model Model_Create(Model_Flag* flagp)
 
     /* States and derivatives */
     model->n_states = <?= model.count_states() ?>;
-    model->states = (realtype*)malloc(model->n_states * sizeof(realtype));
-    model->derivatives = (realtype*)malloc(model->n_states * sizeof(realtype));
+    model->states = (realtype*)malloc((size_t)model->n_states * sizeof(realtype));
+    model->derivatives = (realtype*)malloc((size_t)model->n_states * sizeof(realtype));
 
     /* Intermediary variables */
     model->n_intermediary = <?= model.count_variables(inter=True, deep=True) ?>;
-    model->intermediary = (realtype*)malloc(model->n_intermediary * sizeof(realtype));
+    model->intermediary = (realtype*)malloc((size_t)model->n_intermediary * sizeof(realtype));
 
     /* Parameters */
     model->n_parameters = <?= len(parameters) ?>;
     model->n_parameter_derived = <?= len(parameter_derived) ?>;
-    model->parameters = (realtype*)malloc(model->n_parameters * sizeof(realtype));
-    model->parameter_derived = (realtype*)malloc(model->n_parameter_derived * sizeof(realtype));
+    model->parameters = (realtype*)malloc((size_t)model->n_parameters * sizeof(realtype));
+    model->parameter_derived = (realtype*)malloc((size_t)model->n_parameter_derived * sizeof(realtype));
+
+    /* Pacing */
+    model->n_pace = 0;
+    model->pace_values = NULL;
 
     /* Literals */
     model->n_literals = <?= len(literals) ?>;
     model->n_literal_derived = <?= len(literal_derived) ?>;
-    model->literals = (realtype*)malloc(model->n_literals * sizeof(realtype));
-    model->literal_derived = (realtype*)malloc(model->n_literal_derived * sizeof(realtype));
+    model->literals = (realtype*)malloc((size_t)model->n_literals * sizeof(realtype));
+    model->literal_derived = (realtype*)malloc((size_t)model->n_literal_derived * sizeof(realtype));
 
     /*
      * Sensitivities
@@ -1151,30 +1207,30 @@ Model Model_Create(Model_Flag* flagp)
     /* Pointers to independent variables */
     /* Note that, for sensitivities w.r.t. initial values, the entry in this
        list points to the _current_, not the initial value. */
-    model->s_independents = (realtype**)malloc(model->ns_independents * sizeof(realtype));
+    model->s_independents = (realtype**)malloc((size_t)model->ns_independents * sizeof(realtype));
 <?
 for i, expr in enumerate(s_independents):
     print(tab + 'model->s_independents[' + str(i) + '] = &' + v(expr.var()) + ';')
 ?>
     /* Type of independents (1 for parameter, 0 for initial) */
-    model->s_is_parameter = (int*)malloc(model->ns_independents * sizeof(int));
+    model->s_is_parameter = (int*)malloc((size_t)model->ns_independents * sizeof(int));
 <?
 for i, expr in enumerate(s_independents):
     print(tab + 'model->s_is_parameter[' + str(i) + '] = ' + str(1 if isinstance(expr, myokit.Name) else 0) + ';')
 ?>
     /* Sensitivities of state variables */
-    model->s_states = (realtype*)malloc(model->n_states * model->ns_independents * sizeof(realtype));
+    model->s_states = (realtype*)malloc((size_t)(model->n_states * model->ns_independents) * sizeof(realtype));
 
     /* Sensitivities of intermediary variables needed in calculations */
     model->ns_intermediary = <?= sum(len(x) for x in s_output_equations) ?>;
-    model->s_intermediary = (realtype*)malloc(model->ns_intermediary * sizeof(realtype));
+    model->s_intermediary = (realtype*)malloc((size_t)model->ns_intermediary * sizeof(realtype));
 
     /*
      * Logging
      */
 
     /* Logging configured? */
-    model->logging_initialised = 0;
+    model->logging_initialized = 0;
     model->n_logged_variables = 0;
 
     /* Logged variables and logged types */
@@ -1194,9 +1250,8 @@ for i, expr in enumerate(s_independents):
      * Default values
      */
 
-    /* Bound variables */
+    /* Bound variables (except pacing) */
     model->time = 0;
-    model->pace = 0;
     model->realtime = 0;
     model->evaluations = 0;
 
@@ -1222,10 +1277,10 @@ for eq in parameters.values():
         return NULL;
     }
 
-    /* States */
+    /* State values */
 <?
 for var in model.states():
-    print(tab + v(var) + ' = ' + myokit.float.str(var.state_value()) + ';')
+    print(tab + v(var) + ' = ' + myokit.float.str(var.initial_value(True)) + ';')
 ?>
     /*
      * Caching.
@@ -1238,7 +1293,7 @@ for var in model.states():
     #endif
 
     /*
-     * Finalise
+     * Finalize
      */
 
     /* Set flag to indicate success */

myokit/_sim/cmodel.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 traceback
 
@@ -21,7 +18,7 @@ import myokit.pype
 SOURCE_FILE = 'cmodel.h'
 
 
-class CModel(object):
+class CModel:
     """
     Generates ansi-C code for a model.
 
@@ -35,6 +32,9 @@ class CModel(object):
 
     ``model``
         A :class:`myokit.Model`.
+    ``pacing_labels``
+        A list of ``str`` variable labels, each corresponding to a paced
+        variable.
     ``sensitivities``
         Either ``None`` or a tuple ``(dependents, independents)``. See
         :class:`myokit.Simulation` for details.
@@ -76,7 +76,7 @@ class CModel(object):
         Constants that depend on literals, but not on parameters.
 
     """
-    def __init__(self, model, sensitivities):
+    def __init__(self, model, pacing_labels, sensitivities):
 
         # Parse sensitivity arguments
         has_sensitivities, dependents, independents = \
@@ -86,17 +86,15 @@ class CModel(object):
         # bother with keywords.
         model.create_unique_names()
 
-        # Remove any unused bindings, and get mapping from variables to C
-        # variable names as used in model.h
-        #TODO: Think about best way to do this for model re-use with different
-        # sets of bound variables... Presumably the model would simply support
-        # all bindings used by any of the simulations based on model.h ?
-        bound_variables = model.prepare_bindings({
+        # Get mapping from variables to C variable names as used in model.h
+        labels = {
             'time': 'time',
-            'pace': 'pace',
             'realtime': 'realtime',
             'evaluations': 'evaluations',
-        })
+        }
+        for i, label in enumerate(pacing_labels):
+            labels[label] = 'pace_values[' + str(i) + ']'
+        bound_variables = myokit._prepare_bindings(model, labels)
 
         # Get equations in solvable order (grouped by component)
         equations = model.solvable_order()
@@ -401,7 +399,7 @@ class CModel(object):
         """ Generates and returns the model code. """
 
         # Get states whose initial value is used in sensivitity calculations
-        initials = [p.var().indice() for p in independents
+        initials = [p.var().index() for p in independents
                     if isinstance(p, myokit.InitialValue)]
 
         # Arguments

myokit/_sim/compiler.py

@@ -4,9 +4,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 myokit
@@ -32,7 +29,7 @@ class Compiler(myokit.CModule):
     _compiler = None
 
     def __init__(self):
-        super(Compiler, self).__init__()
+        super().__init__()
         # Create and cache back-end
         Compiler._index += 1