myokit 1.38.0__py3-none-any.whl → 1.39.0__py3-none-any.whl

myokit/formats/cellml/v2/_parser.py

@@ -53,7 +53,7 @@ class CellMLParsingError(myokit.ImportError):
         if element is not None:
             try:    # pragma: no cover
                 line = str(element.sourceline)
-                message = 'Error on line ' + line + '. ' + message
+                message = f'Error on line {line}. {message}'
             except AttributeError:
                 pass
         super().__init__(message)
@@ -89,8 +89,7 @@ class CellMLParser:
         if element.text is not None:
             if element.text.strip():
                 raise CellMLParsingError(
-                    'Text found in ' + self._tag(element, name) + '.',
-                    element)
+                    f'Text found in {self._tag(element, name)}.', element)
 
         # Check child elements
         allowed = set([self._join(x) for x in children])
@@ -102,17 +101,16 @@ class CellMLParser:
             # Check for trailing text
             if child.tail is not None and child.tail.strip():
                 raise CellMLParsingError(
-                    'Text found in ' + self._tag(element, name)
-                    + ', after ' + self._tag(child) + ' element.',
-                    child)
+                    f'Text found in {self._tag(element, name)}, after'
+                    f' {self._tag(child)} element.', child)
 
             # Check if allowed
             if str(child.tag) in allowed:
                 continue
 
             raise CellMLParsingError(
-                'Unexpected content type in ' + self._tag(element, name)
-                + ', found element of type ' + self._tag(child) + '.', child)
+                f'Unexpected content type in {self._tag(element, name)}, found'
+                f' element of type {self._tag(child)}.', child)
 
         # Check attributes
         allowed = set(attributes)
@@ -128,8 +126,8 @@ class CellMLParser:
                 ns, at = split(key)
                 key = self._item(ns, at)
                 raise CellMLParsingError(
-                    'Unexpected attribute ' + key + ' found in '
-                    + self._tag(element, name) + '.', element)
+                    f'Unexpected attribute {key} found in'
+                    f' {self._tag(element, name)}.', element)
 
     def _check_id(self, element, obj=None):
         """
@@ -148,7 +146,7 @@ class CellMLParser:
 
         # Check uniqueness
         if xid in self._ids:
-            raise CellMLParsingError('Duplicate id "' + xid + '".', element)
+            raise CellMLParsingError(f'Duplicate id "{xid}".', element)
 
         # Store and return
         self._ids[xid] = obj
@@ -165,11 +163,11 @@ class CellMLParser:
         if ns is None:
             return item
         elif ns == self._ns:
-            return 'cellml:' + item
+            return f'cellml:{item}'
         elif ns == cellml.NS_MATHML:
-            return 'mathml:' + item
+            return f'mathml:{item}'
         else:
-            return '{' + ns + '}' + item
+            return f'{{{ns}}}{item}'
 
     def _join(self, element, namespace=None):
         """
@@ -177,7 +175,7 @@ class CellMLParser:
         """
         if namespace is None:
             namespace = self._ns
-        return '{' + namespace + '}' + element
+        return f'{{{namespace}}}{element}'
 
     def parse(self, root):
         """
@@ -207,7 +205,7 @@ class CellMLParser:
             parser = etree.XMLParser(remove_comments=True)
             tree = etree.parse(path, parser=parser)
         except Exception as e:
-            raise CellMLParsingError('Unable to parse XML: ' + str(e))
+            raise CellMLParsingError(f'Unable to parse XML: {e}')
 
         # Parse content
         return self.parse(tree.getroot())
@@ -222,7 +220,7 @@ class CellMLParser:
         try:
             root = etree.fromstring(text)
         except Exception as e:
-            raise CellMLParsingError('Unable to parse XML: ' + str(e))
+            raise CellMLParsingError(f'Unable to parse XML: {e}')
 
         # Parse content
         return self.parse(root)
@@ -236,8 +234,7 @@ class CellMLParser:
             name = element.attrib['name']
         except KeyError:
             raise CellMLParsingError(
-                'Component element must have a name attribute.',
-                element)
+                'Component element must have a name attribute.', element)
 
         # Create component (validates name and checks uniqueness)
         try:
@@ -259,8 +256,18 @@ class CellMLParser:
             element, ['variable'], ['name'], name, math=True)
 
         # Create variables and set interfaces
+        initial_values = []
         for child in element.findall(self._join('variable')):
-            self._parse_variable(child, component)
+            init = self._parse_variable(child, component)
+            if init is not None:
+                initial_values.append(init)
+
+        # Set initial values
+        for child, variable, value in initial_values:
+            try:
+                variable.set_initial_value(value)
+            except myokit.formats.cellml.v2.CellMLError as e:
+                raise CellMLParsingError(str(e), child)
 
     def _parse_connection(self, element, model, connected):
         """
@@ -288,8 +295,7 @@ class CellMLParser:
         if c1 == c2:
             raise CellMLParsingError(
                 'The component_1 and component_2 attributes in a connection'
-                ' element must be different, got "' + str(c1)
-                + '" twice.', element)
+                f' element must be different, got "{c1}" twice.', element)
 
         # Get components
         try:
@@ -297,22 +303,20 @@ class CellMLParser:
         except KeyError:
             raise CellMLParsingError(
                 'A map_components component_1 attribute must refer to a'
-                ' component in the current model, got "' + str(c1) + '".',
-                element)
+                f' component in the current model, got "{c1}".', element)
         try:
             c2 = model.component(c2)
         except KeyError:
             raise CellMLParsingError(
                 'A map_components component_2 attribute must refer to a'
-                ' component in the current model, got "' + str(c2) + '".',
-                element)
+                f' component in the current model, got "{c2}".', element)
 
         # Check components are not yet connected
         if (c1, c2) in connected:
             raise CellMLParsingError(
                 'Each connection in a model must connect a unique pair of'
-                ' components, found multiple for "' + c1.name() + '" and "'
-                + c2.name() + '".', element)
+                f' components, found multiple for "{c1.name()}" and'
+                f' "{c2.name()}".', element)
         connected.add((c1, c2))
         connected.add((c2, c1))
 
@@ -359,15 +363,13 @@ class CellMLParser:
         except KeyError:
             raise CellMLParsingError(
                 'A map_variables variable_1 attribute must refer to a'
-                ' variable in component_1, got "' + str(v1) + '".',
-                element)
+                f' variable in component_1, got "{v1}".', element)
         try:
             v2 = c2.variable(v2)
         except KeyError:
             raise CellMLParsingError(
                 'A map_variables variable_2 attribute must refer to a'
-                ' variable in component_2, got "' + str(v1) + '".',
-                element)
+                f' variable in component_2, got "{v1}".', element)
 
         # Connect variables
         model = c1.model()
@@ -428,8 +430,7 @@ class CellMLParser:
         except KeyError:
             raise CellMLParsingError(
                 'A component_ref\'s component attribute must reference a'
-                ' component in the same model, got "' + component + '".',
-                element)
+                f' component in the same model, got "{component}".', element)
 
         # Check allowed content
         self._check_allowed_content(element, ['component_ref'], ['component'])
@@ -441,9 +442,8 @@ class CellMLParser:
             if component.parent() is not None:
                 raise CellMLParsingError(
                     'A component can only have a single encapsulation parent:'
-                    ' found ' + str(component) + ' with parents '
-                    + str(component.parent()) + ' and ' + str(parent) + '.',
-                    element)
+                    f' found {component} with parents {component.parent()} and'
+                    f' and {parent}.', element)
 
             # Set parent (won't raise CellMLErrors)
             component.set_parent(parent)
@@ -498,8 +498,8 @@ class CellMLParser:
                 units = model.find_units(units)
             except myokit.formats.cellml.v2.CellMLError:
                 raise CellMLParsingError(
-                    'Unknown unit "' + str(units) + '" referenced inside a'
-                    ' MathML equation.', element)
+                    f'Unknown unit "{units}" referenced inside a MathML'
+                    ' equation.', element)
 
             # Create and return
             return myokit.Number(value, units.myokit_unit())
@@ -516,36 +516,36 @@ class CellMLParser:
             if ns != cellml.NS_MATHML:
                 raise CellMLParsingError(
                     'The contents of a mathml:math element must be in the'
-                    ' mathml namespace, found "' + str(child.tag) + '" inside '
-                    + str(component) + '.', child)
+                    f' mathml namespace, found "{child.tag}" inside'
+                    f' {component}.', child)
 
             # If it isn't these it must be an apply
             if el != 'apply':
                 raise CellMLParsingError(
                     'Unexpected contents in mathml:math. Expecting'
-                    ' mathml:apply but found mathml:' + el + ' inside maths'
-                    ' for ' + str(component) + '.', child)
+                    f' mathml:apply but found mathml:{el} inside maths for'
+                    f' {component}.', child)
 
             # Parse
             eq = p.parse(child)
             if not isinstance(eq, myokit.Equal):
                 raise CellMLParsingError(
                     'Unexpected element in MathML, expecting a list of'
-                    ' equations, got ' + self._tag(child) + '.', child)
+                    f' equations, got f{self._tag(child)}.', child)
             lhs, rhs = eq
 
             # Check lhs
             if not isinstance(lhs, myokit.LhsExpression):
                 raise CellMLParsingError(
                     'Invalid expression found on the left-hand side of an'
-                    ' equation: ' + self._dae_message, child)
+                    f' equation: {self._dae_message}.', child)
 
             # Check variable is undefined
             var = lhs.var()
             if var.has_equation():
                 raise CellMLParsingError(
-                    'Overdefined variable: ' + str(var) + ': Two defining'
-                    ' equations.', child)
+                    f'Overdefined variable: {var}: Two defining equations.',
+                    child)
 
             # Set equations
             try:
@@ -642,7 +642,7 @@ class CellMLParser:
         except myokit.formats.cellml.v2.CellMLError as e:
             raise CellMLParsingError(
                 'Models that take derivatives with respect to more than one'
-                ' variable are not supported (' + str(e) + ').')
+                f' variable are not supported ({e}).')
 
         # Read any rdf annotations
         # TODO: Allow RDF annotations from external files
@@ -697,9 +697,9 @@ class CellMLParser:
         children = element.findall(self._join('unit'))
         if not children:
             warnings.warn(
-                'Unable to parse definition for units "' + str(name) + '",'
-                ' using `dimensionless instead. (Defining new base units is'
-                ' not supported.)')
+                f'Unable to parse definition for units "{name}", using'
+                ' `dimensionless instead. (Defining new base units is not'
+                ' supported.)')
 
         # Parse content
         myokit_unit = myokit.units.dimensionless
@@ -716,6 +716,10 @@ class CellMLParser:
         """
         Parses a variable ``element`` and adds a variable to the given
         ``component``.
+
+        If an initial value needs to be set, returns a tuple
+        ``(element, variable, initial_value_string)``. Otherwise returns
+        ``None``.
         """
         # Check name is present
         try:
@@ -752,13 +756,15 @@ class CellMLParser:
             ]
             self._check_allowed_content(element, [], attr, name)
 
-            # Set initial value
-            variable.set_initial_value(
-                element.attrib.get('initial_value', None))
+            # Pass back initial value for delayed processing
+            init = element.attrib.get('initial_value', None)
 
         except myokit.formats.cellml.v2.CellMLError as e:
             raise CellMLParsingError(str(e), element)
 
+        if init is not None:
+            return (element, variable, init)
+
     def _sort_units(self, element):
         """
         Returns all units elements in ``element``, sorted in an order that
@@ -794,14 +800,14 @@ class CellMLParser:
             # Check doesn't shadow an si unit
             if name in si_units:
                 raise CellMLParsingError(
-                    'Units name "' + name + '" overlaps with a predefined name'
-                    ' in ' + self._tag(element) + '.', element)
+                    f'Units name "{name}" overlaps with a predefined name in'
+                    f' {self._tag(element)}.', element)
 
             # Check for duplicates
             if name in local_units:
                 raise CellMLParsingError(
-                    'Duplicate units definition "' + name + '" in '
-                    + self._tag(element) + '.', element)
+                    f'Duplicate units definition "{name}" in'
+                    f' {self._tag(element)}.', element)
             local_units[name] = units
 
             # Determine dependencies
@@ -811,8 +817,7 @@ class CellMLParser:
                     dep = unit.attrib['units']
                 except KeyError:
                     raise CellMLParsingError(
-                        'Unit elements must have a units attribute.',
-                        element)
+                        'Unit elements must have a units attribute.', element)
                 deps.add(dep)
             unresolved[name] = deps
 
@@ -835,9 +840,8 @@ class CellMLParser:
                 for name, deps in unresolved.items():
                     deps.difference_update(fresh)
             else:
-                raise CellMLParsingError(
-                    'Unable to resolve network of units in '
-                    + self._tag(element) + '.', element)
+                raise CellMLParsingError('Unable to resolve network of units'
+                                         f' in {self._tag(element)}.', element)
         return ordered
 
     def _tag(self, element, name=None):
@@ -854,6 +858,6 @@ class CellMLParser:
         ns, el = split(element.tag)
         tag = self._item(ns, el)
         if ns == self._ns and name is not None:
-            tag += '[@name="' + name + '"]'
+            tag += f'[@name="{name}"]'
         return tag
 

myokit/formats/cellml/v2/_writer.py

@@ -279,9 +279,13 @@ class CellMLWriter:
 
         # Add initial value
         if variable is variable.initial_value_variable():
-            value = myokit.float.str(variable.initial_value()).strip()
-            if value[-4:] == 'e+00':
-                value = value[:-4]
+            value = variable.initial_value()
+            if isinstance(value, myokit.Name):
+                value = value.var().name()
+            else:
+                value = myokit.float.str(value).strip()
+                if value[-4:] == 'e+00':
+                    value = value[:-4]
             element.attrib['initial_value'] = value
 
     def write(self, model):

myokit/formats/heka/_patchmaster.py

@@ -1,8 +1,6 @@
 #
 # This module reads files in HEKA Patchmaster format.
 #
-# Specifically, it targets the 2x90.2 format.
-#
 # Notes:
 #  - HEKA publishes a lot of information about its file format on its FTP
 #    server: server.hekahome.de
@@ -159,9 +157,10 @@ class PatchMasterFile:
         except ValueError:
             pass
 
-        if not self._version.startswith('v2x90.2'):
-            warnings.warn('Only PatchMaster version v2x90.2 is supported.'
-                          f' Attempting to read version {self._version}.')
+        if not (self._version.startswith('v2x90.2')
+                or self._version.startswith('v2x73')):
+            warnings.warn(
+                'Untested PatchMaster format version {self._version}.')
 
         # Endianness
         f.seek(52)
@@ -1021,6 +1020,9 @@ class Series(TreeNode, myokit.formats.SweepSource):
                     a.r_series_tau()
             else:
                 log.meta[f'{pre}r_series_compensation_enabled'] = 'false'
+            log.meta[f'{pre}current_clamp_holding_current_pA'] = a.i_hold()
+            log.meta[f'{pre}current_clamp_stimulus_gain'] = \
+                a.current_clamp_stimulus_gain()
 
         # Add protocol to meta data
         stimulus = self.stimulus()
@@ -1110,6 +1112,10 @@ class Series(TreeNode, myokit.formats.SweepSource):
                 out.append(f'  R series compensation: {p} %, {q} us')
             else:
                 out.append('  R series compensation: not enabled')
+            # Current-clamp info
+            out.append(f'  Current clamp holding current: {a.i_hold()} pA')
+            out.append('  Current clamp stimulus gain: '
+                       f'{a.current_clamp_stimulus_gain()} pA/mV')
 
         # Info from first trace
         if len(self) and len(self[0]):
@@ -1491,7 +1497,6 @@ class Trace(TreeNode):
         not perform this zeroing, but it can be applied by setting
         ``ignore_zero_segment`` to ``False``.
         """
-
         if self._data_interleave_size == 0 or self._data_interleave_skip == 0:
             # Read continuous data
             d = np.memmap(self._handle, self._data_type, 'r',
@@ -1666,18 +1671,25 @@ class AmplifierState:
         # Read properties
         i = handle.tell()
 
-        # Current gain (V/A)
+        # Current gain (the "gain" in VC mode) (V/A)
         handle.seek(i + 8)      # sCurrentGain = 8;  (* LONGREAL *)
         self._current_gain = reader.read1('d')
 
         # Holding potential and offsets
         handle.seek(i + 112)  # sVHold = 112; (* LONGREAL *)
-        self._holding = reader.read1('d')
+        self._vhold = reader.read1('d')
         handle.seek(i + 128)  # sVpOffset = 128; (* LONGREAL *)
         self._voff = reader.read1('d')
         handle.seek(i + 136)  # sVLiquidJunction = 136; (* LONGREAL *)
         self._ljp = reader.read1('d')
 
+        # Current clamp settings
+        handle.seek(i + 144)  # sCCIHold = 144; (* LONGREAL *)
+        self._ihold = reader.read1('d')
+        # Stimulus scaling in current clamp mode (a byte / enum)
+        handle.seek(i + 243)    # sCCGain = 243; (* BYTE *)
+        self._cc_gain = reader.read1('b')
+
         # Series resistance and compensation
         handle.seek(i + 40)     # sRsFraction = 40; (* LONGREAL *)
         self._rs_fraction = reader.read1('d')
@@ -1730,6 +1742,10 @@ class AmplifierState:
         handle.seek(i + 16)  # sF2Bandwidth = 16; (* LONGREAL *)
         self._filter2_freq_both = reader.read1('d') * 1e-3
 
+        # Stimulus filter
+        handle.seek(i + 282)  # sStimFilterOn = 282; (* BYTE *)
+        self._stimulus_filter = StimulusFilterSetting(reader.read1('b'))
+
         # Suspect this indicates external filter 2
         #handle.seek(i + 287)  # sF2Source = 287; (* BYTE *)
         #self._temp['sF2Source'] = reader.read1('b')
@@ -1752,9 +1768,16 @@ class AmplifierState:
         #handle.seek(i + 264)  # sImon1Bandwidth = 264; (* LONGREAL *)
         #self._temp['sImon1Bandwidth'] = reader.read1('d')
 
-        # Stimulus filter
-        handle.seek(i + 282)  # sStimFilterOn = 282; (* BYTE *)
-        self._stimulus_filter = StimulusFilterSetting(reader.read1('b'))
+        #handle.seek(i + 242)  # sCCRange = 242; (* BYTE *)
+        #print('CC range', reader.read1('b'))
+        #handle.seek(i + 285)  # sCCCFastOn = 285; (* BYTE *)
+        #print('CC fast on', reader.read1('b'))
+        #handle.seek(i + 286)  # sCCFastSpeed = 286; (* BYTE *)
+        #print('CC fast speed', reader.read1('b'))
+        #handle.seek(i + 376)  # sCCStimDacScale = 376; (* LONGREAL *)
+        #print('CC stim dac scale', reader.read1('d'))
+        #handle.seek(i + 160)  # sCCTrackVHold = 160; (* LONGREAL *)
+        #print('CCTrackVHold', reader.read1('d'))
 
     def c_fast(self):
         """
@@ -1820,9 +1843,37 @@ class AmplifierState:
         """
         return self._cs_range
 
+    def current_clamp_stimulus_gain(self):
+        """
+        Returns the "CC-Gain" setting, in pA/mV.
+
+        For current-clamp measurements, this is one of two values (along with
+        the "CC Stim. Scale", which is currently not provided by this class)
+        that determines the scaling of applied stimuli.
+
+        **This value is provided for information only**: stimuli returned by
+        the :class:`PatchMasterFile` methods are already scaled appropriately.
+        """
+        gain_values = (0.1, 1, 10, 100)
+        try:
+            return gain_values[self._cc_gain]
+        except IndexError:  # pragma: no-cover
+            raise NotImplementedError(
+                'Unexpected value found for current clamp gain'
+                f' ({self._cc_gain}).')
+
     def current_gain(self):
         """
-        The gain setting for current measurements, in mV/pA.
+        The gain setting of the "current monitor" output, in mV/pA.
+
+        For voltage-clamp measurements, this is the main "gain" setting used to
+        record currents.
+
+        **This value is provided for information only**: the currents returned
+        by the :class:`PatchMasterFile` methods are already scaled
+        appropriately. The chosen gain value is mainly interesting because it
+        determines the feedback resistor used in the headstage. See the
+        Patchmaster and amplifier manuals for details.
         """
         return self._current_gain * 1e-9
 
@@ -1875,6 +1926,12 @@ class AmplifierState:
         fb = int(fb) if fb == int(fb) else fb
         return f'{self._filter2_type} {fb} kHz combined, {fs} kHz f2-only'
 
+    def i_hold(self):
+        """
+        Returns the current-clamp holding current, in pA.
+        """
+        return self._ihold * 1e12
+
     def ljp(self):
         """
         Returns the liquid junction potential (LJP, in mV) used in the LJP
@@ -1942,12 +1999,12 @@ class AmplifierState:
 
     def v_hold(self):
         """
-        Returns the holding potential (in mV).
+        Returns the voltage-clamp holding potential (in mV).
 
         This is the potential last set in the amplifier window, before any
         experiments were run.
         """
-        return self._holding * 1e3
+        return self._vhold * 1e3
 
 
 class Filter1Setting(enum.Enum):