myokit 1.37.0__tar.gz → 1.37.2__tar.gz

{myokit-1.37.0 → myokit-1.37.2}/LICENSE.txt

@@ -3,7 +3,7 @@ BSD 3-Clause License
 Copyright (c) 2011-2017 Maastricht University. All rights reserved.
 Copyright (c) 2017-2020 University of Oxford. All rights reserved.
 (University of Oxford means the Chancellor, Masters and Scholars of the University of Oxford, having an administrative office at Wellington Square, Oxford OX1 2JD, UK).
-Copyright (c) 2020-2024 University of Nottingham. All rights reserved.
+Copyright (c) 2020-2025 University of Nottingham. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: myokit
-Version: 1.37.0
+Version: 1.37.2
 Summary: A modeling and simulation tool for cardiac cellular electrophysiology
 Home-page: http://myokit.org
 Author: Michael Clerx
@@ -22,13 +22,28 @@ Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: configparser
+Requires-Dist: lxml
+Requires-Dist: matplotlib>=2.2
+Requires-Dist: numpy
+Requires-Dist: setuptools
 Provides-Extra: docs
+Requires-Dist: sphinx>=1.7.4; extra == "docs"
 Provides-Extra: dev
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: flake8>=3; extra == "dev"
 Provides-Extra: optional
+Requires-Dist: scipy; extra == "optional"
+Requires-Dist: sympy; extra == "optional"
 Provides-Extra: gui
+Requires-Dist: pyqt6; extra == "gui"
+Requires-Dist: sip; extra == "gui"
 Provides-Extra: pyqt
+Requires-Dist: pyqt6; extra == "pyqt"
+Requires-Dist: sip; extra == "pyqt"
 Provides-Extra: pyside
-License-File: LICENSE.txt
+Requires-Dist: pyside6; extra == "pyside"
 
 [![Ubuntu unit tests](https://github.com/myokit/myokit/actions/workflows/unit-tests-ubuntu.yml/badge.svg)](https://github.com/myokit/myokit/actions/workflows/unit-tests-ubuntu.yml)
 [![MacOS unit tests](https://github.com/myokit/myokit/actions/workflows/unit-tests-macos.yml/badge.svg)](https://github.com/myokit/myokit/actions/workflows/unit-tests-macos.yml)

{myokit-1.37.0 → myokit-1.37.2}/myokit/__init__.py

@@ -79,7 +79,7 @@ Copyright (c) 2017-2020 University of Oxford. All rights reserved.
  (University of Oxford means the Chancellor, Masters and Scholars of the
   University of Oxford, having an administrative office at Wellington Square,
   Oxford OX1 2JD, UK).
-Copyright (c) 2020-2024 University of Nottingham. All rights reserved.
+Copyright (c) 2020-2025 University of Nottingham. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
@@ -118,7 +118,7 @@ LICENSE_HTML = """
     <br />(University of Oxford means the Chancellor, Masters and Scholars of
     the University of Oxford, having an administrative office at Wellington
     Square, Oxford OX1 2JD, UK).
-    <br />Copyright (c) 2020-2024 University of Nottingham. All rights
+    <br />Copyright (c) 2020-2025 University of Nottingham. All rights
     reserved.</br></p>
 <p>
     Redistribution and use in source and binary forms, with or without

{myokit-1.37.0 → myokit-1.37.2}/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.2}/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.2}/myokit/_datalog.py

@@ -329,23 +329,27 @@ class DataLog(OrderedDict):
         """
         Creates a copy of the log, split with the given ``period``.
 
-        Split signals are given indexes so that "current" becomes "0.current",
-        "1.current", "2.current", etc.
+        Split signals are given indexes so that ``current`` becomes
+        ``0.current``, ``1.current``, ``2.current``, etc.
 
         If the logs entries do not divide well by ``period``, the remainder
         will be ignored. This happens commonly due to rounding point errors (in
         which case the remainder is a single entry). To disable this behavior,
         set ``discard_remainder=False``.
+
+        To split a log into a list of logs, use :meth:`DataLog.split_periodic`.
         """
         # Note: Using closed intervals can lead to logs of unequal length, so
         # it should be disabled here to ensure a valid log
         logs = self.split_periodic(period, adjust=True, closed_intervals=False)
+
         # Discard remainder if present
         if discard_remainder:
             if len(logs) > 1:
                 n = logs[0].length()
                 if logs[-1].length() < n:
                     logs = logs[:-1]
+
         # Create new log with folded data
         out = myokit.DataLog()
         out._time = self._time
@@ -666,9 +670,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 +697,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 +799,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)
@@ -1270,10 +1309,12 @@ class DataLog(OrderedDict):
 
     def split_periodic(self, period, adjust=False, closed_intervals=True):
         """
-        Splits this log into multiple logs, each covering an equal period of
-        time. For example a log covering the time span ``[0, 10000]`` can be
-        split with period ``1000`` to obtain ten logs covering ``[0, 1000]``,
-        ``[1000, 2000]`` etc.
+        Splits this log into multiple logs, returning a list of
+        :class:`DataLog` objects.
+
+        Each returned log covers an equal ``period`` of time. For example a log
+        covering the time span ``[0, 10000]`` split with period ``1000`` will
+        result in a list of ten logs ``[0, 1000]``, ``[1000, 2000]`` etc.
 
         The split log files can be returned as-is, or with the time variable's
         value adjusted so that all logs appear to cover the same span. To
@@ -1284,6 +1325,9 @@ class DataLog(OrderedDict):
         the duplication of some data points. To disable this behavior and
         return half-closed endpoints (containing only the left point), set
         ``closed_intervals`` to ``False``.
+
+        To return a single log with entries ``x`` split as ``x.0``, ``x.1``,
+        etc., use :meth:`DataLog.fold`.
         """
         # Validate log before starting
         self.validate()

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

{myokit-1.37.0 → myokit-1.37.2}/myokit/_sim/cvodessim.py

@@ -695,9 +695,9 @@ class Simulation(myokit.CModule):
             An optional fixed size log interval. Must be ``None`` if
             ``log_times`` is used. If both are ``None`` every step is logged.
         ``log_times``
-            An optional set of pre-determined logging times. Must be ``None``
-            if ``log_interval`` is used. If both are ``None`` every step is
-            logged.
+            An optional sequence (e.g. a list or a numpy array) of
+            pre-determined logging times. Must be ``None`` if ``log_interval``
+            is used. If both are ``None`` every step is logged.
         ``sensitivities``
             An optional list-of-lists to append the calculated sensitivities
             to.

{myokit-1.37.0 → myokit-1.37.2}/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.2/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.2/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)