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

myokit/_sim/mcl.h

@@ -67,7 +67,6 @@ static int
 mcl_flag2(const char* msg, const cl_int flag)
 {
     char sub[1024];
-    char err[2048];
 
     if(flag == CL_SUCCESS) {
         return 0;
@@ -82,164 +81,163 @@ mcl_flag2(const char* msg, const cl_int flag)
     switch(flag) {
         // OpenCL 1.0 Errors
         case CL_DEVICE_NOT_FOUND:
-            sprintf(err, "OpenCL error%s: CL_DEVICE_NOT_FOUND", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_DEVICE_NOT_FOUND", sub);
             break;
         case CL_DEVICE_NOT_AVAILABLE:
-            sprintf(err, "OpenCL error%s: CL_DEVICE_NOT_AVAILABLE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_DEVICE_NOT_AVAILABLE", sub);
             break;
         case CL_COMPILER_NOT_AVAILABLE:
-            sprintf(err, "OpenCL error%s: CL_COMPILER_NOT_AVAILABLE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_COMPILER_NOT_AVAILABLE", sub);
             break;
         case CL_MEM_OBJECT_ALLOCATION_FAILURE:
-            sprintf(err, "OpenCL error%s: CL_MEM_OBJECT_ALLOCATION_FAILURE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_MEM_OBJECT_ALLOCATION_FAILURE", sub);
             break;
         case CL_OUT_OF_RESOURCES:
-            sprintf(err, "OpenCL error%s: CL_OUT_OF_RESOURCES", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_OUT_OF_RESOURCES", sub);
             break;
         case CL_OUT_OF_HOST_MEMORY:
-            sprintf(err, "OpenCL error%s: CL_OUT_OF_HOST_MEMORY", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_OUT_OF_HOST_MEMORY", sub);
             break;
         case CL_PROFILING_INFO_NOT_AVAILABLE:
-            sprintf(err, "OpenCL error%s: CL_PROFILING_INFO_NOT_AVAILABLE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_PROFILING_INFO_NOT_AVAILABLE", sub);
             break;
         case CL_MEM_COPY_OVERLAP:
-            sprintf(err, "OpenCL error%s: CL_MEM_COPY_OVERLAP", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_MEM_COPY_OVERLAP", sub);
             break;
         case CL_IMAGE_FORMAT_MISMATCH:
-            sprintf(err, "OpenCL error%s: CL_IMAGE_FORMAT_MISMATCH", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_IMAGE_FORMAT_MISMATCH", sub);
             break;
         case CL_IMAGE_FORMAT_NOT_SUPPORTED:
-            sprintf(err, "OpenCL error%s: CL_IMAGE_FORMAT_NOT_SUPPORTED", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_IMAGE_FORMAT_NOT_SUPPORTED", sub);
             break;
         case CL_BUILD_PROGRAM_FAILURE:
-            sprintf(err, "OpenCL error%s: CL_BUILD_PROGRAM_FAILURE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_BUILD_PROGRAM_FAILURE", sub);
             break;
         case CL_MAP_FAILURE:
-            sprintf(err, "OpenCL error%s: CL_MAP_FAILURE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_MAP_FAILURE", sub);
             break;
         case CL_MISALIGNED_SUB_BUFFER_OFFSET:
-            sprintf(err, "OpenCL error%s: CL_MISALIGNED_SUB_BUFFER_OFFSET", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_MISALIGNED_SUB_BUFFER_OFFSET", sub);
             break;
         case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST:
-            sprintf(err, "OpenCL error%s: CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST", sub);
             break;
         case CL_INVALID_VALUE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_VALUE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_VALUE", sub);
             break;
         case CL_INVALID_DEVICE_TYPE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_DEVICE_TYPE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_DEVICE_TYPE", sub);
             break;
         case CL_INVALID_PLATFORM:
-            sprintf(err, "OpenCL error%s: CL_INVALID_PLATFORM", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_PLATFORM", sub);
             break;
         case CL_INVALID_DEVICE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_DEVICE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_DEVICE", sub);
             break;
         case CL_INVALID_CONTEXT:
-            sprintf(err, "OpenCL error%s: CL_INVALID_CONTEXT", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_CONTEXT", sub);
             break;
         case CL_INVALID_QUEUE_PROPERTIES:
-            sprintf(err, "OpenCL error%s: CL_INVALID_QUEUE_PROPERTIES", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_QUEUE_PROPERTIES", sub);
             break;
         case CL_INVALID_COMMAND_QUEUE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_COMMAND_QUEUE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_COMMAND_QUEUE", sub);
             break;
         case CL_INVALID_HOST_PTR:
-            sprintf(err, "OpenCL error%s: CL_INVALID_HOST_PTR", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_HOST_PTR", sub);
             break;
         case CL_INVALID_MEM_OBJECT:
-            sprintf(err, "OpenCL error%s: CL_INVALID_MEM_OBJECT", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_MEM_OBJECT", sub);
             break;
         case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
-            sprintf(err, "OpenCL error%s: CL_INVALID_IMAGE_FORMAT_DESCRIPTOR", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_IMAGE_FORMAT_DESCRIPTOR", sub);
             break;
         case CL_INVALID_IMAGE_SIZE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_IMAGE_SIZE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_IMAGE_SIZE", sub);
             break;
         case CL_INVALID_SAMPLER:
-            sprintf(err, "OpenCL error%s: CL_INVALID_SAMPLER", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_SAMPLER", sub);
             break;
         case CL_INVALID_BINARY:
-            sprintf(err, "OpenCL error%s: CL_INVALID_BINARY", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_BINARY", sub);
             break;
         case CL_INVALID_BUILD_OPTIONS:
-            sprintf(err, "OpenCL error%s: CL_INVALID_BUILD_OPTIONS", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_BUILD_OPTIONS", sub);
             break;
         case CL_INVALID_PROGRAM:
-            sprintf(err, "OpenCL error%s: CL_INVALID_PROGRAM", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_PROGRAM", sub);
             break;
         case CL_INVALID_PROGRAM_EXECUTABLE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_PROGRAM_EXECUTABLE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_PROGRAM_EXECUTABLE", sub);
             break;
         case CL_INVALID_KERNEL_NAME:
-            sprintf(err, "OpenCL error%s: CL_INVALID_KERNEL_NAME", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_KERNEL_NAME", sub);
             break;
         case CL_INVALID_KERNEL_DEFINITION:
-            sprintf(err, "OpenCL error%s: CL_INVALID_KERNEL_DEFINITION", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_KERNEL_DEFINITION", sub);
             break;
         case CL_INVALID_KERNEL:
-            sprintf(err, "OpenCL error%s: CL_INVALID_KERNEL", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_KERNEL", sub);
             break;
         case CL_INVALID_ARG_INDEX:
-            sprintf(err, "OpenCL error%s: CL_INVALID_ARG_INDEX", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_ARG_INDEX", sub);
             break;
         case CL_INVALID_ARG_VALUE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_ARG_VALUE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_ARG_VALUE", sub);
             break;
         case CL_INVALID_ARG_SIZE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_ARG_SIZE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_ARG_SIZE", sub);
             break;
         case CL_INVALID_KERNEL_ARGS:
-            sprintf(err, "OpenCL error%s: CL_INVALID_KERNEL_ARGS", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_KERNEL_ARGS", sub);
             break;
         case CL_INVALID_WORK_DIMENSION:
-            sprintf(err, "OpenCL error%s: CL_INVALID_WORK_DIMENSION", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_WORK_DIMENSION", sub);
             break;
         case CL_INVALID_WORK_GROUP_SIZE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_WORK_GROUP_SIZE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_WORK_GROUP_SIZE", sub);
             break;
         case CL_INVALID_WORK_ITEM_SIZE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_WORK_ITEM_SIZE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_WORK_ITEM_SIZE", sub);
             break;
         case CL_INVALID_GLOBAL_OFFSET:
-            sprintf(err, "OpenCL error%s: CL_INVALID_GLOBAL_OFFSET", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_GLOBAL_OFFSET", sub);
             break;
         case CL_INVALID_EVENT_WAIT_LIST:
-            sprintf(err, "OpenCL error%s: CL_INVALID_EVENT_WAIT_LIST", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_EVENT_WAIT_LIST", sub);
             break;
         case CL_INVALID_EVENT:
-            sprintf(err, "OpenCL error%s: CL_INVALID_EVENT", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_EVENT", sub);
             break;
         case CL_INVALID_OPERATION:
-            sprintf(err, "OpenCL error%s: CL_INVALID_OPERATION", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_OPERATION", sub);
             break;
         case CL_INVALID_GL_OBJECT:
-            sprintf(err, "OpenCL error%s: CL_INVALID_GL_OBJECT", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_GL_OBJECT", sub);
             break;
         case CL_INVALID_BUFFER_SIZE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_BUFFER_SIZE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_BUFFER_SIZE", sub);
             break;
         case CL_INVALID_MIP_LEVEL:
-            sprintf(err, "OpenCL error%s: CL_INVALID_MIP_LEVEL", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_MIP_LEVEL", sub);
             break;
         case CL_INVALID_GLOBAL_WORK_SIZE:
-            sprintf(err, "OpenCL error%s: CL_INVALID_GLOBAL_WORK_SIZE", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_GLOBAL_WORK_SIZE", sub);
             break;
         case CL_INVALID_PROPERTY:
-            sprintf(err, "OpenCL error%s: CL_INVALID_PROPERTY", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_INVALID_PROPERTY", sub);
             break;
         // OpenCL 1.1 etc. codes can not be assumed to be defined
         // Might be good to have ifdefs or something
         // OpenCL extensions
         case -1001:     // CL_PLATFORM_NOT_FOUND_KHR
-            sprintf(err, "OpenCL error%s: CL_PLATFORM_NOT_FOUND_KHR", sub);
+            PyErr_Format(PyExc_Exception, "OpenCL error%s: CL_PLATFORM_NOT_FOUND_KHR", sub);
             break;
         // Unknown error
         default:
-            sprintf(err, "Unknown OpenCL error%s: %i", sub, (int)flag);
+            PyErr_Format(PyExc_Exception, "Unknown OpenCL error%s: %i", sub, (int)flag);
             break;
     };
-    PyErr_SetString(PyExc_Exception, err);
     return 1;
 }
 
@@ -522,7 +520,7 @@ int mcl_platform_supports_extension(cl_platform_id platform_id, const char* exte
  *
  * Arguments:
  *  cl_platform_id platform_id  The id of the platform to query
- *  char* buffer                An initialised string buffer, that can be used
+ *  char* buffer                An initialized string buffer, that can be used
  *                              to read and write string information.
  *
  * Returns NULL and sets an error message if any exception occurs.
@@ -611,7 +609,7 @@ PyObject* mcl_info_platform_dict(cl_platform_id platform_id, size_t bufsize, cha
  * Arguments:
  *  cl_device_id device_id  The id of the device to query.
  *  size_t bufsize          Size of the string `buffer`.
- *  char* buffer            An initialised string buffer, that can be used to
+ *  char* buffer            An initialized string buffer, that can be used to
  *                          read and write string information.
  *
  * Returns NULL and sets an error message if any exception occurs.

myokit/_sim/opencl.py

@@ -4,24 +4,14 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
+import configparser
 import os
-import myokit
-
-try:
-    # Python2
-    from ConfigParser import ConfigParser
-except ImportError:
-    # Python 3
-    from configparser import RawConfigParser as ConfigParser
 
+import myokit
 
 # Settings file
 SETTINGS_FILE = os.path.join(myokit.DIR_USER, 'preferred-opencl-device.ini')
 
-
 # Location of C source for OpenCL info module
 SOURCE_FILE = 'opencl.c'
 
@@ -41,7 +31,7 @@ class OpenCL(myokit.CModule):
     _message = None
 
     def __init__(self):
-        super(OpenCL, self).__init__()
+        super().__init__()
         # Create back-end and cache it
         OpenCL._index += 1
         mname = 'myokit_opencl_info_' + str(OpenCL._index)
@@ -165,11 +155,8 @@ class OpenCL(myokit.CModule):
         # Read ini file
         inifile = os.path.expanduser(SETTINGS_FILE)
         if os.path.isfile(inifile):
-            config = ConfigParser()
-            try:
-                config.read(inifile, encoding='ascii')  # Python 3
-            except TypeError:   # pragma: no python 3 cover
-                config.read(inifile)
+            config = configparser.RawConfigParser()
+            config.read(inifile, encoding='ascii')
 
             def get(section, option):
                 x = None
@@ -205,7 +192,7 @@ class OpenCL(myokit.CModule):
             device = device.encode('ascii').decode('ascii')
 
         # Create configuration
-        config = ConfigParser()
+        config = configparser.RawConfigParser()
         config.add_section('selection')
         if platform:
             config.set('selection', 'platform', platform)
@@ -271,7 +258,7 @@ class OpenCL(myokit.CModule):
     '''
 
 
-class OpenCLInfo(object):
+class OpenCLInfo:
     """
     Represents information about the available OpenCL platforms and devices.
 
@@ -288,14 +275,18 @@ class OpenCLInfo(object):
         """
         Returns a formatted string version of this object's information.
         """
+        selected_platform, selected_device = myokit.OpenCL.load_selection()
         b = []
         for i, platform in enumerate(self.platforms):
-            b.append('Platform ' + str(i))
-            platform._format(b, pre=' ')
+            pname = 'Platform ' + str(i)
+            if platform.name == selected_platform:  # pragma: no cover
+                pname += '  <-- Selected platform in myokit.ini'
+            b.append(pname)
+            platform._format(b, selected_platform, selected_device, pre=' ')
         return '\n'.join(b)
 
 
-class OpenCLPlatformInfo(object):
+class OpenCLPlatformInfo:
     """
     Represents information about an OpenCL platform.
 
@@ -342,10 +333,10 @@ class OpenCLPlatformInfo(object):
         """
         b = []
         b.append('Platform: ' + self.name)
-        self._format(b, ' ', name=False)
+        self._format(b, pre=' ', name=False)
         return '\n'.join(b)
 
-    def _format(self, b, pre='', name=True):
+    def _format(self, b, p_selected=None, d_selected=None, pre='', name=True):
         """
         Formats the information in this object and adds it to the list ``b``.
         """
@@ -358,7 +349,10 @@ class OpenCLPlatformInfo(object):
         if self.devices is not None:
             b.append(pre + 'Devices:')
             for j, device in enumerate(self.devices):
-                b.append(pre + ' Device ' + str(j))
+                dname = pre + ' Device ' + str(j)
+                if self.name == p_selected and device.name == d_selected:  # pragma: no cover # noqa
+                    dname += '  <-- Selected device in myokit.ini'
+                b.append(dname)
                 device._format(b, pre + '  ')
 
         if self.device is not None:
@@ -369,7 +363,7 @@ class OpenCLPlatformInfo(object):
         return extension in self.extensions
 
 
-class OpenCLDeviceInfo(object):
+class OpenCLDeviceInfo:
     """
     Represents information about an OpenCL device.
 

myokit/_sim/openclsim.c

@@ -515,9 +515,7 @@ sim_init(PyObject* self, PyObject* args)
     for(i=0; i<nx * ny * n_state; i++) {
         flt = PyList_GetItem(state_in, (Py_ssize_t)i);    // Don't decref!
         if(!PyFloat_Check(flt)) {
-            char errstr[200];
-            sprintf(errstr, "Item %u in state vector is not a float.", (unsigned int)i);
-            PyErr_SetString(PyExc_Exception, errstr);
+            PyErr_Format(PyExc_Exception, "Item %u in state vector is not a float.", (unsigned int)i);
             return sim_clean();
         }
         rvec_state[i] = (Real)PyFloat_AsDouble(flt);
@@ -552,9 +550,7 @@ sim_init(PyObject* self, PyObject* args)
         for(i=0; i<n_field_data; i++) {
             flt = PyList_GetItem(field_data, (Py_ssize_t)i);    // No need to decref
             if(!PyFloat_Check(flt)) {
-                char errstr[200];
-                sprintf(errstr, "Item %u in field data is not a float.", (unsigned int)i);
-                PyErr_SetString(PyExc_Exception, errstr);
+                PyErr_Format(PyExc_Exception, "Item %u in field data is not a float.", (unsigned int)i);
                 return sim_clean();
             }
             rvec_field_data[i] = (Real)PyFloat_AsDouble(flt);
@@ -975,7 +971,7 @@ for var in model.states():
         print(3*tab + 'sprintf(log_var_name, "%u.' + var.qname() + '", (unsigned int)j);')
     else:
         print(3*tab + 'sprintf(log_var_name, "%u.%u.' + var.qname() + '", (unsigned int)j, (unsigned int)i);' )
-    print(3*tab + 'if(log_add(log_dict, logs, vars, k_vars, log_var_name, &rvec_state[(i*nx+j)*n_state+' + str(var.indice()) + '])) {')
+    print(3*tab + 'if(log_add(log_dict, logs, vars, k_vars, log_var_name, &rvec_state[(i*nx+j)*n_state+' + str(var.index()) + '])) {')
     print(4*tab + 'logging_states = 1;')
     print(4*tab + 'k_vars++;')
     print(3*tab + '}')

myokit/_sim/openclsim.cl

@@ -152,8 +152,8 @@ if precision == myokit.DOUBLE_PRECISION:
 
 <?
 if diffusion:
-    print('/* Indice of membrane potential in state vector */')
-    print('#define i_vm ' + str(model.label('membrane_potential').indice()))
+    print('/* Index of membrane potential in state vector */')
+    print('#define i_vm ' + str(model.label('membrane_potential').index()))
 
 if precision == myokit.SINGLE_PRECISION:
     print('/* Using single precision floats */')
@@ -188,7 +188,7 @@ for group in equations.values():
 print('')
 print('/* Aliases of state variables. */')
 for var in model.states():
-    print('#define ' + v(var) + ' state[of1 + ' + str(var.indice()) + ']')
+    print('#define ' + v(var) + ' state[of1 + ' + str(var.index()) + ']')
 
 print('')
 print('/* Aliases of logged intermediary variables. */')

myokit/_sim/openclsim.py

@@ -5,15 +5,15 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import os
-import myokit
-import numpy as np
 import platform
+
 from collections import OrderedDict
 
+import numpy as np
+
+import myokit
+
 
 # Location of C and OpenCL sources
 SOURCE_FILE = 'openclsim.c'
@@ -58,7 +58,7 @@ class SimulationOpenCL(myokit.CModule):
     ``pace``
         The pacing level, this is set if a protocol was passed in.
     ``diffusion_current`` (if enabled)
-        The current flowing from the cell to its neighbours. This will be
+        The current flowing from the cell to its neighbors. This will be
         positive when the cell is acting as a source, negative when it is
         acting as a sink.
 
@@ -103,7 +103,7 @@ class SimulationOpenCL(myokit.CModule):
     cells ``i - 1`` and ``i + 1`` (except at the boundaries).
     Similarly, if ``ncells`` is a 2-dimensional tuple ``(nx, ny)`` a grid will
     be assumed so that each (non-boundary) cell is connected to four
-    neighbours.
+    neighbors.
     Finally, arbitrary geometries can be used by passing a scalar to ``ncells``
     and specifying the connections with :meth:`set_connections`.
 
@@ -148,7 +148,7 @@ class SimulationOpenCL(myokit.CModule):
     def __init__(
             self, model, protocol=None, ncells=256, diffusion=True,
             precision=myokit.SINGLE_PRECISION, native_maths=False, rl=False):
-        super(SimulationOpenCL, self).__init__()
+        super().__init__()
 
         # Require a valid model
         if not model.is_valid():
@@ -272,7 +272,7 @@ class SimulationOpenCL(myokit.CModule):
         self._nstate = self._model.count_states()
 
         # Set state and default state
-        self._state = self._model.state() * self._ntotal
+        self._state = self._model.initial_values(True) * self._ntotal
         self._default_state = list(self._state)
 
         # List of globally logged inputs
@@ -283,7 +283,7 @@ class SimulationOpenCL(myokit.CModule):
         inputs = {'time': 'time', 'pace': 'pace'}
         if self._diffusion_enabled:
             inputs['diffusion_current'] = 'idiff'
-        self._bound_variables = self._model.prepare_bindings(inputs)
+        self._bound_variables = myokit._prepare_bindings(self._model, inputs)
 
         # Create unique names
         self._model.create_unique_names()
@@ -657,7 +657,7 @@ class SimulationOpenCL(myokit.CModule):
 
         # Get value causing error
         if var.is_state():
-            value = states[1 if ifirst > 0 else 0][var.indice()]
+            value = states[1 if ifirst > 0 else 0][var.index()]
         else:  # pragma: no cover
             value = bounds[1 if ifirst > 0 else 0][var.qname()]
         var = var.qname()
@@ -765,9 +765,9 @@ class SimulationOpenCL(myokit.CModule):
 
             I_diff[i] = sum[g[i,j] * (V[i] - V[j])]
 
-        in which the sum is over all neighbours ``j`` of cell ``i``.
+        in which the sum is over all neighbors ``j`` of cell ``i``.
 
-        Alternatively, with capacitance and currents normalised to membrane
+        Alternatively, with capacitance and currents normalized to membrane
         area, we can write::
 
             dV/dt = -1/cm (i_ion + i_stim + i_diff)
@@ -787,10 +787,10 @@ class SimulationOpenCL(myokit.CModule):
 
             g_bar = (1 / chi) * (k / (k + 1)) * D * (1 / dx^2)
 
-        where ``g_bar`` is the cell-to-cell conductance, but normalised with
+        where ``g_bar`` is the cell-to-cell conductance, but normalized with
         respect to unit membrane area.
-        For models with currents normalised to area this is unproblematic, but
-        to convert to models with unnormalised currents this means we have
+        For models with currents normalized to area this is unproblematic, but
+        to convert to models with unnormalized currents this means we have
         added the further assumption that **each node contains some fixed
         amount of membrane**, determined by an area A::
 
@@ -825,9 +825,9 @@ class SimulationOpenCL(myokit.CModule):
         """
         return D * A * k / ((k + 1) * chi * dx * dx)
 
-    def neighbours(self, x, y=None):
+    def neighbors(self, x, y=None):
         """
-        Returns a list of indices specifying the neighbours of the cell at
+        Returns a list of indices specifying the neighbors of the cell at
         index ``x`` (or index ``(x, y)`` for 2d simulations).
 
         Indices are given either as integers (1d or arbitrary geometry) or as
@@ -857,29 +857,38 @@ class SimulationOpenCL(myokit.CModule):
 
         # User-specified connections (always 1d)
         if self._connections is not None:
-            neighbours = []
+            neighbors = []
             for i, j, c in self._connections:
                 if i == x:
-                    neighbours.append(j)
+                    neighbors.append(j)
                 elif j == x:
-                    neighbours.append(i)
-            return neighbours
+                    neighbors.append(i)
+            return neighbors
 
-        # Left and right neighbours
-        neighbours = []
+        # Left and right neighbors
+        neighbors = []
         if x > 0:
-            neighbours.append(x - 1)
+            neighbors.append(x - 1)
         if x + 1 < self._dims[0]:
-            neighbours.append(x + 1)
+            neighbors.append(x + 1)
 
-        # Top and bottom neighbours
+        # Top and bottom neighbors
         if len(self._dims) == 2:
-            neighbours = [(i, y) for i in neighbours]
+            neighbors = [(i, y) for i in neighbors]
             if y > 0:
-                neighbours.append((x, y - 1))
+                neighbors.append((x, y - 1))
             if y + 1 < self._dims[1]:
-                neighbours.append((x, y + 1))
-        return neighbours
+                neighbors.append((x, y + 1))
+        return neighbors
+
+    def neighbours(self, x, y=None):
+        """ Alias of :meth:`neighbors`. """
+        # Deprecated since 2023-06-07
+        import warnings
+        warnings.warn('The method SimulationOpenCL.neighbours() is deprecated.'
+                      ' Please use neighbors() instead.')
+
+        return self.neighbors(x, y)
 
     def pre(self, duration, report_nan=True, progress=None,
             msg='Pre-pacing SimulationOpenCL'):
@@ -1165,14 +1174,14 @@ class SimulationOpenCL(myokit.CModule):
                     vdiff = self._model.binding('diffusion_current')
                     vdiff = None if vdiff is None else vdiff.qname()
 
-                # List all neighbours for this cell
-                neighbours = self.neighbours(*icell)
+                # List all neighbors for this cell
+                neighbors = self.neighbors(*icell)
                 if len(self._dims) == 2:
-                    neighbours_str = ', '.join(
+                    neighbors_str = ', '.join(
                         ('(' + ','.join([str(i) for i in j]) + ')')
-                        for j in neighbours)
+                        for j in neighbors)
                 else:
-                    neighbours_str = ', '.join(str(j) for j in neighbours)
+                    neighbors_str = ', '.join(str(j) for j in neighbors)
 
                 # Show final state
                 txt.append('State during:')
@@ -1192,8 +1201,8 @@ class SimulationOpenCL(myokit.CModule):
                     txt.append(
                         '  Diffusion current: ' + myokit.float.str(
                             bounds[0][vdiff], precision=self._precision))
-                if neighbours:
-                    txt.append('  Connected cells: ' + neighbours_str)
+                if neighbors:
+                    txt.append('  Connected cells: ' + neighbors_str)
 
                 # Show previous state (and derivatives)
                 n_states = len(states)
@@ -1239,8 +1248,8 @@ class SimulationOpenCL(myokit.CModule):
                         txt.append(
                             '  Diffusion current: ' + myokit.float.str(
                                 bounds[1][vdiff], precision=self._precision))
-                    if neighbours:
-                        txt.append('  Connected cells: ' + neighbours_str)
+                    if neighbors:
+                        txt.append('  Connected cells: ' + neighbors_str)
 
                     # Show all variables with non-finite values
                     txt.append(