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

myokit/_myokit_version.py

@@ -14,7 +14,7 @@ __release__ = True
 #    incompatibility
 #  - Changes to revision indicate bugfixes, tiny new features
 #  - There is no significance to odd/even numbers
-__version_tuple__ = 1, 36, 0
+__version_tuple__ = 1, 36, 1
 
 # String version of the version number
 __version__ = '.'.join([str(x) for x in __version_tuple__])

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/mcl.h

@@ -651,6 +651,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     }
 
     // Name
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying name\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DEVICE_NAME, bufsize, buffer, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyUnicode_FromString(buffer);
@@ -658,6 +661,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     Py_CLEAR(val);
 
     // Vendor
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying vendor\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DEVICE_VENDOR, bufsize, buffer, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyUnicode_FromString(buffer);
@@ -665,6 +671,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     Py_CLEAR(val);
 
     // Device version
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying device version\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DEVICE_VERSION, bufsize, buffer, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyUnicode_FromString(buffer);
@@ -672,6 +681,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     Py_CLEAR(val);
 
     // Driver version
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying driver version\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DRIVER_VERSION, bufsize, buffer, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyUnicode_FromString(buffer);
@@ -679,6 +691,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     Py_CLEAR(val);
 
     // Clock speed (MHz)
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying clock speed\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(buf_uint), &buf_uint, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyLong_FromUnsignedLong(buf_uint);
@@ -686,6 +701,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     Py_CLEAR(val);
 
     // Global memory (bytes)
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying global memory size\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(buf_ulong), &buf_ulong, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyLong_FromUnsignedLongLong(buf_ulong);
@@ -693,6 +711,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     Py_CLEAR(val);
 
     // Local memory (bytes)
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying local memory size\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(buf_ulong), &buf_ulong, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyLong_FromUnsignedLongLong(buf_ulong);
@@ -700,6 +721,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     Py_CLEAR(val);
 
     // Const memory (bytes)
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying max buffer size\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(buf_ulong), &buf_ulong, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyLong_FromUnsignedLongLong(buf_ulong);
@@ -707,6 +731,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     Py_CLEAR(val);
 
     // Computing units
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying max computing units\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(buf_uint), &buf_uint, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyLong_FromUnsignedLong(buf_uint);
@@ -714,6 +741,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     Py_CLEAR(val);
 
     // Max workgroup size
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying max work group size\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(buf_size_t), &buf_size_t, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyLong_FromSize_t(buf_size_t);
@@ -721,6 +751,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     Py_CLEAR(val);
 
     // Max workitem sizes
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying max work item sizes\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(buf_uint), &buf_uint, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyLong_FromUnsignedLong(buf_uint);
@@ -739,6 +772,9 @@ PyObject* mcl_info_device_dict(cl_device_id device_id, size_t bufsize, char* buf
     Py_CLEAR(items_sizes_tuple);
 
     // Maximum size of a kernel parameter
+    #ifdef MYOKIT_DEBUG_MESSAGES
+    printf("  Querying maximum kernel parameter size\n");
+    #endif
     flag = clGetDeviceInfo(device_id, CL_DEVICE_MAX_PARAMETER_SIZE, sizeof(buf_size_t), &buf_size_t, NULL);
     if(mcl_flag(flag)) { Py_DECREF(device); return NULL; }
     val = PyLong_FromSize_t(buf_size_t);
@@ -834,29 +870,47 @@ mcl_info(void)
 
     // Check all platforms
     for (i=0; i<n_platforms; i++) {
+        #ifdef MYOKIT_DEBUG_MESSAGES
+        printf("Checking platform %u\n", (unsigned int)i);
+        #endif
 
         // Create platform dict
         platform = mcl_info_platform_dict(platform_ids[i], sizeof(buffer), buffer);
         if (platform == NULL) { Py_DECREF(platforms); return NULL; }
+        #ifdef MYOKIT_DEBUG_MESSAGES
+        printf("  Obtained platform info dict.\n");
+        #endif
 
         // Count devices
         flag = clGetDeviceIDs(platform_ids[i], CL_DEVICE_TYPE_ALL, MCL_MAX_DEVICES, device_ids, &n_devices);
         if (flag == CL_DEVICE_NOT_FOUND) {
             n_devices = 0;
+        } else if (flag == CL_INVALID_VALUE) {
+            // This seems to happen on Mac OS 14.4.1
+            n_devices = 0;
         } else if (mcl_flag(flag)) {
             Py_DECREF(platforms);
             return NULL;
         }
+        #ifdef MYOKIT_DEBUG_MESSAGES
+        printf("  Found %u devices.\n", (unsigned int)n_devices);
+        #endif
 
         // Create devices tuple, must decref on exception
         devices = PyTuple_New((size_t)n_devices);
 
         // Add devices
         for (j=0; j<n_devices; j++) {
+            #ifdef MYOKIT_DEBUG_MESSAGES
+            printf("    Checking device %u\n", (unsigned int)j);
+            #endif
 
             // Create device dict, must decref on exception
             device = mcl_info_device_dict(device_ids[j], sizeof(buffer), buffer);
             if (device == NULL) { Py_DECREF(platforms); Py_DECREF(devices); return NULL; }
+            #ifdef MYOKIT_DEBUG_MESSAGES
+            printf("    Obtained device info dict.\n");
+            #endif
 
             // Add device to devices tuple (steals reference)
             PyTuple_SetItem(devices, j, device);

myokit/lib/hh.py

@@ -298,6 +298,9 @@ class HHModel:
                 '_y[' + k + '] = ' + state.uname() + ' = '
                 + inf + ' + (_y0[' + k + '] - ' + inf
                 + ') * numpy.exp(-_t / ' + tau + ')')
+            f.append(
+                '_y[' + k + '][_t == 0] = ' + state.uname() + '[_t == 0] = '
+                + '_y0[' + k + ']')
 
         # Add current calculation
         if self._current is not None:

myokit/tests/test_lib_hh.py

@@ -15,6 +15,8 @@ import myokit.lib.hh as hh
 
 from myokit.tests import DIR_DATA
 
+from myokit.tests import WarningCollector
+
 
 MODEL = """
 [[model]]
@@ -914,6 +916,40 @@ class AnalyticalSimulationTest(unittest.TestCase):
         e = np.abs(d1['binding.I'] - d2['binding.I'])
         self.assertLess(np.max(e), 2e-4)
 
+    def test_tau_overflow(self):
+        # Overflows leading to tau=0 should still report current
+        # https://github.com/myokit/myokit/issues/1059
+
+        # Load model and convert to inf-tau form
+        fname = os.path.join(DIR_DATA, 'lr-1991-fitting.mmt')
+        model = hh.convert_hh_states_to_inf_tau_form(myokit.load_model(fname))
+
+        # Get initial state and set steady state
+        initial_state = model.get('ina.m').initial_value(as_float=True)
+        steady_state = 0.75
+        model.get('ina.m.inf').set_rhs(steady_state)
+
+        # Create an analytical simulation
+        model = hh.HHModel(model, states=['ina.m', 'ina.h', 'ina.j'],
+                           parameters=['ina.p5'], current='ina.INa')
+        p = myokit.pacing.steptrain_linear(20, 40, 10, -80, 10, 10)
+        s = hh.AnalyticalSimulation(model, protocol=p)
+
+        # Setting p5=0.001 will trigger an overflow in ina.m.beta
+        s.set_parameters([0.001])
+        with WarningCollector() as wc:
+            # Log times chosen so that s._function varies length of _t
+            log = s.run(41, log_times=np.array([0, 1, 2, 10, 11, 12, 20, 40]))
+        self.assertIn('overflow', wc.text())
+
+        # Should be no NaNs in log
+        self.assertFalse(np.any(np.isnan(log['ina.INa'])))
+        self.assertFalse(np.any(np.isnan(log['ina.m'])))
+
+        # Should immediately jump from initial state to steady state
+        self.assertTrue(log['ina.m'][0] == initial_state)
+        self.assertTrue(np.all(log['ina.m'][1:] == steady_state))
+
 
 if __name__ == '__main__':
     unittest.main()

{myokit-1.36.0.dist-info → myokit-1.36.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: myokit
-Version: 1.36.0
+Version: 1.36.1
 Summary: A modeling and simulation tool for cardiac cellular electrophysiology
 Home-page: http://myokit.org
 Author: Michael Clerx

{myokit-1.36.0.dist-info → myokit-1.36.1.dist-info}/RECORD

@@ -8,7 +8,7 @@ myokit/_err.py,sha256=PZJFrb3KGqW8XiT466UDtSTsW83M2J02T96Vm2CaCto,11060
 myokit/_expressions.py,sha256=7We9a830pV7bvQziZcjwab-96p0LXg4AfawZhvvdR8U,103902
 myokit/_io.py,sha256=2ll5Yb-sbP4tvc3pPmzhNuv_PaRMPJlNRWb1TzXfELg,8948
 myokit/_model_api.py,sha256=I93WLjstvikqpkqQ5KC4PjNVlSz3nrxms_aKDgSEZ2c,194214
-myokit/_myokit_version.py,sha256=ps-8_nYwMU87PvevIU7ZzXjDQ-nrIwylXhDzIpiv3VM,726
+myokit/_myokit_version.py,sha256=Tj0x0hW2n9taFBS4CUqW6b_QI-kKolONZiG692DKLek,726
 myokit/_parsing.py,sha256=GTVUwJvqjkQ3rc6BiwMFnzanLivbSUzW796gHCTJrNg,74065
 myokit/_progress.py,sha256=Mi2QU6Vqj4qudhXc76amXM31iID2Mo8Gljw5OH2COZ4,4410
 myokit/_protocol.py,sha256=_N16LGHppIv4yCSPjy0q2f-Oed0yG1wMk0ipTtXnMck,30756
@@ -85,14 +85,14 @@ myokit/_sim/cmodel.h,sha256=PlXRNDWV5JDsl28G-k3UlzwFCF5_crkAeWpRgPO8a0s,38795
 myokit/_sim/cmodel.py,sha256=9amSihccWepI1SGI98b5tvvSq2cmAMLX-ecgHoXnc0Y,15775
 myokit/_sim/compiler.c,sha256=yahdqeQhEU4Uduy3xP2NS21k8h2rQXEQTWYpsE6NEFk,4047
 myokit/_sim/compiler.py,sha256=80Qwk7_LOjbu0jt9_aeMLQMEvYj3H4xIoE525zUUEK8,2664
-myokit/_sim/cvodessim.c,sha256=CU7kQcKCIAhuPfb-R83i5Vy8PNCS8PGmwa3mgSu_WdQ,75604
+myokit/_sim/cvodessim.c,sha256=iWXHVSNTN2VqGGu24N8QFRWwpUUxDo17fTIP0Fv0Ikg,78062
 myokit/_sim/cvodessim.py,sha256=EtFixQFg84qQy134TWOAgFd__cUrWs1LdXiJ_YJ-e_Y,46122
 myokit/_sim/differential.hpp,sha256=LiaFNQks_4RkWeNEnUc48XjbdYyGSsxfWo35leygM68,15446
 myokit/_sim/fiber_tissue.c,sha256=mKtNy3Qs2Tg917hgCryaftwJGHqFn7WZAOuJWG3VVpY,47444
 myokit/_sim/fiber_tissue.py,sha256=A3zyGPGHNjFdGgbIzCiKYN8o4L2nq7W_ZjO996jF9Kc,50780
 myokit/_sim/jacobian.cpp,sha256=mvuxHnxiyg4GW-ik1qOgOGbaj-sb-DbtidsRDXfRIjc,8012
 myokit/_sim/jacobian.py,sha256=5Gmli0knQUozhYyarOrMBFnvytKnrufOh3HrGiycUMM,12957
-myokit/_sim/mcl.h,sha256=psbSuBr38bEBhS3CqNfgBjnQflqGny5uDZfL1bpb558,32352
+myokit/_sim/mcl.h,sha256=B8k6eur1VsvnYO2bV94Zm2-B66sCZMgPmzCUQnfelqA,34114
 myokit/_sim/opencl.c,sha256=jQ3eJNldvX-sOnbIrexUSnOmIfEFSL9ceHNYkW18y80,5037
 myokit/_sim/opencl.py,sha256=cHJ4CeqAmDLEik0WSuZ46UJYKmpaq2i0wuEZu_ZC7ng,16446
 myokit/_sim/openclsim.c,sha256=St0P93K0mcYt2oabR7-XRsVFRsrL6kGW-b_kA-P6TsE,46541
@@ -197,7 +197,7 @@ myokit/gui/vargrapher.py,sha256=GALPOZjQ0ShOBu_qd_RwVRRQla0t2ctgQ25Jb8NmuJ8,6072
 myokit/lib/__init__.py,sha256=GWvBrLDJHdbobXjt9WMFAd1td2Ml7dnvtzsDmYfuVFM,216
 myokit/lib/deps.py,sha256=gB-W7LFZK6gAzf00mXvu6ws44Yua06Gd9HsKMe0lpXM,23859
 myokit/lib/guess.py,sha256=BW_wOeStFKpjdZWRZpaO5PLEj8KGSdy_1kc3FM36zfk,28056
-myokit/lib/hh.py,sha256=TR9ENse4bG5uvh-7r5_LyEo7m5IJBcoTP3KEXp1EYIs,46678
+myokit/lib/hh.py,sha256=8wMRnjrjZ8gNeErKz0KYQSqUeljJPPC2G339jPjNFXw,46813
 myokit/lib/markov.py,sha256=VNXvrRdnATILxvuXm-VPw7S_L1Jtd9rRJPtOHKYtxZQ,67940
 myokit/lib/multi.py,sha256=WDYvoAaVsMqnshk1NoVnH1zyVeVZ0GtsdHplZlkG86A,4408
 myokit/lib/plots.py,sha256=tRyM4DhcZzlPLBs-VxdsZ7MJXvqLlDWmC12WhL7pP44,13875
@@ -245,7 +245,7 @@ myokit/tests/test_jacobian_calculator.py,sha256=_nBJdNI0L6tspWX7RgZcM-WW9CJ8oxZp
 myokit/tests/test_jacobian_tracer.py,sha256=SoT6pOXKtzsDHPY2krHVCTtu7BDBtYobhFqejj77q4M,1767
 myokit/tests/test_lib_deps.py,sha256=0Hgw_ncakKuKOe8awVezmTdxIIoVMZz4JjTEFsIOakc,7476
 myokit/tests/test_lib_guess.py,sha256=IqbElIMWQN_FxiGj4tohZq9JZLpSAFzn4d9lo0-WKOE,42333
-myokit/tests/test_lib_hh.py,sha256=rbNtnT_JXGIEbM-nN82IfntHAz7W2XbRW9CCMo7fOB8,31014
+myokit/tests/test_lib_hh.py,sha256=f6QUvPpsJlRQ5gnULlQQUO9yh4sRSYr7rsqQCURNi3o,32591
 myokit/tests/test_lib_markov.py,sha256=Rg_jqgSiKtlpaE6pLiCcmYlCTqyVkPkQ5SIGfyPRv2I,39983
 myokit/tests/test_lib_multi.py,sha256=XL2qxtgNeO2aRaaM1VEzYBo1H3FTBY7-cftqsKwoNHo,5145
 myokit/tests/test_lib_plots.py,sha256=_t1QucHdCoy6fALOZDY9DL0cMRJYB0nflk68LFSwU7U,5754
@@ -391,9 +391,9 @@ myokit/tests/data/multi/beeler-no-name.mmt,sha256=tBeWcTVag1gAQAvxWlUqH6GQhF1D4D
 myokit/tests/data/multi/lr-1991.mmt,sha256=9jzHRAy1nLiBOPioiEpXmsRvIqwEezRY_ve2eHMDbTQ,6013
 myokit/tests/data/multi/not-a-model.csv,sha256=7ek3pQXr2fpjNjFTs-B-T_kEehx8IQ-evdcg24dtMEs,109
 myokit/tests/data/multi/subdir/beeler-no-name.mmt,sha256=tBeWcTVag1gAQAvxWlUqH6GQhF1D4DMnlmuePQn1vBY,3008
-myokit-1.36.0.dist-info/LICENSE.txt,sha256=19_GtuJ-mvPSB1zH9rF_uKVK-bs5bEXFc7PISIRF1KI,1833
-myokit-1.36.0.dist-info/METADATA,sha256=biNDDX8Nml4PH94SP_ocYhcwVn4cN6gFj6iWMCknl5Y,6279
-myokit-1.36.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-myokit-1.36.0.dist-info/entry_points.txt,sha256=yP9wy3w0YAAYUD5PYGliYKhnKvEp5l6p4S_XvXsqreM,48
-myokit-1.36.0.dist-info/top_level.txt,sha256=vopnhGEticqud7tKy6L6dvi_n_AMXoiYBEiboRTnsWY,7
-myokit-1.36.0.dist-info/RECORD,,
+myokit-1.36.1.dist-info/LICENSE.txt,sha256=19_GtuJ-mvPSB1zH9rF_uKVK-bs5bEXFc7PISIRF1KI,1833
+myokit-1.36.1.dist-info/METADATA,sha256=bCxAeMCjxz2LrlwPK6TPNKOUBXlZhfr_Jtqfn_GMBOA,6279
+myokit-1.36.1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+myokit-1.36.1.dist-info/entry_points.txt,sha256=yP9wy3w0YAAYUD5PYGliYKhnKvEp5l6p4S_XvXsqreM,48
+myokit-1.36.1.dist-info/top_level.txt,sha256=vopnhGEticqud7tKy6L6dvi_n_AMXoiYBEiboRTnsWY,7
+myokit-1.36.1.dist-info/RECORD,,