myokit 1.36.1__py3-none-any.whl → 1.37.1__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, 1
 
 # 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/axon/_abf.py

@@ -574,8 +574,8 @@ class AbfFile(myokit.formats.SweepSource):
         # Only episodic stimulation is supported.
         if self._mode != ACMODE_EPISODIC_STIMULATION:  # pragma: no cover
             warnings.warn(
-                'Unsupported acquisition method '
-                + acquisition_modes[self._mode] + '; unable to read D/A'
+                'Unsupported acquisition method'
+                f' {acquisition_modes[self._mode]}; unable to read D/A'
                 ' channels.')
 
             # Remaining code is all about reading D/A info for episodic
@@ -713,7 +713,7 @@ class AbfFile(myokit.formats.SweepSource):
                         elif t != EPOCH_DISABLED:  # pragma: no cover
                             use = False
                             warnings.warn(
-                                f'Unsupported epoch type: {epoch_types(t)}')
+                                f'Unsupported epoch type: {epoch_types[t]}')
                             break
                 elif source == DAC_DACFILEWAVEFORM:  # pragma: no cover
                     # Stimulus file? Then don't use
@@ -1375,7 +1375,14 @@ class AbfFile(myokit.formats.SweepSource):
         try:
             return self._unit_cache[unit_string]
         except KeyError:
-            unit = myokit.parse_unit(unit_string.replace(MU, 'u'))
+            try:
+                unit = myokit.parse_unit(unit_string.replace(MU, 'u'))
+            except myokit.ParseError:  # pragma: no cover
+                if unit_string == 'oC':
+                    warnings.warn('Unsupported units degrees C.')
+                else:
+                    warnings.warn(f'Unsupported units {unit_string}.')
+                unit = myokit.units.dimensionless
             self._unit_cache[unit_string] = unit
             return unit
 

myokit/formats/diffsl/__init__.py

@@ -0,0 +1,60 @@
+#
+# Provides DiffSL support
+#
+# This file is part of Myokit.
+# See http://myokit.org for copyright, sharing, and licensing details.
+#
+from ._ewriter import DiffSLExpressionWriter
+from ._exporter import DiffSLExporter
+
+# Importers
+
+# Exporters
+_exporters = {
+    'diffsl': DiffSLExporter,
+}
+
+
+def exporters():
+    """
+    Returns a dict of all exporters available in this module.
+    """
+    return dict(_exporters)
+
+
+# Expression writers
+_ewriters = {
+    'diffsl': DiffSLExpressionWriter,
+}
+
+
+def ewriters():
+    """
+    Returns a dict of all expression writers available in this module.
+    """
+    return dict(_ewriters)
+
+
+#
+# Language keywords
+#
+keywords = [
+    'abs',
+    'cos',
+    'dudt',
+    'exp',
+    'F',
+    'G',
+    'heaviside',
+    'in',
+    'log',
+    'M',
+    'out',
+    'pow',
+    'sigmoid',
+    'sin',
+    'sqrt',
+    't',
+    'tan',
+    'u',
+]

myokit/formats/diffsl/_ewriter.py

@@ -0,0 +1,145 @@
+#
+# DiffSL expression writer
+#
+# Supported functions:
+#  https://martinjrobins.github.io/diffsl/functions.html
+#
+# This file is part of Myokit.
+# See http://myokit.org for copyright, sharing, and licensing details.
+#
+import warnings
+
+from myokit import And, Equal, If, LessEqual, Log, MoreEqual, Not, Number
+from myokit.formats.ansic import CBasedExpressionWriter
+
+
+class DiffSLExpressionWriter(CBasedExpressionWriter):
+    """
+    This :class:`ExpressionWriter <myokit.formats.ExpressionWriter>` writes
+    equations for variables in DiffSL syntax.
+
+    For details of the language, see https://martinjrobins.github.io/diffsl/.
+
+    Warnings will be generated if unsupported functions are used in the model.
+    Unsupported functions: `acos`, `asin`, `atan`, `ceil`, `floor`.
+
+    Support for logic expressions is implemented with heaviside functions.
+    For example, `(a >= b)` is converted to `heaviside(a - b)`.
+
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    # -- Literals and identifiers
+
+    # def _ex_name(self, e):
+    # def _ex_number(self, e):
+
+    # -- Functions
+
+    def _ex_abs(self, e):
+        return self._ex_function(e, 'abs')
+
+    def _ex_acos(self, e):
+        warnings.warn('Unsupported function: acos()')
+        return super()._ex_acos(e)
+
+    def _ex_asin(self, e):
+        warnings.warn('Unsupported function: asin()')
+        return super()._ex_asin(e)
+
+    def _ex_atan(self, e):
+        warnings.warn('Unsupported function: atan()')
+        return super()._ex_atan(e)
+
+    def _ex_ceil(self, e):
+        warnings.warn('Unsupported function: ceil()')
+        return super()._ex_ceil(e)
+
+    # def _ex_cos(self, e):
+    # def _ex_derivative(self, e):
+    # def _ex_divide(self, e):
+    # def _ex_exp(self, e):
+
+    def _ex_floor(self, e):
+        warnings.warn('Unsupported function: floor()')
+        return super()._ex_floor(e)
+
+    # def _ex_log(self, e):
+
+    def _ex_log10(self, e):
+        # Log10(a) = Log(a, 10.0) -> '(log(a) / log(10.0))'
+        return super()._ex_log(Log(e[0], Number(10)))
+
+    # def _ex_minus(self, e):
+    # def _ex_multiply(self, e):
+    # def _ex_plus(self, e):
+    # def _ex_power(self, e):
+    # def _ex_prefix_minus(self, e):
+    # def _ex_prefix_plus(self, e):
+    # def _ex_quotient(self, e):
+    # def _ex_remainder(self, e):
+    # def _ex_sin(self, e):
+    # def _ex_sqrt(self, e):
+    # def _ex_tan(self, e):
+
+    # -- Conditional operators
+
+    def _ex_and(self, e):
+        # (a and b) == a * b, where a, b are in {0, 1}
+        return f'{self.ex(e[0])} * {self.ex(e[1])}'
+
+    def _ex_equal(self, e):
+        # (a == b) == heaviside(a - b) * heaviside(b - a)
+        return self.ex(And(MoreEqual(e[0], e[1]), LessEqual(e[0], e[1])))
+
+    def _ex_less(self, e):
+        # (a < b) == 1 - heaviside(a - b)
+        return self.ex(Not(MoreEqual(e[0], e[1])))
+
+    def _ex_less_equal(self, e):
+        # (a <= b) == heaviside(b - a)
+        return f'heaviside({self.ex(e[1])} - {self.ex(e[0])})'
+
+    def _ex_more(self, e):
+        # (a > b) == 1 - heaviside(b - a)
+        return self.ex(Not(LessEqual(e[0], e[1])))
+
+    def _ex_more_equal(self, e):
+        # (a >= b) == heaviside(a - b)
+        return f'heaviside({self.ex(e[0])} - {self.ex(e[1])})'
+
+    def _ex_not(self, e):
+        # not(a) == (1 - a), where a is in {0, 1}
+        return f'(1 - {self.ex(e[0])})'
+
+    def _ex_not_equal(self, e):
+        # (a != b) == 1 - heaviside(a - b) * heaviside(b - a)
+        return self.ex(Not(Equal(e[0], e[1])))
+
+    def _ex_or(self, e):
+        # a or b == not(not(a) and not(b)), where a, b are in {0, 1}
+        return self.ex(Not(And(Not(e[0]), Not(e[1]))))
+
+    # -- Conditional expressions
+
+    def _ex_if(self, e):
+        _if = self.ex(e._i)
+        _then = self.ex(e._t)
+        _not_if = self.ex(Not(e._i))
+        _else = self.ex(e._e)
+
+        return f'({_if} * {_then} + {_not_if} * {_else})'
+
+    def _ex_piecewise(self, e):
+        # Convert piecewise to nested ifs
+        # e.g. piecewise(a, b, c, d, e) -> if(a, b, if(c, d, e))
+        n = len(e._i)
+
+        _nested_ifs = e._e[n]
+
+        for i in range(n - 1, -1, -1):
+            _nested_ifs = If(e._i[i], e._e[i], _nested_ifs)
+
+        return self._ex_if(_nested_ifs)