myokit 1.37.2__tar.gz → 1.37.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: myokit
-Version: 1.37.2
+Version: 1.37.4
 Summary: A modeling and simulation tool for cardiac cellular electrophysiology
 Home-page: http://myokit.org
 Author: Michael Clerx
@@ -123,7 +123,7 @@ A high-level plan for Myokit's future is provided in the [roadmap](./ROADMAP.md)
 ### Meet the team!
 
 Myokit's development is driven by a [team](https://github.com/orgs/myokit/people) at the Universities of Nottingham, Oxford, and Macao, led by Michael Clerx (Nottingham).
-It is guided by an external advisory board composed of Jordi Heijman (Maastricht University), Trine Krogh-Madsen (Weill Cornell Medicine), and David Gavaghan (Oxford).
+It is guided by an external advisory group composed of Jordi Heijman (Maastricht University), Trine Krogh-Madsen (Weill Cornell Medicine), and David Gavaghan (Oxford).
 
 
 ## Citing Myokit

{myokit-1.37.2 → myokit-1.37.4}/README.md

@@ -76,7 +76,7 @@ A high-level plan for Myokit's future is provided in the [roadmap](./ROADMAP.md)
 ### Meet the team!
 
 Myokit's development is driven by a [team](https://github.com/orgs/myokit/people) at the Universities of Nottingham, Oxford, and Macao, led by Michael Clerx (Nottingham).
-It is guided by an external advisory board composed of Jordi Heijman (Maastricht University), Trine Krogh-Madsen (Weill Cornell Medicine), and David Gavaghan (Oxford).
+It is guided by an external advisory group composed of Jordi Heijman (Maastricht University), Trine Krogh-Madsen (Weill Cornell Medicine), and David Gavaghan (Oxford).
 
 
 ## Citing Myokit

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

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

@@ -487,56 +487,55 @@ class Unit:
         return self.__rtruediv__(other)
 
     @staticmethod
-    def register(name, unit, quantifiable=False, output=False):
+    def register(name, unit, quantifiable=False,
+                 preferred_representation=False):
         """
-        Registers a unit name with the Unit class. Registered units will be
-        recognised by the parse() method.
+        Registers a unit name with the :class:`Unit` class so that it will be
+        recognised when parsing.
 
         Arguments:
 
         ``name``
-            The unit name. A variable will be created using this name.
+            The unit name. This must be a valid myokit name, i.e.
+            ``myokit.check_name(name)`` should not raise any errors.
         ``unit``
             A valid unit object
         ``quantifiable``
             ``True`` if this unit should be registered with the unit class as a
-            quantifiable unit. Typically this should only be done for the
-            unquantified symbol notation of SI or SI derived units. For example
-            m, g, Hz, N but not meter, kg, hertz or forthnight.
-        ``output``
-            ``True`` if this units name should be used to display this unit in.
-            This should be set for all common units (m, kg, nm, Hz) but not for
-            more obscure units (furlong, parsec). Having ``output`` set to
-            ``False`` will cause one-way behavior: Myokit will recognise the
-            unit name but never use it in output.
-            Setting this to ``True`` will also register the given name as a
-            preferred representation format.
-
-        """
-        if not isinstance(name, str):
-            raise TypeError('Given name must be a string.')
+            _quantifiable_ unit, i.e. a unit that can be preceded by an SI
+            prefix such as "m" or "G". Typically this should only be done
+            for the unquantified symbol notation of SI or SI derived units. For
+            example "m", "g", or "Hz" but not "km", "meter", or "bushel".
+        ``preferred_representation``
+            Set to ``True`` to also register ``name`` as the preferred
+            representation for ``unit``.
+
+        """
+        name = myokit.check_name(name)
         if not isinstance(unit, Unit):
             raise TypeError('Given unit must be myokit.Unit')
         Unit._units[name] = unit
         if quantifiable:
             # Overwrite existing entries without warning
             Unit._quantifiable.add(name)
-        if output:
+        if preferred_representation:
             # Overwrite existing entries without warning
             Unit._preferred_representations[unit] = name
 
     @staticmethod
     def register_preferred_representation(rep, unit):
         """
-        Registers a preferred representation for the given unit without
-        registering it as a new type. This method can be used to register
-        common representations such as "umol/L" and "km/h".
+        Sets the preferred representation for the a unit, in terms of already
+        defined units.
+
+        This method can be used to register common representations such as
+        "umol/L" and "km/h". The given representation should be parseable by
+        Myokit, with the result equalling ``unit``.
 
         Arguments:
 
         ``rep``
-            A string, containing the preferred name for this unit. This should
-            be something that Myokit can parse.
+            A string containing the preferred representation for this unit.
         ``unit``
             The unit to register a notation for.
 
@@ -545,9 +544,14 @@ class Unit:
         # Overwrite existing entries without warning
         if not isinstance(unit, myokit.Unit):
             raise ValueError(
-                'Second argument to register_preferred_representation must be'
-                ' a myokit.Unit')
-        Unit._preferred_representations[unit] = str(rep)
+                'The second argument to register_preferred_representation must'
+                ' be a myokit.Unit')
+        rep = str(rep)
+        if not myokit.parse_unit(rep) == unit:
+            raise ValueError(
+                f'The representation [{rep}] does not equal {unit._str(True)}'
+                ' when parsed.')
+        Unit._preferred_representations[unit] = rep
 
     def __repr__(self):
         """
@@ -616,7 +620,8 @@ class Unit:
 
     def __str__(self):
 
-        # Strategy 1: Try simple look-up (using float.eq comparison)
+        # Strategy 1: Try simple look-up (using hash based on _str() followed
+        # by check of exponents in __eq__ for comparison
         try:
             return '[' + Unit._preferred_representations[self] + ']'
         except KeyError:
@@ -629,8 +634,8 @@ class Unit:
                 rep = '[' + test + ']'
                 break
 
-        # Strategy 3: Try finding a representation for the exponent and adding
-        # a multiplier to that.
+        # Strategy 3: Try finding a representation for the exponent (without a
+        # multiplier) and adding a multiplier to that.
         if rep is None:
 
             # Because kilos are defined with a multiplier of 1000, the
@@ -640,17 +645,20 @@ class Unit:
             u = Unit(list(self._x), m)
             rep = Unit._preferred_representations.get(u, None)
 
-            # Add multiplier part
+            # Add multiplier part:
             if rep is not None:
-                m = myokit.float.cround(self._m - m)
-                m = 10**m
-                if m >= 1:
-                    m = myokit.float.cround(m)
-                if m < 1e6:
-                    m = str(m)
+                if '(' in rep:
+                    rep = None
                 else:
-                    m = '{:<1.0e}'.format(m)
-                rep = '[' + rep + ' (' + m + ')]'
+                    m = myokit.float.cround(self._m - m)
+                    m = 10**m
+                    if m >= 1:
+                        m = myokit.float.cround(m)
+                    if m < 1e6:
+                        m = str(m)
+                    else:
+                        m = '{:<1.0e}'.format(m)
+                    rep = '[' + rep + ' (' + m + ')]'
 
         # Strategy 4: Build a new representation
         if rep is None:

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

@@ -3,8 +3,6 @@
 #
 # Specifically, it targets the 2x90.2 format.
 #
-# It has not been extensively tested.
-#
 # Notes:
 #  - HEKA publishes a lot of information about its file format on its FTP
 #    server: server.hekahome.de
@@ -25,6 +23,8 @@
 #    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.
 #
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
@@ -236,6 +236,9 @@ class PatchMasterFile:
     def __iter__(self):
         return iter(self._pulsed_tree)
 
+    def __len__(self):
+        return len(self._pulsed_tree)
+
     def amplifier_tree(self):
         """
         Returns this file's amplifier tree (an :class:`AmplifierFile` object),
@@ -626,7 +629,7 @@ class Series(TreeNode, myokit.formats.SweepSource):
         1. In the individual :class:`Trace` objects. This is somewhat
            counter-intuitive as some of these properties (e.g.
            :meth:Trace.r_pipette()`) were set before a series was
-           acquired and do no change between channels or sweeps.
+           acquired and do not change between channels or sweeps.
         2. In the series' :class:`AmplifierState`, which can be accessed via
            the :meth:`amplifier_state()` method.
 
@@ -984,6 +987,8 @@ class Series(TreeNode, myokit.formats.SweepSource):
             log.meta[f'{pre}current_gain_mV_per_pA'] = a.current_gain()
             log.meta[f'{pre}filter1'] = a.filter1_str()
             log.meta[f'{pre}filter2'] = a.filter2_str()
+            log.meta[f'{pre}filter1_kHz'] = a.filter1().frequency()
+            log.meta[f'{pre}filter2_kHz'] = a.filter2()[2]
             log.meta[f'{pre}stimulus_filter'] = a.stimulus_filter_str()
             log.meta[f'{pre}ljp_correction_mV'] = a.ljp()
             log.meta[f'{pre}voltage_offset_mV'] = a.v_off()
@@ -991,6 +996,10 @@ class Series(TreeNode, myokit.formats.SweepSource):
             if a.c_fast_enabled():
                 log.meta[f'{pre}c_fast_compensation_enabled'] = 'true'
                 log.meta[f'{pre}c_fast_pF'] = a.c_fast()
+                cf = a.c_fast_detailed()
+                log.meta[f'{pre}c_fast_amp1_pF'] = cf[0]
+                log.meta[f'{pre}c_fast_amp2_pF'] = cf[1]
+                log.meta[f'{pre}c_fast_tau2_us'] = cf[2]
             else:
                 log.meta[f'{pre}c_fast_compensation_enabled'] = 'false'
             log.meta[f'{pre}c_slow_pF'] = a.c_slow()
@@ -1080,6 +1089,9 @@ class Series(TreeNode, myokit.formats.SweepSource):
             # C fast
             if a.c_fast_enabled():
                 out.append(f'  C fast compensation: {a.c_fast()} pF,')
+                cf = a.c_fast_detailed()
+                out.append(f'  C fast (amp1, amp2, tau2): {cf[0]} pF, {cf[1]}'
+                           f' pF, {cf[2]} us')
             else:
                 out.append('  C fast compensation: not enabled')
             # C slow
@@ -1635,6 +1647,17 @@ class Trace(TreeNode):
 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
+    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).
     """
     def __init__(self, handle, reader):
 
@@ -1663,6 +1686,10 @@ 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')
@@ -1697,10 +1724,13 @@ class AmplifierState:
         # 2 is the combined bandwidth of Filter 1 and Filter 2.
         handle.seek(i + 239)  # sF2Response = 239; (* BYTE *)
         self._filter2_type = Filter2Type(reader.read1('b'))
-        handle.seek(i + 24)  # sF2Frequency = 24; (* LONGREAL *)
-        self._filter2_freq_solo = reader.read1('d')
+        if self._filter2_type is Filter2Type.BYPASS:
+            self._filter2_freq_solo = 0
+        else:
+            handle.seek(i + 24)  # sF2Frequency = 24; (* LONGREAL *)
+            self._filter2_freq_solo = reader.read1('d') * 1e-3
         handle.seek(i + 16)  # sF2Bandwidth = 16; (* LONGREAL *)
-        self._filter2_freq_both = reader.read1('d')
+        self._filter2_freq_both = reader.read1('d') * 1e-3
 
         # Suspect this indicates external filter 2
         #handle.seek(i + 287)  # sF2Source = 287; (* BYTE *)
@@ -1818,11 +1848,13 @@ class AmplifierState:
         """
         Returns a tuple ``(type, f_both, f_solo)`` describing the Filter 2
         settings, where ``type`` is a :class:`Filter2Type`, where ``f_both`` is
-        the frequency in Hz of both filters combined, and when ``f_solo`` is
-        the frequency of Filter 2 alone.
+        the frequency in kHz of both filters combined, and when ``f_solo`` is
+        the frequency in kHz of Filter 2 alone.
 
         The frequency shown in PatchMaster is that of both filters combined.
         If the "bypass" filter is selected, the frequency settings are unused.
+        In this case, ``f_both`` will be the frequency of filter 1 and
+        ``f_solo`` will be returned as 0.
 
         For more information on Filter 1 and 2, see :class:`Filter1Setting`.
         """
@@ -1840,8 +1872,8 @@ class AmplifierState:
         """
         if self._filter2_type is Filter2Type.BYPASS:
             return str(self._filter2_type)
-        fb = round(self._filter2_freq_both * 1e-3, 2)
-        fs = round(self._filter2_freq_solo * 1e-3, 2)
+        fb = round(self._filter2_freq_both, 2)
+        fs = round(self._filter2_freq_solo, 2)
         fb = int(fb) if fb == int(fb) else fb
         return f'{self._filter2_type} {fb} kHz combined, {fs} kHz f2-only'
 
@@ -1889,6 +1921,19 @@ 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
@@ -1949,6 +1994,17 @@ class Filter1Setting(enum.Enum):
         else:
             return 'HQ 30 kHz'
 
+    def frequency(self):
+        """ Returns the cut-off frequency for this filter setting, in kHz. """
+        if self is Filter1Setting.BESSEL_100K:
+            return 100
+        elif self is Filter1Setting.BESSEL_30K:
+            return 30
+        elif self is Filter1Setting.BESSEL_10K:
+            return 10
+        else:
+            return 30
+
 
 class Filter2Type(enum.Enum):
     """
@@ -2020,6 +2076,24 @@ 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.2 → myokit-1.37.4}/myokit/formats/sbml/_api.py

@@ -313,15 +313,18 @@ class Model:
                 variable.uname(),
                 variable.is_constant(),
             )
-            if variable.is_state() or variable.is_literal():
-                v.set_value(variable.rhs(), variable.is_state())
-            else:
-                # if variable is constant but not literal,
-                # set via initial value
-                v.set_initial_value(variable.rhs())
 
-            if variable.is_state():
-                v.set_initial_value(variable.initial_value())
+            if variable.is_constant():
+                if variable.is_literal():
+                    v.set_value(variable.rhs())
+                else:
+                    v.set_initial_value(variable.rhs())
+            else:
+                if variable.is_state():
+                    v.set_initial_value(variable.initial_value())
+                    v.set_value(variable.rhs(), True)
+                else:
+                    v.set_value(variable.rhs())
 
             unit = variable_unit(variable, time_unit)
             if unit is not None:

{myokit-1.37.2 → myokit-1.37.4}/myokit/gui/datalog_viewer.py

@@ -63,8 +63,8 @@ SETTINGS_FILE = os.path.join(myokit.DIR_USER, 'DataLogViewer.ini')
 # About
 ABOUT = '<h1>' + TITLE + '</h1>' + """
 <p>
-    The DataLog viewer is a PROTOTYPE utility to examine time series data.
-    At the moment, exclusively WinWCP, ABF and CSV files.
+    The DataLog viewer is a PROTOTYPE utility to examine time series data in
+    formats supported by Myokit.
 </p>
 <p>
     System info:
@@ -162,6 +162,8 @@ class DataLogViewer(myokit.gui.MyokitApplication):
                 self._tool_next_file.setEnabled(True)
                 self._tool_prev_file.setEnabled(True)
             self._tabs.setCurrentIndex(0)
+            self._tool_close.setEnabled(True)
+            self._tool_close_all.setEnabled(True)
 
     def action_about(self):
         """
@@ -178,15 +180,48 @@ class DataLogViewer(myokit.gui.MyokitApplication):
         self._tabs.removeTab(index)
 
         # Update buttons
-        if self._tabs.count() < 2:
+        n = self._tabs.count()
+        if n < 2:
             self._tool_next_file.setEnabled(False)
             self._tool_prev_file.setEnabled(False)
+            if n < 1:
+                self._tool_close.setEnabled(False)
+                self._tool_close_all.setEnabled(False)
 
         # Delete tab
         if tab is not None:
             tab.deleteLater()
-        gc.collect()
         del tab
+        gc.collect()
+
+    def action_close_current(self):
+        """ Close the current tab. """
+        idx = self._tabs.currentIndex()
+        if idx >= 0:
+            self.action_close(idx)
+
+    def action_close_all(self):
+        """ Called to close all tabs. """
+        n = self._tabs.count()
+        if n < 1:
+            return
+
+        # Get all tabs, to delete later
+        tabs = [self._tabs.widget(i) for i in range(n)]
+        # Remove all tabs, without deleting
+        self._tabs.clear()
+
+        # Update buttons
+        self._tool_close.setEnabled(False)
+        self._tool_close_all.setEnabled(False)
+        self._tool_next_file.setEnabled(False)
+        self._tool_prev_file.setEnabled(False)
+
+        # Delete tabs
+        for tab in tabs:
+            tab.deleteLater()
+        del tab, tabs
+        gc.collect()
 
     def action_first_var(self):
         """ Select the first variable in the current file. """
@@ -225,6 +260,10 @@ class DataLogViewer(myokit.gui.MyokitApplication):
             if tab_count_new > tab_count:
                 self._tabs.setCurrentIndex(tab_count)
 
+                # Enable tab closing buttons
+                self._tool_close.setEnabled(True)
+                self._tool_close_all.setEnabled(True)
+
                 # Enable next/previous file menu items
                 if tab_count_new > 1:
                     self._tool_next_file.setEnabled(True)
@@ -285,6 +324,21 @@ class DataLogViewer(myokit.gui.MyokitApplication):
         self._tool_open.setIcon(QtGui.QIcon.fromTheme('document-open'))
         self._tool_open.triggered.connect(self.action_open)
         self._menu_file.addAction(self._tool_open)
+        # File > Close
+        self._tool_close = QtGui.QAction('&Close tab', self)
+        self._tool_close.setShortcut('Ctrl+W')
+        self._tool_close.setStatusTip('Close the current tab')
+        self._tool_close.setIcon(QtGui.QIcon.fromTheme('document-close'))
+        self._tool_close.triggered.connect(self.action_close_current)
+        self._tool_close.setEnabled(False)
+        self._menu_file.addAction(self._tool_close)
+        # File > Close all
+        self._tool_close_all = QtGui.QAction('Close &all tabs', self)
+        self._tool_close_all.setStatusTip('Close all tabs')
+        self._tool_close_all.setIcon(QtGui.QIcon.fromTheme('document-close'))
+        self._tool_close_all.triggered.connect(self.action_close_all)
+        self._tool_close_all.setEnabled(False)
+        self._menu_file.addAction(self._tool_close_all)
         # File > ----
         self._menu_file.addSeparator()
         # File > Quit
@@ -401,9 +455,7 @@ class DataLogViewer(myokit.gui.MyokitApplication):
                     self._path = path
 
     def load_file(self, filename):
-        """
-        Loads a data file.
-        """
+        """ Loads a data file. """
         root, ext = os.path.splitext(os.path.basename(filename))
         try:
             action = self._load_actions[ext.lower()]
@@ -700,7 +752,8 @@ class SweepSourceTab(GraphTabWidget):
         widget.setLayout(vbox)
 
         # Add tab
-        self.addTab(widget, name)
+        adda = 'D/A' if da else 'A/D'
+        self.addTab(widget, f'{adda}: {name}')
 
     '''
     def debug_tab(self, channel_index, da=True):

{myokit-1.37.2 → myokit-1.37.4}/myokit/tests/test_quantity.py

@@ -107,10 +107,10 @@ class QuantityTest(unittest.TestCase):
         # Test has does not change in quantity's lifetime
 
         try:
-            u = myokit.units.m**8
+            u = myokit.units.m / myokit.units.mol
             q1 = myokit.Quantity(1, u)
             h1 = hash(q1)
-            myokit.Unit.register_preferred_representation('abc', u)
+            myokit.Unit.register_preferred_representation('km/kmol', u)
             q2 = myokit.Quantity(1, u)
             h2 = hash(q2)
             self.assertEqual(h1, h2)

{myokit-1.37.2 → myokit-1.37.4}/myokit/tests/test_sbml_export.py

@@ -170,6 +170,7 @@ class TestSBMLExport(unittest.TestCase):
         self.assertIn("<listOfUnitDefinitions>", sbml_str)
         self.assertIn('<unitDefinition id="m_per_s_times_1e3">', sbml_str)
 
+    def test_list_of_parameters_const_depend(self):
         # Test setting a constant parameter that depends on another parameter
         model = Model()
         p = model.add_parameter("my_parameter")
@@ -193,6 +194,7 @@ class TestSBMLExport(unittest.TestCase):
         self.assertIn('<initialAssignment symbol="my_parameter2">', sbml_str)
         self.assertIn("<times/>\n            <ci>my_parameter</ci>\n            <cn>2.0</cn>", sbml_str)  # noqa: E501
 
+    def test_list_of_parameters_var(self):
         model = Model()
         p = model.add_parameter("my_parameter", is_constant=False)
         p.set_initial_value(myokit.Number(1))
@@ -325,3 +327,22 @@ class TestSBMLExport(unittest.TestCase):
             sbml_str
         )
 
+    def test_variable_dependent_variables(self):
+        m = myokit.Model()
+        c = m.add_component('comp')
+        t = c.add_variable('time', rhs=myokit.Number(0))
+        t.set_unit(myokit.units.second)
+        t.set_binding('time')
+        v = c.add_variable('var', initial_value=3)
+        v.set_rhs(myokit.Number(1))
+        v2 = c.add_variable('var2')
+        v2.set_rhs(myokit.Name(v))
+
+        s = sbml.Model.from_myokit_model(m)
+        self.assertEqual(s.parameter('var2').is_rate(), False)
+        self.assertEqual(s.parameter('var').is_rate(), True)
+
+        sbml_str = write_string(s).decode("utf8")
+        self.assertIn('<initialAssignment symbol="var">', sbml_str)
+        self.assertNotIn('<initialAssignment symbol="var2">', sbml_str)
+        self.assertIn('<assignmentRule variable="var2">', sbml_str)

{myokit-1.37.2 → myokit-1.37.4}/myokit/tests/test_unit.py

@@ -296,24 +296,35 @@ class MyokitUnitTest(unittest.TestCase):
         self.assertEqual(x.exponents(), [0, 2, 1.5, 0, 0, 0, -1.23])
 
     def test_register_errors(self):
-        # Test errors for Unit.register (rest is already used a lot).
-        self.assertRaises(TypeError, myokit.Unit.register, 4, myokit.Unit())
+        # Test errors for Unit.register (rest of the method is already used
+        # throughout other tests).
+        self.assertRaises(myokit.InvalidNameError, myokit.Unit.register, 4,
+                          myokit.Unit())
         self.assertRaises(TypeError, myokit.Unit.register, 'hi', 4)
 
     def test_register_preferred_representation(self):
         # Test new representations can be registered
 
-        u = myokit.units.m**8
-        self.assertEqual(str(u), '[m^8]')
+        u = myokit.units.K / myokit.units.A
         try:
-            myokit.Unit.register_preferred_representation(
-                'abc', myokit.units.m**8)
-            self.assertEqual(str(u), '[abc]')
+            # Register valid unit
+            self.assertEqual(str(u), '[K/A]')  # also auto registers!
+            myokit.Unit.register_preferred_representation('mK/mA', u)
+            self.assertEqual(str(u), '[mK/mA]')
 
+            # Attempt registering something that isn't a unit
             self.assertRaisesRegex(
                 ValueError, 'must be a myokit.Unit',
                 myokit.Unit.register_preferred_representation, 'x', 123)
 
+            # Attempt registering a representation that doesn't match the unit
+            self.assertRaisesRegex(
+                ValueError, r'does not equal \[K/A] when parsed',
+                myokit.Unit.register_preferred_representation, 'm', u)
+            self.assertRaisesRegex(
+                ValueError, r'does not equal \[K/A \(2\)] when parsed',
+                myokit.Unit.register_preferred_representation, 'K/A', u * 2)
+
         finally:
             # Bypassing the public API, this is bad test design!
             if u in myokit.Unit._preferred_representations:
@@ -365,6 +376,16 @@ class MyokitUnitTest(unittest.TestCase):
         self.assertEqual(str(c), '[V]')
         self.assertEqual(str(d), '[V]')
 
+        # 1115: Test str() doesn't create representations with more than one
+        # multiplier.
+        unit1 = myokit.units.mol / (1e3 * myokit.units.g)
+        unit2 = 1e-12 * myokit.units.mol / (1e3 * myokit.units.g)
+        unit3 = 1e-6 * unit2
+        self.assertEqual(str(unit1), '[mol/g (0.001)]')
+        self.assertEqual(str(unit2), '[mol/g (1e-15)]')
+        # Before fixing 1115, this returned [mol/g (0.001) (1e-12)]
+        self.assertEqual(str(unit3), '[mol/g (1e-21)]')
+
     def test_repr(self):
         # Test :meth:`Unit.repr()`.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: myokit
-Version: 1.37.2
+Version: 1.37.4
 Summary: A modeling and simulation tool for cardiac cellular electrophysiology
 Home-page: http://myokit.org
 Author: Michael Clerx
@@ -123,7 +123,7 @@ A high-level plan for Myokit's future is provided in the [roadmap](./ROADMAP.md)
 ### Meet the team!
 
 Myokit's development is driven by a [team](https://github.com/orgs/myokit/people) at the Universities of Nottingham, Oxford, and Macao, led by Michael Clerx (Nottingham).
-It is guided by an external advisory board composed of Jordi Heijman (Maastricht University), Trine Krogh-Madsen (Weill Cornell Medicine), and David Gavaghan (Oxford).
+It is guided by an external advisory group composed of Jordi Heijman (Maastricht University), Trine Krogh-Madsen (Weill Cornell Medicine), and David Gavaghan (Oxford).
 
 
 ## Citing Myokit