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

myokit/_model_api.py

@@ -716,7 +716,10 @@ class VarOwner(ModelPart, VarProvider):
         If ``recursive`` is ``True``, any child variables will be deleted as
         well.
 
-        A :class:`myokit.IntegrityError` will be raised if
+        A :class:`myokit.IntegrityError` will be raised if the variable cannot
+        be removed because other variables depend on it. (Although dependencies
+        from child variables will be ignored if ``recursive`` is set to
+        ``True``).
         """
         if variable.parent() != self:
             raise ValueError(
@@ -1095,9 +1098,7 @@ class Model(ObjectWithMetaData, VarProvider):
                 raise myokit.IncompatibleUnitError(msg, var._token)
 
     def clone(self):
-        """
-        Returns a (deep) clone of this model.
-        """
+        """ Returns a (deep) clone of this model. """
         clone = Model()
 
         # Copy meta data
@@ -4520,16 +4521,10 @@ class Variable(VarOwner):
             warnings.warn('The keyword argument `state_value` is deprecated.'
                           ' Please use `initial_value` instead.')
 
-        # Handle string and number rhs's
-        model = self.model()
-        if not isinstance(initial_value, myokit.Expression):
-            if isinstance(initial_value, str):
-                # Expressions are evaluated in model context
-                initial_value = myokit.parse_expression(
-                    initial_value, context=model)
-            elif initial_value is not None:
-                initial_value = myokit.Number(initial_value)
+        # Parse initial value
+        initial_value = self._set_initial_value(initial_value, False)
 
+        model = self.model()
         try:
             # Set lhs to derivative expression
             self._lhs = myokit.Derivative(myokit.Name(self))
@@ -4854,6 +4849,9 @@ class Variable(VarOwner):
             x.set_rhs(myokit.Plus(myokit.Number(1), myokit.Name(y)))
             x.set_rhs('1 + y')
 
+        Expressions used as a variable's right-hand side must be numerical:
+        :class:`myokit.Condition` operators can not be used as RHS.
+
         Calling `set_rhs` will reset the validation status of the model this
         variable belongs to.
         """
@@ -5107,6 +5105,14 @@ class Equation:
     def __init__(self, lhs, rhs):
         self._lhs = lhs
         self._rhs = rhs
+        if not isinstance(lhs, myokit.Expression):
+            raise myokit.IntegrityError(
+                'Both sides of an equation must be myokit.Expression objects.'
+                f' Found {type(lhs)} for LHS.')
+        if not isinstance(rhs, myokit.Expression):
+            raise myokit.IntegrityError(
+                'Both sides of an equation must be myokit.Expression objects.'
+                f' Found {type(lhs)} for RHS.')
 
     def __eq__(self, other):
         if not isinstance(other, Equation):

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, 1
+__version_tuple__ = 1, 37, 0
 
 # String version of the version number
 __version__ = '.'.join([str(x) for x in __version_tuple__])

myokit/_sim/jacobian.py

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

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/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)