myokit 1.36.0__py3-none-any.whl → 1.37.0__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:
@@ -75,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)
@@ -184,6 +263,7 @@ ErrorHandler(int error_code, const char *module, const char *function,
         PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "CVODES: %s", msg);
     }
 }
+#endif
 
 /*
  * Initialisation status.
@@ -569,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;
@@ -747,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
@@ -767,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
@@ -777,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.");
     }
 
     /*
@@ -809,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.");
         }
     }
 
@@ -964,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]));
         }
@@ -990,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);
 
     /*
@@ -1081,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
@@ -1155,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.");
@@ -1184,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));
@@ -1416,7 +1488,7 @@ sim_step(PyObject *self, PyObject *args)
             #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
@@ -1487,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) */
@@ -1501,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 */
@@ -1509,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 */
@@ -1549,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
@@ -1678,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;
             }

myokit/_sim/jacobian.py

@@ -166,7 +166,7 @@ class JacobianTracer(myokit.CppModule):
             self._ext.calculate(state, bound, deriv, partial)
             # Discard derivatives
             # Convert partial derivatives to numpy array and store
-            partial = np.array(partial, copy=False)
+            partial = np.asarray(partial)
             partial = partial.reshape((ns, ns))
             partials.append(partial)
         partials = np.array(partials)
@@ -282,8 +282,8 @@ class JacobianCalculator(myokit.CppModule):
         self._ext.calculate(state, inputs, deriv, partial)
 
         # Create numpy versions and return
-        deriv = np.array(deriv, copy=False)
-        partial = np.array(partial, copy=False).reshape((n, n))
+        deriv = np.asarray(deriv)
+        partial = np.asarray(partial).reshape((n, n))
         return deriv, partial
 
     def newton_root(self, x=None, accuracy=0, max_iter=50, damping=1):