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

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/_sim/openclsim.py

@@ -534,7 +534,7 @@ class SimulationOpenCL(myokit.CModule):
                 lower, upper = safe_range
                 for dims in myokit._dimco(*self._dims):
                     key = '.'.join([str(x) for x in dims]) + post
-                    ar = np.array(_log[key], copy=False)
+                    ar = np.asarray(_log[key])
                     i = np.where(
                         (ar < lower)
                         | (ar > upper)
@@ -1080,7 +1080,7 @@ class SimulationOpenCL(myokit.CModule):
         n = len(self._fields) * self._nx * self._ny
         if n:
             field_data = self._fields.values()
-            field_data = [np.array(x, copy=False) for x in field_data]
+            field_data = [np.asarray(x) for x in field_data]
             field_data = np.vstack(field_data)
             field_data = list(field_data.reshape(n, order='F'))
         else:
@@ -1342,7 +1342,7 @@ class SimulationOpenCL(myokit.CModule):
                 'This method is unavailable when diffusion is disabled.')
 
         # Check the field's size
-        gx = np.array(gx, copy=False, dtype=float)
+        gx = np.asarray(gx, dtype=float)
         if len(self._dims) == 1:
             s = self._nx - 1
             if gx.shape != (s, ):
@@ -1360,7 +1360,7 @@ class SimulationOpenCL(myokit.CModule):
             if gy is None:
                 raise ValueError(
                     'The argument `gy` must be set for 2-d simulations.')
-            gy = np.array(gy, copy=False, dtype=float)
+            gy = np.asarray(gy, dtype=float)
             s = (self._ny - 1, self._nx)
             if gy.shape != s:
                 raise ValueError(
@@ -1514,7 +1514,7 @@ class SimulationOpenCL(myokit.CModule):
         if not var.is_constant():
             raise ValueError('Only constants can be used for fields.')
         # Check values
-        values = np.array(values, copy=False, dtype=float)
+        values = np.asarray(values, dtype=float)
         if len(self._dims) == 1:
             if values.shape != (self._nx, ):
                 raise ValueError(

myokit/_sim/rhs.py

@@ -153,7 +153,7 @@ class RhsBenchmarker(myokit.CModule):
         the given benchmarked times.
         """
         import numpy as np
-        times = np.array(times, copy=False)
+        times = np.asarray(times)
         # Remove outliers twice
         for i in range(0, 2):
             avg = np.mean(times)

myokit/formats/__init__.py

@@ -128,15 +128,7 @@ class ExpressionWriter:
        ``a**b**c`` is interpreted as ``a**(b**c)``, necessitating a different
        bracket-adding logic than used in Myokit.
 
-    3. Binary operators are sometimes implemented as n-ary operators. In
-       Myokit, ``0 == 0 == 0`` is a sequence of two binary operators,
-       interpreted as ``(0 == 0) == 0``. Because ``(0 == 0)`` evaluates to
-       ``1``, this expression returns ``0`` (1 does not equal 0). In Python,
-       the expression ``0 == 0 == 0`` is a ternary (n-ary) operator,
-       interpreted as ``all_equal(0, 0, 0)``, which evaluates to ``1``. For
-       languages that use this convention, extra brackets must be added.
-
-    4. Myokit does not have increment or decrement operators ``--`` and ``++``,
+    3. Myokit does not have increment or decrement operators ``--`` and ``++``,
        so the expression ``--x`` is interpreted as ``-(-x)``. This is the same
        in Python. But in C-based languages, this is interpreted as a decrement
        operator so care must be taken to add extra brackets.
@@ -886,6 +878,9 @@ class SweepSource:
 
         Note that a source with zero recorded channels may still report a
         non-zero number of sweeps if it can provide D/A outputs.
+
+        Similarly, formats like WCP can report zero sweeps but have a non-zero
+        channel count (if no data was recorded).
         """
         raise NotImplementedError
 

myokit/formats/ansic/_ewriter.py

@@ -102,23 +102,14 @@ class CBasedExpressionWriter(PythonExpressionWriter):
 
     def _ex_not(self, e):
         # C conditions all have brackets, so don't add more
-        if isinstance(e[0], (myokit.Condition)):
-            return f'(!{self.ex(e[0])})'
-        # But do add more if the user's being silly
-        return f'(!({self.ex(e[0])}))'
+        return f'(!{self.ex(e[0])})'
 
     def _ex_if(self, e):
-        _if, _then, _else = self.ex(e._i), self.ex(e._t), self.ex(e._e)
-        # If i is not a condtion (which always gets brackets from this writer)
-        # then add brackets
-        if not isinstance(e._i, myokit.Condition):
-            _if = f'({_if})'
-        return f'({_if} ? {_then} : {_else})'
+        return f'({self.ex(e._i)} ? {self.ex(e._t)} : {self.ex(e._e)})'
 
     def _ex_piecewise(self, e):
         # Render ifs; add extra bracket if not a condition (see _ex_if)
-        _ifs = [self.ex(x) if isinstance(x, myokit.Condition)
-                else f'({self.ex(x)})' for x in e._i]
+        _ifs = [self.ex(x) for x in e._i]
         _thens = [self.ex(x) for x in e._e]
 
         s = []
@@ -200,13 +191,7 @@ class AnsiCExpressionWriter(CBasedExpressionWriter):
     #def _ex_not(self, e):
 
     def _ex_if(self, e):
-        # Allow _fcond
-
         _if, _then, _else = self.ex(e._i), self.ex(e._t), self.ex(e._e)
-        # If i is not a condtion (which always gets brackets from this writer)
-        # then add brackets
-        if not isinstance(e._i, myokit.Condition):
-            _if = f'({_if})'
 
         # Use if-then-else function?
         if self._fcond is not None:
@@ -219,8 +204,7 @@ class AnsiCExpressionWriter(CBasedExpressionWriter):
         # Allow _fcond
 
         # Render ifs; add extra bracket if not a condition (see _ex_if)
-        _ifs = [self.ex(x) if isinstance(x, myokit.Condition)
-                else f'({self.ex(x)})' for x in e._i]
+        _ifs = [self.ex(x) for x in e._i]
         _thens = [self.ex(x) for x in e._e]
 
         s = []

myokit/formats/heka/_patchmaster.py

@@ -928,6 +928,7 @@ class Series(TreeNode, myokit.formats.SweepSource):
                 include_da = False
 
         # Populate log
+        log.set_time_key('time')
         if join_sweeps:
             # Join sweeps
             offsets = (self._sweep_starts_r if use_real_start_times
@@ -964,31 +965,34 @@ class Series(TreeNode, myokit.formats.SweepSource):
                     log.cmeta[name]['unit'] = self._da_units[0]
 
         # Add meta data
-        log.set_time_key('time')
+        log.meta['time'] = self._time.strftime(myokit.DATE_FORMAT)
         a = self.amplifier_state()
+        t = self[0][0] if len(self) and len(self[0]) else None
         log.meta['current_gain_mV_per_pA'] = a.current_gain()
+        log.meta['filter1'] = a.filter1()
+        if t is not None:
+            log.meta['r_pipette_MOhm'] = t.r_pipette()
+            log.meta['r_seal_MOhm'] = t.r_seal()
         log.meta['ljp_correction_mV'] = a.ljp()
-        log.meta['c_slow_compensation_pF'] = a.c_slow()
+        log.meta['voltage_offset_mV'] = a.v_off()
         if a.c_fast_enabled():
             log.meta['c_fast_compensation_enabled'] = 'true'
             log.meta['c_fast_pF'] = a.c_fast()
-            log.meta['c_fast_tau_micro_s'] = a.c_fast_tau()
+            log.meta['c_fast_tau_us'] = a.c_fast_tau()
         else:
             log.meta['c_fast_compensation_enabled'] = 'false'
+        log.meta['c_slow_pF'] = a.c_slow()
         log.meta['r_series_MOhm'] = a.r_series()
         if a.r_series_enabled():
             log.meta['r_series_compensation_enabled'] = 'true'
             log.meta['r_series_compensation_percent'] = round(
                 a.r_series_fraction() * 100, 1)
+            log.meta['r_series_compensation_tau_us'] = a.r_series_tau()
+            if t is not None:
+                log.meta['r_series_post_compensation_MOhm'] = \
+                    t.r_series_remaining()
         else:
             log.meta['r_series_compensation_enabled'] = 'false'
-        if len(self) and len(self[0]):
-            t = self[0][0]
-            log.meta['r_pipette_MOhm'] = t.r_pipette()
-            log.meta['r_seal_MOhm'] = t.r_series()
-            log.meta['r_series_post_compensation_MOhm'] = \
-                t.r_series_remaining()
-            log.meta['c_slow_pF'] = t.c_slow()
 
         return log
 
@@ -1035,6 +1039,8 @@ class Series(TreeNode, myokit.formats.SweepSource):
         if a.r_series_enabled():
             p = round(a.r_series_fraction() * 100, 1)
             out.append(f'  R series compensation: {p} %.')
+            p = round(a.r_series_tau(), 1)
+            out.append(f'  R series compensation tau: {p} us')
         else:
             out.append('  R series compensation: not enabled')
         if len(self) and len(self[0]):

myokit/formats/opencl/_ewriter.py

@@ -31,27 +31,6 @@ class OpenCLExpressionWriter(CBasedExpressionWriter):
         self._sp = (precision == myokit.SINGLE_PRECISION)
         self._nm = bool(native_math)
 
-    def _exc(self, e):
-        """Returns ``ex(e)`` if ``e`` is a Condition, else ``ex(e != 0)``."""
-        # Can be removed after https://github.com/myokit/myokit/issues/1056
-        if isinstance(e, myokit.Condition):
-            return self.ex(e)
-        return self.ex(myokit.NotEqual(e, myokit.Number(0)))
-
-    def _ex_infix_comparison(self, e, op):
-        """Handles ex() for infix condition operators (==, !=, > etc.)."""
-        # Can be removed after https://github.com/myokit/myokit/issues/1056
-        c1 = isinstance(e[0], myokit.Condition)
-        c2 = isinstance(e[1], myokit.Condition)
-        if (c1 and c2) or not (c1 or c2):
-            return f'({self.ex(e[0])} {op} {self.ex(e[1])})'
-        else:
-            return f'({self._exc(e[0])} {op} {self._exc(e[1])})'
-
-    def _ex_infix_logical(self, e, op):
-        # Can be removed after https://github.com/myokit/myokit/issues/1056
-        return f'({self._exc(e[0])} {op} {self._exc(e[1])})'
-
     #def _ex_name(self, e):
     #def _ex_derivative(self, e):
     #def _ex_initial_value(self, e):
@@ -126,25 +105,7 @@ class OpenCLExpressionWriter(CBasedExpressionWriter):
 
     #def _ex_and(self, e):
     #def _ex_or(self, e):
-
-    def _ex_not(self, e):
-        # Can be removed after https://github.com/myokit/myokit/issues/1056
-        return f'(!{self._exc(e[0])})'
-
-    def _ex_if(self, e):
-        # Can be removed after https://github.com/myokit/myokit/issues/1056
-        _if, _then, _else = self._exc(e._i), self.ex(e._t), self.ex(e._e)
-        return f'({_if} ? {_then} : {_else})'
-
-    def _ex_piecewise(self, e):
-        # Can be removed after https://github.com/myokit/myokit/issues/1056
-        _ifs = [self._exc(x) for x in e._i]
-        _thens = [self.ex(x) for x in e._e]
-        s = []
-        n = len(_ifs)
-        for _if, _then in zip(_ifs, _thens):
-            s.append(f'({_if} ? {_then} : ')
-        s.append(_thens[-1])
-        s.append(')' * len(_ifs))
-        return ''.join(s)
+    #def _ex_not(self, e):
+    #def _ex_if(self, e):
+    #def _ex_piecewise(self, e):
 

myokit/formats/opencl/template/minilog.py

@@ -177,7 +177,7 @@ class DataLog(OrderedDict):
         import numpy as np
         out = DataLog()
         for k, d in self.items():
-            out[k] = np.array(d, copy=False)
+            out[k] = np.asarray(d)
         return out
 
     def save_csv(self, filename, pad=None):

myokit/formats/sympy/_ereader.py

@@ -156,7 +156,8 @@ class SymPyExpressionReader:
     def _ex_abs(self, e):
         return myokit.Abs(self.ex(e.args[0]))
 
-    def _ex_not(self, e):
+    def _ex_not(self, e):   # pragma: no cover
+        # Sympy turns not(a == b) into a != b etc., so can't test!
         return myokit.Not(self.ex(e.args[0]))
 
     def _ex_equal(self, e):

myokit/formats/wcp/_wcp.py

@@ -241,7 +241,7 @@ class WcpFile(myokit.formats.SweepSource):
 
     def _channel_id(self, channel_id):
         """ Checks an int or str channel id and returns a valid int. """
-        if self._nr == 0:  # pragma: no cover
+        if self._nr == 0:
             raise KeyError(f'Channel {channel_id} not found (empty file).')
 
         # Handle string
@@ -314,7 +314,7 @@ class WcpFile(myokit.formats.SweepSource):
 
         # Create log
         log = myokit.DataLog()
-        if self._nr == 0:  # pragma: no cover
+        if self._nr == 0:
             return log
 
         # Get channel names
@@ -433,7 +433,7 @@ class WcpFile(myokit.formats.SweepSource):
         return self._nr
 
     def records(self):
-        """ Deprecated alias of :meth:`sweep_count`. """
+        """ Deprecated alias of :meth:`record_count`. """
         # Deprecated since 2023-06-22
         import warnings
         warnings.warn(

myokit/gui/datalog_viewer.py

@@ -641,13 +641,18 @@ class SweepSourceTab(GraphTabWidget):
     def __init__(self, parent, source):
         super().__init__(parent)
 
-        # Add A/D
-        for i in range(source.channel_count()):
-            self._add_graph_tab(source, i)
-
-        # Add D/A
-        for i in range(source.da_count()):
-            self._add_graph_tab(source, i, True)
+        if source.sweep_count() > 0:
+            # Must have this condition to avoid getting exceptions with e.g.
+            # the empty WCP file in the test data set.
+            # myokit log myokit/tests/data/formats/wcp-file-empty.wcp
+
+            # Add A/D
+            for i in range(source.channel_count()):
+                self._add_graph_tab(source, i)
+
+            # Add D/A
+            for i in range(source.da_count()):
+                self._add_graph_tab(source, i, True)
 
         # Add meta data
         self._add_meta_tab(source)

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/lib/markov.py

@@ -1077,7 +1077,7 @@ class AnalyticalSimulation:
         y0 = PI.dot(self._state.reshape((n, 1)))
 
         # Reshape times array
-        times = np.array(times, copy=False).reshape((len(times),))
+        times = np.asarray(times).reshape((len(times),))
 
         # Calculate state
         x = P.dot(y0 * np.exp(times * E))
@@ -1223,7 +1223,7 @@ class DiscreteSimulation:
 
         Returns a discretized state ``y`` where ``sum(y) = nchannels``.
         """
-        x = np.array(x, copy=False, dtype=float)
+        x = np.asarray(x, dtype=float)
         if (np.abs(1 - np.sum(x))) > 1e-6:
             raise ValueError(
                 'The sum of fractions in the state to be discretized must'

myokit/lib/plots.py

@@ -62,28 +62,28 @@ def simulation_times(
     def stair(ax, time, realtime, evaluations):
         if time is None:
             raise ValueError('This plotting mode requires "time" to be set.')
-        time = np.array(time, copy=False)
+        time = np.asarray(time)
         step = np.arange(0, len(time))
         ax.step(time, step, label=label)
 
     def stair_inverse(ax, time, realtime, evaluations):
         if time is None:
             raise ValueError('This plotting mode requires "time" to be set.')
-        time = np.array(time, copy=False)
+        time = np.asarray(time)
         step = np.arange(0, len(time))
         ax.step(step, time, label=label)
 
     def load(ax, time, realtime, evaluations):
         if time is None:
             raise ValueError('This plotting mode requires "time" to be set.')
-        time = np.array(time, copy=False)
+        time = np.asarray(time)
         size = np.log(1 / (time[1:] - time[:-1]))
         ax.step(time[1:], size, label=label)
 
     def histo(ax, time, realtime, evaluations):
         if time is None:
             raise ValueError('This plotting mode requires "time" to be set.')
-        time = np.array(time, copy=False)
+        time = np.asarray(time)
         zero = float(time[0])
         bucket_w = (time[-1] - zero) / nbuckets
         bucket_x = np.zeros(nbuckets)

myokit/tests/test_datablock.py

@@ -167,11 +167,11 @@ class DataBlock1dTest(unittest.TestCase):
         d = myokit.DataLog()
         d.set_time_key('time')
         d['time'] = time
-        d['x', 0] = np.array(down, copy=True)
-        d['x', 1] = np.array(down, copy=True)
-        d['x', 2] = np.array(down, copy=True)
-        d['x', 3] = np.array(down, copy=True)
-        d['x', 4] = np.array(down, copy=True)
+        d['x', 0] = np.copy(down)
+        d['x', 1] = np.copy(down)
+        d['x', 2] = np.copy(down)
+        d['x', 3] = np.copy(down)
+        d['x', 4] = np.copy(down)
         d['x', 1][10:] = 40
         b = myokit.DataBlock1d.from_log(d)
         self.assertEqual(b.cv('x'), 0)
@@ -180,11 +180,11 @@ class DataBlock1dTest(unittest.TestCase):
         d = myokit.DataLog()
         d.set_time_key('time')
         d['time'] = time
-        d['x', 0] = np.array(down, copy=True)
-        d['x', 1] = np.array(down, copy=True)
-        d['x', 2] = np.array(down, copy=True)
-        d['x', 3] = np.array(down, copy=True)
-        d['x', 4] = np.array(down, copy=True)
+        d['x', 0] = np.copy(down)
+        d['x', 1] = np.copy(down)
+        d['x', 2] = np.copy(down)
+        d['x', 3] = np.copy(down)
+        d['x', 4] = np.copy(down)
         d['x', 1][10:] = 40
         d['x', 2][10:] = 40
         d['x', 3][10:] = 40

myokit/tests/test_datalog.py

@@ -2109,9 +2109,12 @@ class DataLogTest(unittest.TestCase):
         self.assertRaises(ValueError, d.split_periodic, 0)
         self.assertRaises(ValueError, d.split_periodic, -1)
 
-        # Test larger period than log data
+        # Test larger period than log data: Should return length-1 list
         d['x'] = [4, 5, 6, 7]
         e = d.split_periodic(100)
+        self.assertIsInstance(e, list)
+        self.assertEqual(len(e), 1)
+        e = e[0]
         self.assertEqual(set(d.keys()), set(e.keys()))
         self.assertFalse(d is e)