myokit 1.37.4__tar.gz → 1.38.0__tar.gz

{myokit-1.37.4/myokit.egg-info → myokit-1.38.0}/PKG-INFO

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

{myokit-1.37.4 → myokit-1.38.0}/myokit/_datablock.py

@@ -2169,8 +2169,7 @@ class ColorMapViridis(ColorMap):
     https://github.com/BIDS/colormap/blob/master/colormaps.py
     and were distributed under a CC0 license.
 
-    Viridis was designed by Eric Firing, Nathaniel J. Smith, and Stefan van der
-    Walt.
+    Viridis was designed by Nathaniel J. Smith and Stefan van der Walt.
     """
     _VALUES = np.array((
         (68, 1, 84),
@@ -2456,14 +2455,13 @@ class ColorMapViridis(ColorMap):
 
 class ColorMapInferno(ColorMap):
     """
-    A colormap using "Viridis".
+    A colormap using "Inferno".
 
-    The values used by this color map are taken from
+    The values used by this color map are adapted from
     https://github.com/BIDS/colormap/blob/master/colormaps.py
     and were distributed under a CC0 license.
 
-    Viridis was designed by Eric Firing, Nathaniel J. Smith, and Stefan van der
-    Walt.
+    Inferno was designed by Nathaniel J. Smith and Stefan van der Walt.
     """
     _VALUES = np.array((
         (0, 0, 4),

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

{myokit-1.37.4 → myokit-1.38.0}/myokit/_parsing.py

@@ -949,6 +949,10 @@ def parse_protocol_from_stream(stream):
                 'Expecting [[protocol]]')
         expect(next(stream), EOL)
 
+    # Handling "next" accuracy: after summing, times set using "next" will be
+    # rounded to 9 digits precision.
+    round_next = lambda x: round(x, 9)
+
     # Create protocol
     protocol = myokit.Protocol()
 
@@ -971,7 +975,7 @@ def parse_protocol_from_stream(stream):
                     'Unable to determine end of previous event, "next" cannot'
                     ' be used here.')
             else:
-                t = t_next
+                t = round_next(t_next)
         else:
             t = parse_number(stream)
         if t_last is None:

{myokit-1.37.4 → myokit-1.38.0}/myokit/_sim/cable.c

@@ -272,7 +272,7 @@ sim_clean()
     return 0;
 }
 static PyObject*
-py_sim_clean()
+py_sim_clean(PyObject *self, PyObject *args)
 {
     sim_clean();
     Py_RETURN_NONE;

{myokit-1.37.4 → myokit-1.38.0}/myokit/_sim/fiber_tissue.c

@@ -291,7 +291,7 @@ sim_clean()
     return 0;
 }
 static PyObject*
-py_sim_clean()
+py_sim_clean(PyObject *self, PyObject *args)
 {
     #ifdef MYOKIT_DEBUG_MESSAGES
     printf("Python py_sim_clean called.\n");

{myokit-1.37.4 → myokit-1.38.0}/myokit/_unit.py

@@ -186,7 +186,7 @@ class Unit:
         ``unit2``.
 
         Exponents are stored internally as floating point numbers, and the
-        check for closeness if made with a relative tolerance of ``reltol`` and
+        check for closeness is made with a relative tolerance of ``reltol`` and
         absolute tolerance of ``abstol``, using::
 
             abs(a - b) < max(reltol * max(abs(a), abs(b)), abstol)

{myokit-1.37.4 → myokit-1.38.0}/myokit/formats/axon/_abf.py

@@ -254,7 +254,6 @@ class AbfFile(myokit.formats.SweepSource):
         # Read the protocol information
         self._n_adc = None
         self._n_dac = None
-
         self._rate = None
         self._mode = None
 
@@ -264,6 +263,7 @@ class AbfFile(myokit.formats.SweepSource):
         self._run_start_to_start = None
         self._sweeps_per_run = None
         self._sweep_start_to_start = None
+        self._equal_length_sweeps = None
         self._samples_per_channel = None
 
         # To be able to treat v1 and v2 slightly more easily, we define 3
@@ -281,7 +281,6 @@ class AbfFile(myokit.formats.SweepSource):
         # will have A/D but no (or no supported) D/A. Conversely protocol files
         # will have D/A only. So all in one sweep is easiest.
         self._sweeps = None
-
         self._read_3_protocol_information()
 
         # Read and calculate conversion factors for integer data in ADC
@@ -553,7 +552,10 @@ class AbfFile(myokit.formats.SweepSource):
             # 1.x versions only seem to have 1 DAC channel, but this is not
             # supported here.
             self._n_adc = int(h['nADCNumChannels'])
-            self._n_dac = min(len(h['sDACChannelName']), 2)
+            if h['sDACChannelName'] is None:    # pragma: no cover
+                self._n_dac = 2
+            else:
+                self._n_dac = min(len(h['sDACChannelName']), 2)
             self._rate = 1e6 / (h['fADCSampleInterval'] * self._n_adc)
             self._mode = h['nOperationMode']
         else:
@@ -577,11 +579,7 @@ class AbfFile(myokit.formats.SweepSource):
                 '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
-            # stimulation, so return
             self._n_dac = 0
-            return
 
         # Gather protocol information
         if self._version < 2:
@@ -668,9 +666,16 @@ class AbfFile(myokit.formats.SweepSource):
             self._sweep_start_to_start = self._samples_per_channel / self._rate
 
         # Create empty sweeps
-        n = h['lActualSweeps']
-        if self._is_protocol_file:
+        if self._mode == ACMODE_GAP_FREE:   # pragma: no cover
+            # In gap-free mode, treat the data as a single sweep
+            n = 1
+        elif self._is_protocol_file:
+            # In protocol file, there is no number of recorded sweeps, so use
+            # intended number of sweeps instead
             n = self._sweeps_per_run
+        else:
+            # Use number of recorded sweeps
+            n = h['lActualSweeps']
         self._sweeps = [Sweep() for i in range(n)]
 
         # User lists are not supported for D/A reconstruction
@@ -811,7 +816,8 @@ class AbfFile(myokit.formats.SweepSource):
         # Get binary integer format
         dt = np.dtype('i2') if h['nDataFormat'] == 0 else np.dtype('f4')
 
-        # Get number of channels, create a numpy memory map
+        # Get number of channels, create a numpy memory map of all data
+        # The map has size n and starts at offset o
         if self._version < 2:
             # Old files, get info from fields stored directly in header
             o = h['lDataSectionPtr'] * BLOCKSIZE \
@@ -823,37 +829,57 @@ class AbfFile(myokit.formats.SweepSource):
             n = h['sections']['Data']['length']
         data = np.memmap(self._filepath, dt, 'r', shape=(n,), offset=o)
 
-        # Load list of sweeps (Sweeps are called 'episodes' in ABF < 2)
+        # Load information about sweep sizes from "SynchArray".
+        # The number of sweep information structs will be n, and information
+        # starts at an offset o
         if self._version < 2:
             n = h['lSynchArraySize']
             o = h['lSynchArrayPtr'] * BLOCKSIZE
         else:
             n = h['sections']['SynchArray']['length']
             o = h['sections']['SynchArray']['index'] * BLOCKSIZE
-        if n > 0:
-            dt = [(str('offset'), str('i4')), (str('len'), str('i4'))]
-            sweep_data = np.memmap(
-                self._filepath, dt, 'r', shape=(n,), offset=o)
-        else:   # pragma: no cover
-            # Cover pragma: Don't have appropriate test file
-            sweep_data = np.empty((1), dt)
-            sweep_data[0]['len'] = data.size
-            sweep_data[0]['offset'] = 0
 
-        # Number of sweeps must equal n
-        if n != h['lActualSweeps']:
-            raise NotImplementedError(
-                'Unable to read file with different sizes per sweep.')
-
-        # Time-offset at start of first sweep
-        start = sweep_data[0]['offset'] / rate
+        # Get sweep start times (real times, not array offsets) and sizes
+        # (as number of points in an array)
+        if self._mode != ACMODE_GAP_FREE:
+            # This will be read in as an array of numpy.Void objects, which are
+            # similar to structs. In ``dt`` we name the entries offset and len.
+            sweep_starts_sizes = np.memmap(
+                self._filepath, [('offset', 'i4'), ('len', 'i4')], 'r',
+                shape=(n,), offset=o)
+        else:   # pragma: no cover
+            # In gap-free model, all data is a single sweep
+            sweep_starts_sizes = [(0, len(data))]
+
+        # Sanity check
+        if len(sweep_starts_sizes) != len(self._sweeps):  # pragma: no cover
+            raise RuntimeError(
+                'Unexpected situation: number of sweeps is'
+                f' {len(self._sweeps)} but found list of'
+                f' {len(sweep_starts_sizes)} sweep sizes.')
+
+        # Check if sweep sizes are all the same
+        self._equal_length_sweeps = True
+        if len(sweep_starts_sizes) > 0:
+            size = sweep_starts_sizes[0][1]
+            for o, s in sweep_starts_sizes[1:]:
+                if s != size:   # pragma: no cover
+                    self._equal_length_sweeps = False
+                    break
+            del size
+
+        # Episodic stimulation? Then increment start time using sweep interval
+        # First time is time listed in first sweep
+        if self._mode == ACMODE_EPISODIC_STIMULATION:
+            tstart = sweep_starts_sizes[0][0] / rate
 
         # Get data
         pos = 0
-        for i_sweep, sdat in enumerate(sweep_data):
+        for i_sweep, (start, size) in enumerate(sweep_starts_sizes):
 
-            # Get the number of data points
-            size = sdat['len']
+            # Not episodic: Then use listed start time
+            if self._mode != ACMODE_EPISODIC_STIMULATION:   # pragma: no cover
+                tstart = start / rate
 
             # Calculate the correct size for variable-length event mode
             if self._mode == ACMODE_VARIABLE_LENGTH_EVENTS:  # pragma: no cover
@@ -874,25 +900,20 @@ class AbfFile(myokit.formats.SweepSource):
             # If needed, reformat the integers
             if h['nDataFormat'] == 0:
                 # Data given as integers? Convert to floating point
-
                 for i in range(self._n_adc):
                     part[:, i] *= self._adc_factors[i]
                     part[:, i] += self._adc_offsets[i]
 
-            # Get start in other modes
-            if self._mode != ACMODE_EPISODIC_STIMULATION:  # pragma: no cover
-                # All modes except episodic stimulation
-                start = data['offset'] / rate
-
-            # Create and populate sweep
+            # Create and populate sweep object
             sweep = self._sweeps[i_sweep]
             for i in range(self._n_adc):
                 c = Channel(self)
                 c._data = part[:, i]    # Actually store the data
                 c._rate = rate
-                c._start = start
+                c._start = tstart
                 c._is_reconstruction = False
 
+                # Add meta data
                 if self._version < 2:
                     j = h['nADCSamplingSeq'][i]
 
@@ -947,9 +968,9 @@ class AbfFile(myokit.formats.SweepSource):
 
                 sweep._channels.append(c)
 
+            # In episodic mode, increase time according to sweep interval
             if self._mode == ACMODE_EPISODIC_STIMULATION:
-                # Increase time according to sweeps in episodic stim. mode
-                start += self._sweep_start_to_start
+                tstart += self._sweep_start_to_start
 
     def _read_6_da_reconstructions(self):
         """
@@ -1034,6 +1055,12 @@ class AbfFile(myokit.formats.SweepSource):
 
         return int_id
 
+    def acquisition_mode_str(self):
+        """
+        Returns the acquisition mode, as a string.
+        """
+        return acquisition_modes[self._mode]
+
     def channel(self, channel_id, join_sweeps=False):
         # Docstring in SweepSource
         channel_id = self._channel_id(channel_id)
@@ -1193,8 +1220,7 @@ class AbfFile(myokit.formats.SweepSource):
         return self._da_units[index]
 
     def equal_length_sweeps(self):
-        # Always true for ABF
-        return True
+        return self._equal_length_sweeps
 
     def filename(self):
         """ Returns this ABF file's filename. """
@@ -1530,13 +1556,13 @@ HEADER_FIELDS = {
     # Note that a lot of the groups in the version 1 header start with obsolete
     # fields, followed later by their newer equivalents.
     1: [
-        ('fFileSignature', 0, '4s'),       # Coarse file version indication
+        ('fFileSignature', 0, '4s'),        # Coarse file version indication
         # Group 1, File info and sizes
-        ('fFileVersionNumber', 4, 'f'),    # Version number as float
-        ('nOperationMode', 8, 'h'),        # Acquisition mode
+        ('fFileVersionNumber', 4, 'f'),     # Version number as float
+        ('nOperationMode', 8, 'h'),         # Acquisition mode
         ('lActualAcqLength', 10, 'i'),
         ('nNumPointsIgnored', 14, 'h'),
-        ('lActualSweeps', 16, 'i'),
+        ('lActualSweeps', 16, 'i'),         # AKA lActualEpisodes
         ('lFileStartDate', 20, 'i'),
         ('lFileStartTime', 24, 'i'),
         ('lStopWatchTime', 28, 'i'),

{myokit-1.37.4 → myokit-1.38.0}/myokit/formats/heka/_patchmaster.py

@@ -23,8 +23,9 @@
 #    numbers of steps are given; the manual mentions two types of log
 #    interpretation but there is no obvious field to select one; a "toggle"
 #    mode is mentioned in the manual but again is not easy to find in the file.
-#  - Series resistance prediction percentage is not stored in the Patchmaster
-#    file.
+#  - Series resistance prediction percentage is not stored separately in the
+#    Patchmaster file. In addition, the value stored seems to be either
+#    percentage compensation or prediction, without much consistency.
 #
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
@@ -78,7 +79,8 @@ class PatchMasterFile:
     represent a single cell, and each "series" will be a protocol (called a
     "stimulus") run on that cell. Groups are named by the user. Series are
     named after the "stimulus" they run. Sweeps are usually unnamed (although
-    they do have a ``label`` property), and channels are named by the user.
+    they do have a ``label`` property), and traces (channels) are named by the
+    user.
 
     To access groups, index them by integer, or use the :meth:`group` method to
     find the first group with a given label::
@@ -294,8 +296,6 @@ class EndianAwareReader:
 
     def read(self, form):
         """ Read and unpack using the struct format ``form``. """
-        #if offset is not None:
-        #    f.seek(offset)
         return struct.unpack(
             self._e + form, self._f.read(struct.calcsize(form)))
 
@@ -1209,7 +1209,6 @@ class Sweep(TreeNode):
         # Seconds since first sweep, based on self._time, set by parent series
         self._time_since_first = None
 
-        #self._data_offset = None
         self._stimulus_id = None
 
     def _read_properties(self, handle, reader):
@@ -1217,7 +1216,6 @@ class Sweep(TreeNode):
         i = handle.tell()
         handle.seek(i + 4)  # SwLabel = 4; (* String32Type *)
         self._label = reader.str(32)
-        #self._data_offset = reader.read1('i')
         handle.seek(i + 40)     # SwStimCount = 40; (* INT32 *)
         self._stimulus_id = reader.read1('i') - 1
         handle.seek(i + 48)     # SwTime = 48; (* LONGREAL *)
@@ -1364,6 +1362,7 @@ class Trace(TreeNode):
         handle.seek(i + 40)     # TrData
         self._data_pos = reader.read1('i')
         self._n = reader.read1('i')
+        handle.seek(i + 70)     # TrDataFormat
         dtype = int(reader.read1('b'))
         self._data_type = _data_types[dtype]
         self._data_size = _data_sizes[dtype]
@@ -1649,15 +1648,18 @@ class AmplifierState:
     Describes the state of an amplifier used by PatchMaster.
 
     This "state" contains lots of valuable meta data about the fast and slow
-    capacitance correction, the series resistance compensation (but not
-    prediction! see below), the filtering, the gain, and voltage offset
+    capacitance correction, the series resistance compensation (and/or
+    prediction, but see below!), the filtering, the gain, and voltage offset
     corrections (zeroing and online LJP).
 
-    A notable omission is information about the series compensation
-    _prediction_ feature. This should have an on/off statement, and a
-    percentage (which can be set separately from the _correction_ percentage in
-    Patchmaster). Unfortunately this is not stored in the format yet (20 feb
-    2025).
+    A notable issue is information omission is information about the series
+    compensation _prediction_ feature. By default, the level of prediction is
+    the same as the level of correction. A checkbox in the software (which the
+    manual erroneously described as an on/off switch) can be used to set both
+    values independently. If this is done, it becomes unclear what the value in
+    the file represents, as only one value is stored. For this reason, if
+    prediction is set seperately from correction, both values must be noted
+    down by the experimenter and the value from the file should be ignored.
     """
     def __init__(self, handle, reader):
 
@@ -1686,10 +1688,6 @@ class AmplifierState:
         handle.seek(i + 304)  # sRsTau = 304; (* LONGREAL *)
         self._rs_tau = reader.read1('d')
 
-        # Prediction is not recorded!
-        self._rs_prediction = PredictionSetting.UNKNOWN if self._rs_enabled \
-            else PredictionSetting.OFF
-
         # Fast capacitance correction
         handle.seek(i + 56)    # sCFastAmp1 = 56; (* LONGREAL *)
         self._cf_amp1 = reader.read1('d')
@@ -1921,19 +1919,6 @@ class AmplifierState:
         """
         return self._rs_tau * 1e6 if self._rs_enabled else 0
 
-    def r_series_prediction(self):
-        """
-        The percentage "prediction" is not recorded in the file: this method
-        returns ``PredictionSetting.OFF`` if compensation (and therefore
-        prediction) was disabled, and ``UNKNOWN`` if compensation was enabled
-        (so prediction may have been active).
-
-        This serves as a placeholder in case future changes to the format
-        incorporate it, and as a place to document that this feature is missing
-        by design.
-        """
-        return self._rs_prediction
-
     def stimulus_filter(self):
         """
         Returns a :class:`StimulusFilterSetting` descibing the stimulus filter
@@ -2076,24 +2061,6 @@ class StimulusFilterSetting(enum.Enum):
             return 'Bessel 20 us (on)'
 
 
-class PredictionSetting(enum.Enum):
-    """
-    Very limited information about the series resistance compensation
-    prediction.
-
-    Series resistance compensation includes a "prediction" pathway,
-    configurable via a percentage prediction in Patchmaster. Unfortunately this
-    is not stored in the file format, so that knowledge of this parameters is
-    limited to "off" (when series resistance compensation is disabled) or
-    "unknown" (when series resistance compensation is enabled).
-    """
-    OFF = 0
-    UNKNOWN = 1
-
-    def __str__(self):
-        return 'Off' if self is PredictionSetting.OFF else 'Unknown'
-
-
 #
 # From StimFile_v9.txt
 # (* RootRecord        = RECORD *)

{myokit-1.37.4 → myokit-1.38.0}/myokit/tests/test_formats_axon.py

@@ -208,6 +208,8 @@ class AbfTest(unittest.TestCase):
         self.assertIn('version 1.65', abf.meta_str())
         self.maxDiff = None
         self.assertEqual(abf.meta_str(), V1_INFO)
+        self.assertEqual(abf.acquisition_mode_str(),
+                         'Episodic stimulation mode')
 
         # Test getting full header runs without crashing
         abf.meta_str(True)
@@ -445,6 +447,8 @@ class AbfTest(unittest.TestCase):
         self.assertIn('version 2.0', abf.meta_str())
         self.maxDiff = None
         self.assertEqual(abf.meta_str(), V2_INFO)
+        self.assertEqual(abf.acquisition_mode_str(),
+                         'Episodic stimulation mode')
 
         # Test getting full header runs without crashing
         abf.meta_str(True)

{myokit-1.37.4 → myokit-1.38.0/myokit.egg-info}/PKG-INFO

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