myokit 1.37.0__tar.gz → 1.37.1__tar.gz

{myokit-1.37.0/myokit.egg-info → myokit-1.37.1}/PKG-INFO

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

{myokit-1.37.0 → myokit-1.37.1}/myokit/_aux.py

@@ -591,6 +591,10 @@ def step(model, initial=None, reference=None, ignore_errors=False):
     # Get initial state
     if initial is None:
         initial = model.initial_values(as_floats=True)
+    else:
+        # Convert initial values etc to floats. Will also be performed by
+        # evaluate_derivatives, but done here for the printing code below.
+        initial = model.map_to_state(initial)
 
     # Get evaluation at initial state
     values = model.evaluate_derivatives(

{myokit-1.37.0 → myokit-1.37.1}/myokit/_datablock.py

@@ -562,8 +562,8 @@ class DataBlock1d:
             end += n0
             if end > nb:
                 raise myokit.DataBlockReadError(
-                    'Unable to read DataBlock1d: Header indicates larger data'
-                    ' than found in the body.')
+                    'Unable to read DataBlock1d: Header indicates more time'
+                    ' data than found in the body.')
             data = array.array(dtype)
             data.frombytes(body[start:end])
             if sys.byteorder == 'big':  # pragma: no cover
@@ -583,7 +583,7 @@ class DataBlock1d:
                 end += n0
                 if end > nb:
                     raise myokit.DataBlockReadError(
-                        'Unable to read DataBlock1d: Header indicates larger'
+                        'Unable to read DataBlock1d: Header indicates more 0d'
                         ' data than found in the body.')
                 data = array.array(dtype)
                 data.frombytes(body[start:end])
@@ -602,7 +602,7 @@ class DataBlock1d:
                 end += n1
                 if end > nb:
                     raise myokit.DataBlockReadError(
-                        'Unable to read DataBlock1d: Header indicates larger'
+                        'Unable to read DataBlock1d: Header indicates more 1d'
                         ' data than found in the body.')
                 data = array.array(dtype)
                 data.frombytes(body[start:end])
@@ -1351,8 +1351,8 @@ class DataBlock2d:
             end += n0
             if end > nb:
                 raise myokit.DataBlockReadError(
-                    'Unable to read DataBlock2d: Header indicates larger data'
-                    ' than found in the body.')
+                    'Unable to read DataBlock2d: Header indicates more time'
+                    ' data than found in the body.')
 
             data = array.array(dtype)
             data.frombytes(body[start:end])
@@ -1373,8 +1373,8 @@ class DataBlock2d:
                 end += n0
                 if end > nb:
                     raise myokit.DataBlockReadError(
-                        'Unable to read DataBlock2d: Header indicates larger'
-                        ' data than found in the body.')
+                        'Unable to read DataBlock2d: Header indicates more'
+                        ' 0d data than found in the body.')
                 data = array.array(dtype)
                 data.frombytes(body[start:end])
                 if sys.byteorder == 'big':  # pragma: no cover
@@ -1392,8 +1392,8 @@ class DataBlock2d:
                 end += n2
                 if end > nb:
                     raise myokit.DataBlockReadError(
-                        'Unable to read DataBlock2d: Header indicates larger'
-                        ' data than found in the body.')
+                        'Unable to read DataBlock2d: Header indicates more'
+                        ' 2d data than found in the body.')
                 data = array.array(dtype)
                 data.frombytes(body[start:end])
                 if sys.byteorder == 'big':  # pragma: no cover

{myokit-1.37.0 → myokit-1.37.1}/myokit/_datalog.py

@@ -666,9 +666,11 @@ class DataLog(OrderedDict):
         """
         Loads a CSV file from disk and returns it as a :class:`DataLog`.
 
-        The CSV file must start with a header line indicating the variable
-        names, separated by commas. Each subsequent row should contain the
-        values at a single point in time for all logged variables.
+        The CSV file must start with a header line indicating the column names,
+        separated by commas. Each subsequent row should contain the values at a
+        single point in time for all logged variables. Duplicate column names
+        will be given a suffix "-i", where "i" is an integer chosen to create
+        a unique name.
 
         The ``DataLog`` is created using the data type specified by the
         argument ``precision``, regardless of the data type of the stored data.
@@ -691,9 +693,18 @@ class DataLog(OrderedDict):
                 'Syntax error on line ' + str(line) + ', character '
                 + str(1 + char) + ': ' + msg)
 
+        # Detect Microsoft's annyoing utf-8-sig encoding
+        # Note: We have to perform the first read in utf-8 mode, because the
+        # default encoding on windows will turn the BOM into a different set of
+        # characters, so that f.read(1) won't actually equal \ufeff
+        encoding = None
+        with open(filename, 'r', encoding='utf-8') as f:
+            if f.read(1) == '\ufeff':
+                encoding = 'utf-8-sig'
+
         quote = '"'
         delim = ','
-        with open(filename, 'r', newline=None) as f:
+        with open(filename, 'r', newline=None, encoding=encoding) as f:
             # Read header
             keys = []   # The log keys, in order of appearance
 
@@ -784,8 +795,32 @@ class DataLog(OrderedDict):
             if c == delim:
                 e(1, i, 'Empty field in header.')
 
-            # Create data structure
+            # Handle duplicate keys by adding "-i" to all keys that appear
+            # more than once. If an entry key-i already exists, i is
+            # incremented.
             m = len(keys)
+            if len(set(keys)) != m:
+                first_seen = {}  # key: index first seen at
+                duplicates = {}  # key: list of indices of duplicates
+                for i, key in enumerate(keys):
+                    if key in first_seen:
+                        try:
+                            duplicates[key].append(i)
+                        except KeyError:
+                            duplicates[key] = [first_seen[key], i]
+                    else:
+                        first_seen[key] = i
+                for key, indices in duplicates.items():
+                    j = 1
+                    for i in indices:
+                        k = key
+                        while k in first_seen:
+                            k = f'{key}-{j}'
+                            j += 1
+                        keys[i] = k
+                        first_seen[k] = i
+
+            # Create data structure
             lists = []
             for key in keys:
                 x = array.array(typecode)

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

{myokit-1.37.0 → myokit-1.37.1}/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-1.37.1/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-1.37.1/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)