myokit 1.35.4__py3-none-any.whl → 1.36.1__py3-none-any.whl

myokit/_sim/cvodessim.c

@@ -25,20 +25,26 @@ import myokit
 #include <Python.h>
 #include <stdio.h>
 
-#include <cvodes/cvodes.h>
-#include <nvector/nvector_serial.h>
-#include <sundials/sundials_types.h>
 #include <sundials/sundials_config.h>
 #ifndef SUNDIALS_VERSION_MAJOR
     #define SUNDIALS_VERSION_MAJOR 2
 #endif
+#include <sundials/sundials_types.h>
+#if SUNDIALS_VERSION_MAJOR >= 7
+    #define realtype sunrealtype
+    #define RCONST SUN_RCONST
+#endif
+#include <nvector/nvector_serial.h>
+#include <cvodes/cvodes.h>
 #if SUNDIALS_VERSION_MAJOR >= 3
     #include <sunmatrix/sunmatrix_dense.h>
     #include <sunlinsol/sunlinsol_dense.h>
-    #include <cvodes/cvodes_direct.h>
 #else
     #include <cvodes/cvodes_dense.h>
 #endif
+#if SUNDIALS_VERSION_MAJOR < 6
+    #include <cvodes/cvodes_direct.h>
+#endif
 
 <?
 if myokit.DEBUG_SM:
@@ -54,6 +60,13 @@ if myokit.DEBUG_SP:
     print('#ifndef MYOKIT_DEBUG_PROFILING')
     print('#define MYOKIT_DEBUG_PROFILING')
     print('#endif')
+
+if myokit.DEBUG_SS:
+    print('// Show simulator stats')
+    print('#ifndef MYOKIT_DEBUG_STATS')
+    print('#define MYOKIT_DEBUG_STATS')
+    print('#endif')
+
 ?>
 
 #include "pacing.h"
@@ -68,107 +81,180 @@ typedef struct {
     realtype *p;
 } *UserData;
 
+/*
+ * Check flags set by a generic sundials function, set python error.
+ *  sundials_flag: The value to check
+ *  funcname: The name of the function that returned the flag
+ */
+int
+check_sundials_flag(int flag, const char *funcname)
+{
+    /* Check if flag < 0 */
+    if (flag < 0) {
+        PyErr_Format(PyExc_Exception, "Function %s failed with flag = %d", funcname, flag);
+        return 1;
+    }
+    return 0;
+}
+
+/*
+ * Check flags set by any cvode-related function except cvode(), set python error.
+ *  sundials_flag: The value to check
+ *  funcname: The name of the function that returned the flag
+ */
+int
+check_cvode_related_flag(int flag, const char *funcname)
+{
+    /* Check if flag < 0 */
+    if (flag < 0) {
+        switch (flag) {
+        case CV_MEM_NULL:
+            PyErr_Format(PyExc_Exception, "Function %s failed with flag CV_MEM_NULL: The cvode memory block was not initialized.", funcname);
+            break;
+        case CV_MEM_FAIL:
+            PyErr_Format(PyExc_Exception, "Function %s failed with flag CV_MEM_FAIL: A memory allocation failed.", funcname);
+            break;
+        case CV_NO_MALLOC:
+            PyErr_Format(PyExc_Exception, "Function %s failed with flag CV_NO_MALLOC: A memory allocation function returned NULL.", funcname);
+            break;
+        case CV_ILL_INPUT:
+            PyErr_Format(PyExc_Exception, "Function %s failed with flag CV_ILL_INPUT: Invalid input arguments.", funcname);
+            break;
+        case CV_NO_SENS:
+            PyErr_Format(PyExc_Exception, "Function %s failed with flag CV_NO_SENS: Forward sensitivity analysis was not initialized.", funcname);
+            break;
+        case CV_BAD_K:
+            PyErr_Format(PyExc_Exception, "Function %s failed with flag CV_BAD_K: Argument k is not in range.", funcname);
+            break;
+        case CV_BAD_T:
+            PyErr_Format(PyExc_Exception, "Function %s failed with flag CV_BAD_T: Argument t is not in range.", funcname);
+            break;
+        case CV_BAD_DKY:
+            PyErr_Format(PyExc_Exception, "Function %s failed with flag CV_BAD_DKY: The argument DKY was NULL.", funcname);
+            break;
+        default:
+            PyErr_Format(PyExc_Exception, "Function %s failed with unhandled flag = %d", funcname, flag);
+        }
+        return 1;
+    }
+    return 0;
+}
+
 /*
  * Check sundials flags, set python error.
- *  flagvalue : The value to check
+ *  flag: The value to check
+ *  funcname: The name of the function that returned the flag
+ */
+int
+check_cvode_flag(int flag)
+{
+    /* Check if flag < 0 */
+    if (flag < 0) {
+        switch (flag) {
+        case CV_TOO_MUCH_WORK:
+            PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag CV_TOO_MUCH_WORK: The solver took mxstep internal steps but could not reach tout.");
+            break;
+        case CV_TOO_MUCH_ACC:
+            PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag CV_TOO_MUCH_ACC: The solver could not satisfy the accuracy demanded by the user for some internal step.");
+            break;
+        case CV_ERR_FAILURE:
+            PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag CV_ERR_FAILURE: Error test failures occurred too many times during one internal time step or minimum step size was reached.");
+            break;
+        case CV_CONV_FAILURE:
+            PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag CV_CONV_FAILURE: Convergence test failures occurred too many times during one internal time step or minimum step size was reached.");
+            break;
+        case CV_LINIT_FAIL:
+            PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag CV_LINIT_FAIL: The linear solver's initialization function failed.");
+            break;
+        case -6:
+            PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -6 CV_LSETUP_FAIL: The linear solver's setup function failed in an unrecoverable manner.");
+            break;
+        case -7:
+            PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -7 CV_LSOLVE_FAIL: The linear solver's solve function failed in an unrecoverable manner.");
+            break;
+        case -8:
+            PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -8 CV_RHSFUNC_FAIL: The right-hand side function failed in an unrecoverable manner.");
+            break;
+        case -9:
+            PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -9 CV_FIRST_RHSFUNC_ERR: The right-hand side function failed at the first call.");
+            break;
+        case -10:
+            PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -10 CV_REPTD_RHSFUNC_ERR: The right-hand side function had repeated recoverable errors.");
+            break;
+        case -11:
+            PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -11 CV_UNREC_RHSFUNC_ERR: The right-hand side function had a recoverable error, but no recovery is possible.");
+            break;
+        case -12:
+            PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -12 CV_RTFUNC_FAIL: The root finding function failed in an unrecoverable manner.");
+            break;
+        case -20:
+            PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -20 CV_MEM_FAIL: A memory allocation failed.");
+            break;
+        case -21:
+            PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -21 CV_MEM_NULL: The cvode mem argument was NULL.");
+            break;
+        case -22:
+            PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -22 CV_ILL_INPUT: One of the function inputs is illegal.");
+            break;
+        case -23:
+            PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -23 CV_NO_MALLOC: The cvode memory block was not allocated by a call to CVodeMalloc.");
+            break;
+        case -24:
+            PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -24 CV_BAD_K: The derivative order k is larger than the order used.");
+            break;
+        case -25:
+            PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -25 CV_BAD_T: The time t is outside the last step taken.");
+            break;
+        case -26:
+            PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -26 CV_BAD_DKY: The output derivative vector is NULL.");
+            break;
+        case -27:
+            PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -27 CV_TOO_CLOSE: The output and initial times are too close to each other.");
+            break;
+        default:
+            PyErr_Format(PyExc_Exception, "Function CVode() failed with unhandled flag = %d", flag);
+        }
+        return 1;
+    }
+    return 0;
+}
+
+#if SUNDIALS_VERSION_MAJOR >= 7
+/*
+ * Check sundials error code (Sundials 7 and above)
+ *  sunerr   : The SunErroCode to check
  *  funcname : The name of the function that returned the flag
- *  opt : Mode selector
- *         0 : Error if the flag is null
- *         1 : Error if the flag is < 0
- *         2 : Errir
  */
 int
-check_cvode_flag(void *flagvalue, char *funcname, int opt)
+check_sundials_error(SUNErrCode code, const char *funcname)
 {
-    if (opt == 0 && flagvalue == NULL) {
-        /* Check if sundials function returned null pointer */
-        PyErr_Format(PyExc_Exception, "%s() failed - returned NULL pointer", funcname);
+    const char* msg;
+    if (code) {
+        msg = SUNGetErrMsg(code);
+        PyErr_Format(PyExc_Exception, "%s() failed with message = %s", funcname, msg);
         return 1;
-    } else if (opt == 1) {
-        /* Check if flag < 0 */
-        int flag = *((int*)flagvalue);
-        if (flag < 0) {
-            if (strcmp(funcname, "CVode") == 0) {
-                switch (flag) {
-                case -1:
-                    PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -1 CV_TOO_MUCH_WORK: The solver took mxstep internal steps but could not reach tout.");
-                    break;
-                case -2:
-                    PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -2 CV_TOO_MUCH_ACC: The solver could not satisfy the accuracy demanded by the user for some internal step.");
-                    break;
-                case -3:
-                    PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -3 CV_ERR_FAILURE: Error test failures occurred too many times during one internal time step or minimum step size was reached.");
-                    break;
-                case -4:
-                    PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -4 CV_CONV_FAILURE: Convergence test failures occurred too many times during one internal time step or minimum step size was reached.");
-                    break;
-                case -5:
-                    PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -5 CV_LINIT_FAIL: The linear solver's initialization function failed.");
-                    break;
-                case -6:
-                    PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -6 CV_LSETUP_FAIL: The linear solver's setup function failed in an unrecoverable manner.");
-                    break;
-                case -7:
-                    PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -7 CV_LSOLVE_FAIL: The linear solver's solve function failed in an unrecoverable manner.");
-                    break;
-                case -8:
-                    PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -8 CV_RHSFUNC_FAIL: The right-hand side function failed in an unrecoverable manner.");
-                    break;
-                case -9:
-                    PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -9 CV_FIRST_RHSFUNC_ERR: The right-hand side function failed at the first call.");
-                    break;
-                case -10:
-                    PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -10 CV_REPTD_RHSFUNC_ERR: The right-hand side function had repeated recoverable errors.");
-                    break;
-                case -11:
-                    PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -11 CV_UNREC_RHSFUNC_ERR: The right-hand side function had a recoverable error, but no recovery is possible.");
-                    break;
-                case -12:
-                    PyErr_SetString(PyExc_ArithmeticError, "Function CVode() failed with flag -12 CV_RTFUNC_FAIL: The root finding function failed in an unrecoverable manner.");
-                    break;
-                case -20:
-                    PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -20 CV_MEM_FAIL: A memory allocation failed.");
-                    break;
-                case -21:
-                    PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -21 CV_MEM_NULL: The cvode mem argument was NULL.");
-                    break;
-                case -22:
-                    PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -22 CV_ILL_INPUT: One of the function inputs is illegal.");
-                    break;
-                case -23:
-                    PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -23 CV_NO_MALLOC: The cvode memory block was not allocated by a call to CVodeMalloc.");
-                    break;
-                case -24:
-                    PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -24 CV_BAD_K: The derivative order k is larger than the order used.");
-                    break;
-                case -25:
-                    PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -25 CV_BAD_T: The time t is outside the last step taken.");
-                    break;
-                case -26:
-                    PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -26 CV_BAD_DKY: The output derivative vector is NULL.");
-                    break;
-                case -27:
-                    PyErr_SetString(PyExc_Exception, "Function CVode() failed with flag -27 CV_TOO_CLOSE: The output and initial times are too close to each other.");
-                    break;
-                default:
-                    PyErr_Format(PyExc_Exception, "Function CVode() failed with unknown flag = %d", flag);
-                }
-            } else {
-                PyErr_Format(PyExc_Exception, "%s() failed with flag = %d", funcname, flag);
-            }
-            return 1;
-        }
     }
     return 0;
 }
+#endif
 
 /*
  * Error and warning message handler for CVODES.
- * Error messages are already set via check_cvode_flag, so this method
+ * Error messages are already set via check_cvode_flag & co, so this method
  * suppresses error messages.
  * Warnings are passed to Python's warning system, where they can be
  * caught or suppressed using the warnings module.
  */
+#if SUNDIALS_VERSION_MAJOR >= 7
+void
+ErrorHandler(int line, const char* function, const char* file, const char* msg,
+             SUNErrCode error_code, void* err_user_data, SUNContext context)
+{
+    if (error_code) {
+        PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "CVODES: %s", msg);
+    }
+}
+#else
 void
 ErrorHandler(int error_code, const char *module, const char *function,
              char *msg, void *eh_data)
@@ -177,6 +263,7 @@ ErrorHandler(int error_code, const char *module, const char *function,
         PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "CVODES: %s", msg);
     }
 }
+#endif
 
 /*
  * Initialisation status.
@@ -196,7 +283,7 @@ union PSys *pacing_systems;   /* Array of pacing systems (event based or time se
 enum PSysType *pacing_types;  /* Array of pacing system types */
 PyObject *protocols;          /* The protocols used to generate the pacing systems */
 double* pacing;               /* Pacing values, same size as pacing_systems and pacing_types */
-int n_pace;                   /* The number of pacing systems */
+int n_pace;                   /* The number of pacing systems: Must be set with every call from Python that uses it */
 
 /*
  * CVODE Memory
@@ -562,6 +649,10 @@ sim_init(PyObject *self, PyObject *args)
     Model_Flag flag_model;
     ESys_Flag flag_epacing;
     TSys_Flag flag_fpacing;
+    /* Error handling in >=7 */
+    #if SUNDIALS_VERSION_MAJOR >= 7
+    SUNErrCode sunerr;
+    #endif
 
     /* Pacing systems */
     ESys epacing;
@@ -740,11 +831,12 @@ sim_init(PyObject *self, PyObject *args)
     /*
      * Create sundials context
      */
-    #if SUNDIALS_VERSION_MAJOR >= 6
+    #if SUNDIALS_VERSION_MAJOR >= 7
+    sunerr = SUNContext_Create(SUN_COMM_NULL, &sundials_context);
+    if (check_sundials_error(sunerr, "SUNContext_Create")) return sim_clean();
+    #elif SUNDIALS_VERSION_MAJOR >= 6
     flag_cvode = SUNContext_Create(NULL, &sundials_context);
-    if (check_cvode_flag(&flag_cvode, "SUNContext_Create", 1)) {
-        return sim_cleanx(PyExc_Exception, "Failed to create Sundials context.");
-    }
+    if (check_sundials_flag(flag_cvode, "SUNContext_Create")) return sim_clean();
     #ifdef MYOKIT_DEBUG_PROFILING
     benchmarker_print("CP Created sundials context.");
     #endif
@@ -760,9 +852,7 @@ sim_init(PyObject *self, PyObject *args)
     #else
     y = N_VNew_Serial(model->n_states);
     #endif
-    if (check_cvode_flag((void*)y, "N_VNew_Serial", 0)) {
-        return sim_cleanx(PyExc_Exception, "Failed to create state vector.");
-    }
+    if (y == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for state vector.");
 
     /* Create state vector copy for error handling */
     #if SUNDIALS_VERSION_MAJOR >= 6
@@ -770,16 +860,12 @@ sim_init(PyObject *self, PyObject *args)
     #else
     ylast = N_VNew_Serial(model->n_states);
     #endif
-    if (check_cvode_flag((void*)ylast, "N_VNew_Serial", 0)) {
-        return sim_cleanx(PyExc_Exception, "Failed to create last-state vector.");
-    }
+    if (ylast == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for last-state vector.");
 
     /* Create sensitivity vector array */
     if (model->has_sensitivities) {
         sy = N_VCloneVectorArray(model->ns_independents, y);
-        if (check_cvode_flag((void*)sy, "N_VCloneVectorArray", 0)) {
-            return sim_cleanx(PyExc_Exception, "Failed to allocate space to store sensitivities.");
-        }
+        if (sy == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for sensitivity vector array.");
     }
 
     /*
@@ -802,14 +888,10 @@ sim_init(PyObject *self, PyObject *args)
         #else
         z = N_VNew_Serial(model->n_states);
         #endif
-        if (check_cvode_flag((void*)z, "N_VNew_Serial", 0)) {
-            return sim_cleanx(PyExc_Exception, "Failed to create state vector for logging.");
-        }
+        if (z == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for state vector for logging.");
         if (model->has_sensitivities) {
             sz = N_VCloneVectorArray(model->ns_independents, y);
-            if (check_cvode_flag((void*)sz, "N_VCloneVectorArray", 0)) {
-                return sim_cleanx(PyExc_Exception, "Failed to create state sensitivity vector array for logging.");
-            }
+            if (sz == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for sensitivity vector array for logging.");
         }
     }
 
@@ -957,9 +1039,7 @@ sim_init(PyObject *self, PyObject *args)
         /* Create parameter scaling vector, for error control */
         /* TODO: Get this from the Python code ? */
         pbar = (realtype*)malloc((size_t)model->ns_independents * sizeof(realtype));
-        if (pbar == NULL) {
-            return sim_cleanx(PyExc_Exception, "Unable to allocate space to store parameter scales.");
-        }
+        if (pbar == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for parameter scale array.");
         for (i=0; i<model->ns_independents; i++) {
             pbar[i] = (udata->p[i] == 0.0 ? 1.0 : fabs(udata->p[i]));
         }
@@ -983,17 +1063,11 @@ sim_init(PyObject *self, PyObject *args)
         n_pace = (int)PyList_Size(protocols);
     }
     pacing_systems = (union PSys*)malloc((size_t)n_pace * sizeof(union PSys));
-    if (pacing_systems == NULL) {
-        return sim_cleanx(PyExc_Exception, "Unable to allocate space to store pacing systems.");
-    }
+    if (pacing_systems == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for pacing systems.");
     pacing_types = (enum PSysType *)malloc((size_t)n_pace * sizeof(enum PSysType));
-    if (pacing_types == NULL) {
-        return sim_cleanx(PyExc_Exception, "Unable to allocate space to store pacing types.");
-    }
+    if (pacing_types == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for pacing types.");
     pacing = (realtype*)malloc((size_t)n_pace * sizeof(realtype));
-    if (pacing == NULL) {
-        return sim_cleanx(PyExc_Exception, "Unable to allocate space to store pacing values.");
-    }
+    if (pacing == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for pacing values.");
     Model_SetupPacing(model, n_pace);
 
     /*
@@ -1074,68 +1148,73 @@ sim_init(PyObject *self, PyObject *args)
         #else
         cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
         #endif
-        if (check_cvode_flag((void*)cvode_mem, "CVodeCreate", 0)) return sim_clean();
+        if (cvode_mem == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate CVODE memory.");
 
         /* Set error and warning-message handler */
+        #if SUNDIALS_VERSION_MAJOR >= 7
+        sunerr = SUNContext_PushErrHandler(sundials_context, ErrorHandler, NULL);
+        if (check_sundials_error(sunerr, "SUNContext_PushErrHandler")) return sim_clean();
+        #else
         flag_cvode = CVodeSetErrHandlerFn(cvode_mem, ErrorHandler, NULL);
-        if (check_cvode_flag(&flag_cvode, "CVodeInit", 1)) return sim_clean();
+        if (check_cvode_related_flag(flag_cvode, "CVodeSetErrHandlerFn")) return sim_clean();
+        #endif
 
         /* Initialize solver memory, specify the rhs */
         flag_cvode = CVodeInit(cvode_mem, rhs, t, y);
-        if (check_cvode_flag(&flag_cvode, "CVodeInit", 1)) return sim_clean();
+        if (check_cvode_related_flag(flag_cvode, "CVodeInit")) return sim_clean();
 
         /* Set absolute and relative tolerances */
         flag_cvode = CVodeSStolerances(cvode_mem, RCONST(rel_tol), RCONST(abs_tol));
-        if (check_cvode_flag(&flag_cvode, "CVodeSStolerances", 1)) return sim_clean();
+        if (check_cvode_related_flag(flag_cvode, "CVodeSStolerances")) return sim_clean();
 
         /* Set a maximum step size (or 0.0 for none) */
         flag_cvode = CVodeSetMaxStep(cvode_mem, dt_max < 0 ? 0.0 : dt_max);
-        if (check_cvode_flag(&flag_cvode, "CVodeSetmaxStep", 1)) return sim_clean();
+        if (check_cvode_related_flag(flag_cvode, "CVodeSetmaxStep")) return sim_clean();
 
         /* Set a minimum step size (or 0.0 for none) */
         flag_cvode = CVodeSetMinStep(cvode_mem, dt_min < 0 ? 0.0 : dt_min);
-        if (check_cvode_flag(&flag_cvode, "CVodeSetminStep", 1)) return sim_clean();
+        if (check_cvode_related_flag(flag_cvode, "CVodeSetminStep")) return sim_clean();
 
         #if SUNDIALS_VERSION_MAJOR >= 6
             /* Create dense matrix for use in linear solves */
             sundense_matrix = SUNDenseMatrix(model->n_states, model->n_states, sundials_context);
-            if (check_cvode_flag((void *)sundense_matrix, "SUNDenseMatrix", 0)) return sim_clean();
+            if (sundense_matrix == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for dense matrix.");
 
             /* Create dense linear solver object with matrix */
             sundense_solver = SUNLinSol_Dense(y, sundense_matrix, sundials_context);
-            if (check_cvode_flag((void *)sundense_solver, "SUNLinSol_Dense", 0)) return sim_clean();
+            if (sundense_solver == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for dense solver.");
 
             /* Attach the matrix and solver to cvode */
             flag_cvode = CVodeSetLinearSolver(cvode_mem, sundense_solver, sundense_matrix);
-            if (check_cvode_flag(&flag_cvode, "CVodeSetLinearSolver", 1)) return sim_clean();
+            if (check_sundials_flag(flag_cvode, "CVodeSetLinearSolver")) return sim_clean();
         #elif SUNDIALS_VERSION_MAJOR >= 4
             /* Create dense matrix for use in linear solves */
             sundense_matrix = SUNDenseMatrix(model->n_states, model->n_states);
-            if (check_cvode_flag((void *)sundense_matrix, "SUNDenseMatrix", 0)) return sim_clean();
+            if (sundense_matrix == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for dense matrix.");
 
             /* Create dense linear solver object with matrix */
             sundense_solver = SUNLinSol_Dense(y, sundense_matrix);
-            if (check_cvode_flag((void *)sundense_solver, "SUNLinSol_Dense", 0)) return sim_clean();
+            if (sundense_solver == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for dense solver.");
 
             /* Attach the matrix and solver to cvode */
             flag_cvode = CVodeSetLinearSolver(cvode_mem, sundense_solver, sundense_matrix);
-            if (check_cvode_flag(&flag_cvode, "CVodeSetLinearSolver", 1)) return sim_clean();
+            if (check_sundials_flag(flag_cvode, "CVodeSetLinearSolver")) return sim_clean();
         #elif SUNDIALS_VERSION_MAJOR >= 3
             /* Create dense matrix for use in linear solves */
             sundense_matrix = SUNDenseMatrix(model->n_states, model->n_states);
-            if (check_cvode_flag((void *)sundense_matrix, "SUNDenseMatrix", 0)) return sim_clean();
+            if (sundense_matrix == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for dense matrix.");
 
             /* Create dense linear solver object with matrix */
             sundense_solver = SUNDenseLinearSolver(y, sundense_matrix);
-            if (check_cvode_flag((void *)sundense_solver, "SUNDenseLinearSolver", 0)) return sim_clean();
+            if (sundense_solver == NULL) return sim_cleanx(PyExc_Exception, "Unable to allocate space for dense solver.");
 
             /* Attach the matrix and solver to cvode */
             flag_cvode = CVDlsSetLinearSolver(cvode_mem, sundense_solver, sundense_matrix);
-            if (check_cvode_flag(&flag_cvode, "CVDlsSetLinearSolver", 1)) return sim_clean();
+            if (check_sundials_flag(flag_cvode, "CVDlsSetLinearSolver")) return sim_clean();
         #else
             /* Create dense matrix for use in linear solves */
             flag_cvode = CVDense(cvode_mem, model->n_states);
-            if (check_cvode_flag(&flag_cvode, "CVDense", 1)) return sim_clean();
+            if (check_sundials_flag(flag_cvode, "CVDense")) return sim_clean();
         #endif
 
         #ifdef MYOKIT_DEBUG_PROFILING
@@ -1148,19 +1227,19 @@ sim_init(PyObject *self, PyObject *args)
                RHS of the sensitivity ODE */
             /*flag_cvode = CVodeSensInit(cvode_mem, model->ns_independents, CV_SIMULTANEOUS, rhs1, sy);*/
             flag_cvode = CVodeSensInit(cvode_mem, model->ns_independents, CV_SIMULTANEOUS, NULL, sy);
-            if (check_cvode_flag(&flag_cvode, "CVodeSensInit", 1)) return sim_clean();
+            if (check_cvode_related_flag(flag_cvode, "CVodeSensInit")) return sim_clean();
 
             /* Attach user data */
             flag_cvode = CVodeSetUserData(cvode_mem, udata);
-            if (check_cvode_flag(&flag_cvode, "CVodeSetUserData", 1)) return sim_clean();
+            if (check_cvode_related_flag(flag_cvode, "CVodeSetUserData")) return sim_clean();
 
             /* Set parameter scales used in tolerances */
             flag_cvode = CVodeSetSensParams(cvode_mem, udata->p, pbar, NULL);
-            if (check_cvode_flag(&flag_cvode, "CVodeSetSensParams", 1)) return sim_clean();
+            if (check_cvode_related_flag(flag_cvode, "CVodeSetSensParams")) return sim_clean();
 
             /* Set sensitivity tolerances calculating method (using pbar) */
             flag_cvode = CVodeSensEEtolerances(cvode_mem);
-            if (check_cvode_flag(&flag_cvode, "CVodeSensEEtolerances", 1)) return sim_clean();
+            if (check_cvode_related_flag(flag_cvode, "CVodeSensEEtolerances")) return sim_clean();
 
             #ifdef MYOKIT_DEBUG_PROFILING
             benchmarker_print("CP CVODES sensitivity methods initialized.");
@@ -1177,7 +1256,7 @@ sim_init(PyObject *self, PyObject *args)
     if (model->is_ode && PyList_Check(rf_list)) {
         /* Initialize root function with 1 component */
         flag_cvode = CVodeRootInit(cvode_mem, 1, rf_function);
-        if (check_cvode_flag(&flag_cvode, "CVodeRootInit", 1)) return sim_clean();
+        if (check_cvode_related_flag(flag_cvode, "CVodeRootInit")) return sim_clean();
 
         /* Direction of root crossings, one entry per root function, but we only use 1. */
         rf_direction = (int*)malloc(sizeof(int));
@@ -1302,6 +1381,22 @@ sim_init(PyObject *self, PyObject *args)
     benchmarker_print("CP Logging times and strategy initialized.");
     #endif
 
+    #ifdef MYOKIT_DEBUG_STATS
+    if (model->is_ode) {
+        printf(" 1. number of steps taken by cvodes.\n");
+        printf(" 2. number of calls to the user's f function.\n");
+        printf(" 3. number of calls made to the linear solver setup function.\n");
+        printf(" 4. number of error test failures.\n");
+        printf(" 5. method order used on the last internal step.\n");
+        printf(" 6. method order to be used on the next internal step.\n");
+        printf(" 7. actual value of initial step size.\n");
+        printf(" 8. step size taken on the last internal step.\n");
+        printf(" 9. step size to be attempted on the next internal step.\n");
+        printf("10. current internal time reached.\n");
+        printf("1\t2\t3\t4\t5\t6\t\t7\t\t8\t\t9\t\t10\n");
+    }
+    #endif
+
     /*
      * Done!
      */
@@ -1340,6 +1435,13 @@ sim_step(PyObject *self, PyObject *args)
     PyObject *val;
     PyObject* ret;
 
+    #ifdef MYOKIT_DEBUG_STATS
+    /* CVODE stats */
+    long int cv_nsteps, cv_nfevals, cv_nlinsetups, cv_netfails;
+    int cv_qlast, cv_qcur;
+    realtype cv_hinused, cv_hlast, cv_hcur, cv_tcur;
+    #endif
+
     /*
      * Set start time for logging of realtime.
      * This is handled here instead of in sim_init so it only includes time
@@ -1367,12 +1469,30 @@ sim_step(PyObject *self, PyObject *args)
 
             /* Take a single ODE step */
             #ifdef MYOKIT_DEBUG_MESSAGES
-            printf("\nCM Taking CVODE step from time %g to %g.\n", t, tnext);
+            printf("\nCM Taking CVODE step from time %g to %g", t, tnext);
             #endif
             flag_cvode = CVode(cvode_mem, tnext, y, &t, CV_ONE_STEP);
+            #ifdef MYOKIT_DEBUG_MESSAGES
+            printf(" : flag %d\n", flag_cvode);
+            #endif
+
+            /* Show cvodes stats */
+            #ifdef MYOKIT_DEBUG_STATS
+            CVodeGetIntegratorStats(cvode_mem, &cv_nsteps, &cv_nfevals,
+                                    &cv_nlinsetups, &cv_netfails, &cv_qlast, &cv_qcur,
+                                    &cv_hinused, &cv_hlast, &cv_hcur, &cv_tcur);
+            printf("%ld,\t%ld,\t%ld,\t%ld,\t%d,\t%d,\t%g,\t%g,\t%g,\t%g\n",
+                   cv_nsteps, cv_nfevals, cv_nlinsetups, cv_netfails,
+                   cv_qlast, cv_qcur,
+                   cv_hinused, cv_hlast, cv_hcur, cv_tcur);
+            #endif
 
             /* Check for errors */
-            if (check_cvode_flag(&flag_cvode, "CVode", 1)) {
+            if (check_cvode_flag(flag_cvode)) {
+                #ifdef MYOKIT_DEBUG_MESSAGES
+                printf("\nCM CVODE flag %d. Setting error output and returning.\n", flag_cvode);
+                #endif
+
                 /* Something went wrong... Set outputs and return */
                 for (i=0; i<model->n_states; i++) {
                     PyList_SetItem(state_py, i, PyFloat_FromDouble(NV_Ith_S(ylast, i)));
@@ -1384,6 +1504,8 @@ sim_step(PyObject *self, PyObject *args)
                 for (i=0; i<n_pace; i++) {
                     PyList_SetItem(bound_py, 3 + i, PyFloat_FromDouble(pacing[i]));
                 }
+
+                /* Error state set by check_cvode_flag, so use ordinary return. */
                 return sim_clean();
             }
 
@@ -1400,7 +1522,18 @@ sim_step(PyObject *self, PyObject *args)
         /* Check if progress is being made */
         if (t == tlast) {
             if (++zero_step_count >= max_zero_step_count) {
-                return sim_cleanx(PyExc_ArithmeticError, "Maximum number of zero-length steps taken at t=%g", t);
+                /* Something went wrong: set outputs and return */
+                for (i=0; i<model->n_states; i++) {
+                    PyList_SetItem(state_py, i, PyFloat_FromDouble(NV_Ith_S(ylast, i)));
+                    /* PyList_SetItem steals a reference: no need to decref the double! */
+                }
+                PyList_SetItem(bound_py, 0, PyFloat_FromDouble(tlast));
+                PyList_SetItem(bound_py, 1, PyFloat_FromDouble(realtime));
+                PyList_SetItem(bound_py, 2, PyFloat_FromDouble((double)evaluations));
+                for (i=0; i<n_pace; i++) {
+                    PyList_SetItem(bound_py, 3 + i, PyFloat_FromDouble(pacing[i]));
+                }
+                return sim_cleanx(PyExc_ArithmeticError, "Maximum number of zero-length steps taken.");
             }
         } else {
             /* Only count consecutive zero steps */
@@ -1426,10 +1559,10 @@ sim_step(PyObject *self, PyObject *args)
 
                     /* Go back to time=tnext */
                     flag_cvode = CVodeGetDky(cvode_mem, tnext, 0, y);
-                    if (check_cvode_flag(&flag_cvode, "CVodeGetDky", 1)) return sim_clean();
+                    if (check_cvode_related_flag(flag_cvode, "CVodeGetDky")) return sim_clean();
                     if (model->has_sensitivities) {
                         flag_cvode = CVodeGetSensDky(cvode_mem, tnext, 0, sy);
-                        if (check_cvode_flag(&flag_cvode, "CVodeGetSensDky", 1)) return sim_clean();
+                        if (check_cvode_related_flag(flag_cvode, "CVodeGetSensDky")) return sim_clean();
                     }
                     t = tnext;
                     /* Require reinit (after logging) */
@@ -1440,7 +1573,7 @@ sim_step(PyObject *self, PyObject *args)
                     /* Get current sensitivity vector */
                     if (model->has_sensitivities) {
                         flag_cvode = CVodeGetSens(cvode_mem, &t, sy);
-                        if (check_cvode_flag(&flag_cvode, "CVodeGetSens", 1)) return sim_clean();
+                        if (check_cvode_related_flag(flag_cvode, "CVodeGetSens")) return sim_clean();
                     }
 
                     /* Root found */
@@ -1448,7 +1581,7 @@ sim_step(PyObject *self, PyObject *args)
 
                         /* Get directions of root crossings (1 per root function) */
                         flag_root = CVodeGetRootInfo(cvode_mem, rf_direction);
-                        if (check_cvode_flag(&flag_root, "CVodeGetRootInfo", 1)) return sim_clean();
+                        if (check_cvode_related_flag(flag_root, "CVodeGetRootInfo")) return sim_clean();
                         /* We only have one root function, so we know that rf_direction[0] is non-zero at this point. */
 
                         /* Store tuple (time, direction) for the found root */
@@ -1488,10 +1621,10 @@ sim_step(PyObject *self, PyObject *args)
                     /* Get interpolated y(tlog) */
                     if (model->is_ode) {
                         flag_cvode = CVodeGetDky(cvode_mem, tlog, 0, z);
-                        if (check_cvode_flag(&flag_cvode, "CVodeGetDky", 1)) return sim_clean();
+                        if (check_cvode_related_flag(flag_cvode, "CVodeGetDky")) return sim_clean();
                         if (model->has_sensitivities) {
                             flag_cvode = CVodeGetSensDky(cvode_mem, tlog, 0, sz);
-                            if (check_cvode_flag(&flag_cvode, "CVodeGetSensDky", 1)) return sim_clean();
+                            if (check_cvode_related_flag(flag_cvode, "CVodeGetSensDky")) return sim_clean();
                         }
                     }
                     /* If cvode-free mode, the states can't change so we don't
@@ -1617,10 +1750,10 @@ sim_step(PyObject *self, PyObject *args)
              */
             if (model->is_ode && flag_reinit) {
                 flag_cvode = CVodeReInit(cvode_mem, t, y);
-                if (check_cvode_flag(&flag_cvode, "CVodeReInit", 1)) return sim_clean();
+                if (check_cvode_related_flag(flag_cvode, "CVodeReInit")) return sim_clean();
                 if (model->has_sensitivities) {
                     flag_cvode = CVodeSensReInit(cvode_mem, CV_SIMULTANEOUS, sy);
-                    if (check_cvode_flag(&flag_cvode, "CVodeSensReInit", 1)) return sim_clean();
+                    if (check_cvode_related_flag(flag_cvode, "CVodeSensReInit")) return sim_clean();
                 }
                 flag_reinit = 0;
             }
@@ -1697,36 +1830,40 @@ sim_step(PyObject *self, PyObject *args)
  * Evaluates the state derivatives at the given state
  */
 PyObject*
-sim_eval_derivatives(PyObject *self, PyObject *args)
+sim_evaluate_derivatives(PyObject *self, PyObject *args)
 {
     /* Declare variables here for C89 compatibility */
     int i;
     int success;
     double time_in;
+    double realtime_in;
+    double evaluations_in;
     PyObject *pace_in;
-    double *pacing_in;
-    Model model;
-    Model_Flag flag_model;
-    PyObject *state;
-    PyObject *deriv;
+    double *pacing_values;
     PyObject *literals;
     PyObject *parameters;
+    PyObject *state;
+    PyObject *deriv;
     PyObject *val;
+    Model model;
+    Model_Flag flag_model;
 
     /* Start */
     success = 0;
 
     /* Check input arguments */
     /* Check input arguments     0123456789ABCDEF*/
-    if (!PyArg_ParseTuple(args, "dOOOOO",
+    if (!PyArg_ParseTuple(args, "dOddOOOO",
             &time_in,           /* 0. Float: time */
-            &pace_in,           /* 1. List: pace */
-            &state,             /* 2. List: state */
-            &deriv,             /* 3. List: store derivatives here */
+            &pace_in,           /* 1. List: pacing values */
+            &realtime_in,       /* 2. Float: realtime */
+            &evaluations_in,    /* 3. Float: evaluations */
             &literals,          /* 4. List: literal constant values */
-            &parameters         /* 5. List: parameter values */
-            )) {
-        PyErr_SetString(PyExc_Exception, "Incorrect input arguments in sim_eval_derivatives.");
+            &parameters,        /* 5. List: parameter values */
+            &state,             /* 6. List: state */
+            &deriv              /* 7. List: store derivatives here */
+    )) {
+        PyErr_SetString(PyExc_Exception, "Incorrect input arguments in sim_evaluate_derivatives.");
         /* Nothing allocated yet, no pyobjects _created_, return directly */
         return 0;
     }
@@ -1736,14 +1873,6 @@ sim_eval_derivatives(PyObject *self, PyObject *args)
         PyErr_SetString(PyExc_Exception, "Pace argument must be a list.");
         return 0;
     }
-    if (!PyList_Check(state)) {
-        PyErr_SetString(PyExc_Exception, "State argument must be a list.");
-        return 0;
-    }
-    if (!PyList_Check(deriv)) {
-        PyErr_SetString(PyExc_Exception, "Derivatives argument must be a list.");
-        return 0;
-    }
     if (!PyList_Check(literals)) {
         PyErr_SetString(PyExc_Exception, "Literals argument must be a list.");
         return 0;
@@ -1752,6 +1881,14 @@ sim_eval_derivatives(PyObject *self, PyObject *args)
         PyErr_SetString(PyExc_Exception, "Parameters argument must be a list.");
         return 0;
     }
+    if (!PyList_Check(state)) {
+        PyErr_SetString(PyExc_Exception, "State argument must be a list.");
+        return 0;
+    }
+    if (!PyList_Check(deriv)) {
+        PyErr_SetString(PyExc_Exception, "Derivatives argument must be a list.");
+        return 0;
+    }
 
     /* From this point on, no more direct returning: use goto error */
     model = NULL;
@@ -1767,6 +1904,8 @@ sim_eval_derivatives(PyObject *self, PyObject *args)
         goto error;
     }
 
+    /* Set up pacing (but without protocols) */
+    n_pace = (int)PyList_Size(pace_in);
     flag_model = Model_SetupPacing(model, n_pace);
     if (flag_model != Model_OK) {
         Model_SetPyErr(flag_model);
@@ -1774,18 +1913,23 @@ sim_eval_derivatives(PyObject *self, PyObject *args)
     }
 
     /* Set pacing values */
-    pacing_in = (double*)malloc((size_t)n_pace * sizeof(double));
+    pacing_values = (double*)malloc((size_t)n_pace * sizeof(double));
     for (i=0; i<n_pace; i++) {
         val = PyList_GetItem(pace_in, i); /* Don't decref */
         if (!PyFloat_Check(val)) {
             PyErr_Format(PyExc_Exception, "Item %d in pace vector is not a float.", i);
             goto error;
         }
-        pacing_in[i] = PyFloat_AsDouble(val);
+        pacing_values[i] = PyFloat_AsDouble(val);
     }
 
     /* Set bound variables */
-    Model_SetBoundVariables(model, (realtype)time_in, (realtype*)pacing_in, 0, 0);
+    Model_SetBoundVariables(
+        model,
+        (realtype)time_in,
+        (realtype*)pacing_values,
+        (realtype)realtime_in,
+        (realtype)evaluations_in);
 
     /* Set literal values */
     for (i=0; i<model->n_literals; i++) {
@@ -1925,7 +2069,7 @@ PyMethodDef SimMethods[] = {
     {"sim_init", sim_init, METH_VARARGS, "Initialize the simulation."},
     {"sim_step", sim_step, METH_VARARGS, "Perform the next step in the simulation."},
     {"sim_clean", py_sim_clean, METH_VARARGS, "Clean up after an aborted simulation."},
-    {"eval_derivatives", sim_eval_derivatives, METH_VARARGS, "Evaluate the state derivatives."},
+    {"evaluate_derivatives", sim_evaluate_derivatives, METH_VARARGS, "Evaluate the state derivatives."},
     {"set_tolerance", sim_set_tolerance, METH_VARARGS, "Set the absolute and relative solver tolerance."},
     {"set_max_step_size", sim_set_max_step_size, METH_VARARGS, "Set the maximum solver step size (0 for none)."},
     {"set_min_step_size", sim_set_min_step_size, METH_VARARGS, "Set the minimum solver step size (0 for none)."},