myokit 1.35.0__py3-none-any.whl → 1.35.2__py3-none-any.whl

myokit/tests/test_formats_wcp.py

@@ -10,9 +10,77 @@ import unittest
 
 import numpy as np
 
+import myokit
 import myokit.formats.wcp as wcp
 
-from myokit.tests import DIR_FORMATS
+from myokit.tests import DIR_FORMATS, WarningCollector
+
+
+INFO = '''
+WinWCP file: wcp-file.wcp
+WinWCP Format version 9
+Recorded on: 21/11/2014 14:18:28
+  Number of records: 11
+  Channels per record: 2
+  Samples per channel: 256
+  Sampling interval: 0.001 s
+A/D channel: Im
+  Unit: pA
+A/D channel: Vm
+  Unit: mV
+Records: Type, Status, Sampling Interval, Start, Marker
+Record 0: TEST, ACCEPTED, 0.0, ""
+Record 1: TEST, ACCEPTED, 0.5, ""
+Record 2: TEST, ACCEPTED, 1.0, ""
+Record 3: TEST, ACCEPTED, 1.5, ""
+Record 4: TEST, ACCEPTED, 2.0615234375, ""
+Record 5: TEST, ACCEPTED, 3.0615234375, ""
+Record 6: TEST, ACCEPTED, 3.5615234375, ""
+Record 7: TEST, ACCEPTED, 4.0615234375, ""
+Record 8: TEST, ACCEPTED, 4.5615234375, ""
+Record 9: TEST, ACCEPTED, 5.125, ""
+Record 10: TEST, ACCEPTED, 5.625, ""
+'''.strip()
+
+
+INFO_LONG = INFO + '''
+----------------------------------- header -----------------------------------
+ver: 9
+ctime: 21/11/2014 12:43:08
+rtime: 21/11/2014 14:18:28
+nbh: 1024
+adcmax: 32677
+nc: 2
+nba: 2
+nbd: 2
+ad: 10.0
+nr: 11
+dt: 0.001
+nz: 20
+id: ''' + '''
+--------------------------------- raw header ---------------------------------
+rtimesecs: 9062.11
+yo0: 0
+yu0: pA
+yn0: Im
+yg0: 0.0005
+yz0: 0
+yr0: 0
+yo1: 1
+yu1: mV
+yn1: Vm
+yg1: 0.01
+yz1: 0
+yr1: 0
+txperc: 0
+pkpavg: 1
+nsvchan: 0
+nsvalign: 0
+nsvtypr: 0
+nsvs2p: F
+nsvcur0: 0
+nsvcur1: 0
+'''.rstrip()
 
 
 class WcpTest(unittest.TestCase):
@@ -23,43 +91,144 @@ class WcpTest(unittest.TestCase):
     def test_data_file(self):
         # Test basic wcp file reading.
 
-        # Load old file from Maastricht
+        # Load test file
         fname = 'wcp-file.wcp'
         path = os.path.join(DIR_FORMATS, fname)
         w = wcp.WcpFile(path)
+        self.assertEqual(w.version(), '9')
 
-        self.assertEqual(w.channels(), 2)
-        self.assertEqual(w.channel_names(), ['Im', 'Vm'])
         self.assertEqual(w.filename(), fname)
         self.assertEqual(w.path(), path)
-        self.assertEqual(w.records(), 11)
-        #print(w.sampling_interval())
+        self.assertEqual(w.record_count(), 11)
+        self.assertEqual(w.sample_count(), 256)
         self.assertEqual(len(w.times()), 256)
         self.assertEqual(len(w.values(0, 0)), 256)
 
-    def test_data_log_conversion(self):
-        # Test conversion to a data log.
+        # Test meta data
+        self.maxDiff = None
+        self.assertEqual(w.meta_str(), INFO)
+        self.assertEqual(w.meta_str(True), INFO_LONG)
+        with WarningCollector() as c:
+            self.assertEqual(w.info(), INFO)
+        self.assertIn('deprecated', c.text())
 
-        w = wcp.WcpFile(os.path.join(DIR_FORMATS, 'wcp-file.wcp'))
-        d = w.myokit_log()
-        keys = ['time']
-        for cn in w.channel_names():
-            for i in range(w.records()):
-                keys.append(str(i) + '.' + cn)
-        self.assertEqual(set(d.keys()), set(keys))
-        self.assertEqual(len(d.time()), 256)
-        self.assertTrue(np.all(d.time() == w.times()))
-
-    def test_plot_method(self):
-        # Test the plot method.
+        # Test Sequence interface
+        self.assertEqual(len(w), w.record_count())
+        self.assertEqual(np.array(w[0]).shape, (2, 256))
+        self.assertEqual(len([r for r in w]), w.record_count())
+
+        # Test SweepSource interface
+        self.assertEqual(w.channel_count(), 2)
+        self.assertEqual(w.channel_names(), ['Im', 'Vm'])
+        self.assertEqual(w.channel_units(), [myokit.units.pA, myokit.units.mV])
+        self.assertEqual(w.channel_names(0), 'Im')
+        self.assertEqual(w.channel_names(1), 'Vm')
+        self.assertEqual(w.channel_units(0), myokit.units.pA)
+        self.assertEqual(w.channel_units(1), myokit.units.mV)
+        self.assertEqual(w.sweep_count(), w.record_count())
+        self.assertTrue(w.equal_length_sweeps())
+        self.assertEqual(w.time_unit(), myokit.units.s)
+
+        # Test SweepSource.channel()
+        # Without joining
+        t0, v0 = w.channel(0)
+        t1, v1 = w.channel(1)
+        self.assertEqual(len(t0), len(t1), w.sweep_count())
+        self.assertEqual(len(v0), len(v1), w.sweep_count())
+        self.assertEqual(len(t0[0]), w.sample_count())
+        self.assertEqual(len(t1[1]), w.sample_count())
+        self.assertEqual(len(v0[2]), w.sample_count())
+        self.assertEqual(len(v1[3]), w.sample_count())
+        self.assertTrue(np.all(v0[0] == w.channel('Im')[1][0]))
+        self.assertTrue(np.all(v0[0] != w.channel('Vm')[1][0]))
+        self.assertTrue(np.all(v1[1] == w.channel('Vm')[1][1]))
+
+        # With joining
+        x = w.channel(0, join_sweeps=True)
+        y = w.channel(1, join_sweeps=True)
+        self.assertEqual(len(x), len(y), 2)
+        self.assertEqual(len(x[0]), w.sample_count() * w.sweep_count())
+        self.assertEqual(len(x[0]), len(x[1]))
+        self.assertEqual(len(x[0]), len(y[0]), len(y[1]))
+        self.assertTrue(np.all(x[1] == w.channel('Im', True)[1]))
+        self.assertTrue(np.all(x[1] != w.channel('Vm', True)[1]))
+        self.assertTrue(np.all(y[1] == w.channel('Vm', True)[1]))
+
+        # Channel doesn't exist
+        self.assertRaises(IndexError, w.channel, -1)
+        self.assertRaises(IndexError, w.channel, 2)
+        self.assertRaises(KeyError, w.channel, 'Tom')
 
+        # Conversion to log
+        # Without joining
+        d = w.log()
+        k = ['time']
+        for r in range(w.record_count()):
+            for c in range(w.channel_count()):
+                k.append(f'{r}.{c}.channel')
+        self.assertEqual(set(k), set(d.keys()))
+        self.assertTrue(np.all(d['time'] == w.channel(0)[0][0]))
+        self.assertTrue(np.all(d['1.0.channel'] == w.channel(0)[1][1]))
+
+        # Without joining, use names
+        d = w.log(use_names=True)
+        k = ['time']
+        for c in w.channel_names():
+            for r in range(w.record_count()):
+                k.append(f'{r}.{c}')
+        self.assertEqual(set(k), set(d.keys()))
+        self.assertTrue(np.all(d['time'] == w.channel(0)[0][0]))
+        self.assertTrue(np.all(d['1.Im'] == w.channel(0)[1][1]))
+
+        # With joining
+        d = w.log(join_sweeps=True)
+        self.assertEqual(list(d.keys()), ['time', '0.channel', '1.channel'])
+        self.assertTrue(np.all(d['time'] == w.channel(0, True)[0]))
+        self.assertTrue(np.all(d['0.channel'] == w.channel(0, True)[1]))
+
+        # With joining, use names
+        d = w.log(join_sweeps=True, use_names=True)
+        self.assertEqual(list(d.keys()), ['time', 'Im', 'Vm'])
+        self.assertTrue(np.all(d['time'] == w.channel(0, True)[0]))
+        self.assertTrue(np.all(d['Vm'] == w.channel(1, True)[1]))
+
+        # Deprecated methods
+        with WarningCollector() as c:
+            self.assertEqual(w.records(), w.record_count())
+        self.assertIn('deprecated', c.text())
+        with WarningCollector() as c:
+            self.assertEqual(w.channels(), w.channel_count())
+        self.assertIn('deprecated', c.text())
+        with WarningCollector() as c:
+            e = w.myokit_log()
+        self.assertIn('deprecated', c.text())
+
+        # Unsupported da methods
+        self.assertEqual(w.da_count(), 0)
+        self.assertRaises(NotImplementedError, w.da, 0)
+        self.assertRaises(NotImplementedError, w.da_names)
+        self.assertRaises(NotImplementedError, w.da_units)
+        self.assertRaises(NotImplementedError, w.da_protocol)
+
+    def test_figure_method(self):
+        # Tests matplotlib_figure
         # Select matplotlib backend that doesn't require a screen
         import matplotlib
         matplotlib.use('template')
+        w = wcp.WcpFile(os.path.join(DIR_FORMATS, 'wcp-file.wcp'))
+        f = w.matplotlib_figure()
+        self.assertIsInstance(f, matplotlib.figure.Figure)
 
-        # Load and create plots
+    def test_figure_method_deprecated(self):
+        # Tests matplotlib_figure
+        # Select matplotlib backend that doesn't require a screen
+        import matplotlib
+        matplotlib.use('template')
         w = wcp.WcpFile(os.path.join(DIR_FORMATS, 'wcp-file.wcp'))
-        w.plot()
+        with WarningCollector() as c:
+            f = w.plot()
+        self.assertIn('deprecated', c.text())
+        self.assertIsNone(f, matplotlib.figure.Figure)
 
 
 if __name__ == '__main__':

myokit/tests/test_pacing_system_c.py

@@ -11,7 +11,7 @@ import numpy as np
 import myokit
 
 from myokit.tests.ansic_event_based_pacing import AnsicEventBasedPacing
-from myokit.tests.ansic_fixed_form_pacing import AnsicFixedFormPacing
+from myokit.tests.ansic_time_series_pacing import AnsicTimeSeriesPacing
 
 
 class EventBasedPacingAnsicTest(unittest.TestCase):
@@ -96,12 +96,30 @@ class EventBasedPacingAnsicTest(unittest.TestCase):
         s = myokit.Simulation(m, p)
         self.assertRaises(myokit.SimultaneousProtocolEventError, s.run, 40)
 
+    def test_negative_time(self):
+        # Test starting from a negative time
 
-class FixedFormPacingAnsicTest(unittest.TestCase):
+        p = myokit.pacing.blocktrain(level=1, duration=1, period=2)
+        s = AnsicEventBasedPacing(p, initial_time=-100)
+        self.assertEqual(s.time(), -100)
+        self.assertEqual(s.next_time(), 0)
+        self.assertEqual(s.pace(), 0)
+
+        p = myokit.pacing.blocktrain(level=1, duration=1, period=2, offset=1)
+        s = AnsicEventBasedPacing(p, initial_time=-100)
+        self.assertEqual(s.time(), -100)
+        self.assertEqual(s.next_time(), 1)
+        self.assertEqual(s.pace(), 0)
+        s.advance(s.next_time())
+        self.assertEqual(s.time(), 1)
+        self.assertEqual(s.pace(), 1)
+
+
+class TimeSeriesPacingAnsicTest(unittest.TestCase):
     """
-    Test the Ansi-C fixed-form pacing system (aka point-list, aka data-clamp).
+    Test the Ansi-C time-series pacing system (aka point-list, aka data-clamp).
     """
-    def test_fixed_form_pacing_ansic(self):
+    def test_time_series_pacing_ansic(self):
         # Tests if the basics work
 
         if False:
@@ -136,27 +154,37 @@ class FixedFormPacingAnsicTest(unittest.TestCase):
             sys.exit(1)
 
         # Test with small lists
-        values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
         times = [0, 0, 1, 1, 1, 2, 2, 2, 3, 4, 5, 7]
         values = list(range(len(times)))
-        pacing = AnsicFixedFormPacing(myokit.TimeSeriesProtocol(times, values))
-
-        def test(value, index):
-            self.assertEqual(pacing.pace(value), index)
-
-        test(-1, 0)
-        test(0, 1)
-        test(1, 2)
-        test(2, 5)
-        test(3, 8)
-        test(4, 9)
-        test(5, 10)
-        test(7, 11)
-        test(8, 11)
-        test(1.5, 4.5)
-        test(1.75, 4.75)
-        test(6, 10.5)
-        test(5.5, 10.25)
+        pacing = AnsicTimeSeriesPacing(
+            myokit.TimeSeriesProtocol(times, values))
+
+        self.assertEqual(pacing.pace(-1), 0)
+        self.assertEqual(pacing.pace(0), 1)
+        self.assertEqual(pacing.pace(1), 2)
+        self.assertEqual(pacing.pace(2), 5)
+        self.assertEqual(pacing.pace(3), 8)
+        self.assertEqual(pacing.pace(4), 9)
+        self.assertEqual(pacing.pace(5), 10)
+        self.assertEqual(pacing.pace(7), 11)
+        self.assertEqual(pacing.pace(8), 11)
+        self.assertEqual(pacing.pace(1.5), 4.5)
+        self.assertEqual(pacing.pace(1.75), 4.75)
+        self.assertEqual(pacing.pace(6), 10.5)
+        self.assertEqual(pacing.pace(5.5), 10.25)
+
+        # Test not starting at 0
+        times = [1, 2]
+        values = [10, 20]
+        pacing = AnsicTimeSeriesPacing(
+            myokit.TimeSeriesProtocol(times, values))
+
+        self.assertEqual(pacing.pace(-1), 10)
+        self.assertEqual(pacing.pace(0), 10)
+        self.assertEqual(pacing.pace(1), 10)
+        self.assertEqual(pacing.pace(2), 20)
+        self.assertEqual(pacing.pace(3), 20)
+        self.assertEqual(pacing.pace(1.5), 15)
 
 
 if __name__ == '__main__':

myokit/tests/test_pacing_system_py.py

@@ -89,6 +89,24 @@ class EventBasedPacingPythonTest(unittest.TestCase):
         m = str(e.exception)
         self.assertEqual(float(m[2 + m.index('t='):-1]), 3000)
 
+    def test_negative_time(self):
+        # Test starting from a negative time
+
+        p = myokit.pacing.blocktrain(level=1, duration=1, period=2)
+        s = myokit.PacingSystem(p, initial_time=-100)
+        self.assertEqual(s.time(), -100)
+        self.assertEqual(s.next_time(), 0)
+        self.assertEqual(s.pace(), 0)
+
+        p = myokit.pacing.blocktrain(level=1, duration=1, period=2, offset=1)
+        s = myokit.PacingSystem(p, initial_time=-100)
+        self.assertEqual(s.time(), -100)
+        self.assertEqual(s.next_time(), 1)
+        self.assertEqual(s.pace(), 0)
+        s.advance(s.next_time())
+        self.assertEqual(s.time(), 1)
+        self.assertEqual(s.pace(), 1)
+
 
 if __name__ == '__main__':
     unittest.main()

myokit/tests/test_simulation_1d.py

@@ -53,10 +53,6 @@ class Simulation1dTest(unittest.TestCase):
         s.pre(1)
         self.assertNotEqual(s.default_state(0), x0)
 
-        # Test running without a protocol
-        s.set_protocol(None)
-        s.run(1)
-
         # Simulation time can't be negative
         self.assertRaises(ValueError, s.run, -1)
 
@@ -121,26 +117,49 @@ class Simulation1dTest(unittest.TestCase):
         self.assertEqual(x, m.initial_values(True) * 2)
         self.assertEqual(x, s.default_state())
 
-    def test_with_progress_reporter(self):
-        # Test running with a progress reporter.
-        m, p, _ = myokit.load(os.path.join(DIR_DATA, 'lr-1991.mmt'))
+    def test_negative_time(self):
+        # Test starting at a negative time
 
-        # Test using a progress reporter
-        s = myokit.Simulation1d(m, p, ncells=5)
-        s.set_step_size(0.05)
-        with myokit.tools.capture() as c:
-            s.run(110, progress=myokit.ProgressPrinter())
-        c = c.text().splitlines()
-        self.assertTrue(len(c) > 0)
-
-        # Not a progress reporter
-        self.assertRaisesRegex(
-            ValueError, 'ProgressReporter', s.run, 5, progress=12)
+        m = myokit.load_model(os.path.join(DIR_DATA, 'lr-1991.mmt'))
+        p = myokit.pacing.blocktrain(duration=1, level=1, period=2)
+        n = 4
+        s = myokit.Simulation1d(m, p, ncells=n)
+
+        s.set_time(-10)
+        self.assertEqual(s.time(), -10)
+        d = s.run(5, log=['engine.pace']).npview()
+        self.assertEqual(s.time(), -5)
+        self.assertTrue(np.all(d['engine.pace'] == 0))
+        d = s.run(6, log=['engine.time', 'engine.pace']).npview()
+        #print(d['engine.time'])
+        #print(d['engine.pace'])
+        self.assertEqual(s.time(), 1)
+        self.assertTrue(np.all(d['engine.pace'][:-1] == 0))
+        self.assertEqual(d['engine.pace'][-1], 1)
+
+    def test_no_protocol(self):
+        # Test running without a protocol
+        m = myokit.load_model(os.path.join(DIR_DATA, 'lr-1991.mmt'))
+        x = 0.123
+        m.get('engine.pace').set_rhs(x)
+        n = 4
 
-        # Cancel from reporter
-        self.assertRaises(
-            myokit.SimulationCancelledError, s.run, 1,
-            progress=CancellingReporter(0))
+        # Create without a protocol
+        s = myokit.Simulation1d(m, ncells=n)
+        d = s.run(10, log=['engine.pace']).npview()
+        self.assertIn('engine.pace', d.keys())
+        self.assertTrue(np.all(d['engine.pace'] == 0))
+
+        # Set, then unset
+        y = 0.101
+        p = myokit.pacing.blocktrain(level=y, duration=100, period=100)
+        s.set_protocol(p)
+        d = s.run(5, log=['engine.pace']).npview()
+        self.assertTrue(np.all(d['engine.pace'] == y))
+        self.assertGreater(len(d['engine.pace']), 1)
+        s.set_protocol(None)
+        d = s.run(5, log=['engine.pace']).npview()
+        self.assertTrue(np.all(d['engine.pace'] == 0))
 
     def test_set_state(self):
         # Test :meth:`Simulation1d.set_state()`.
@@ -218,6 +237,27 @@ class Simulation1dTest(unittest.TestCase):
         self.assertRaises(ValueError, s.default_state, -1)
         self.assertRaises(ValueError, s.default_state, n)
 
+    def test_with_progress_reporter(self):
+        # Test running with a progress reporter.
+        m, p, _ = myokit.load(os.path.join(DIR_DATA, 'lr-1991.mmt'))
+
+        # Test using a progress reporter
+        s = myokit.Simulation1d(m, p, ncells=5)
+        s.set_step_size(0.05)
+        with myokit.tools.capture() as c:
+            s.run(110, progress=myokit.ProgressPrinter())
+        c = c.text().splitlines()
+        self.assertTrue(len(c) > 0)
+
+        # Not a progress reporter
+        self.assertRaisesRegex(
+            ValueError, 'ProgressReporter', s.run, 5, progress=12)
+
+        # Cancel from reporter
+        self.assertRaises(
+            myokit.SimulationCancelledError, s.run, 1,
+            progress=CancellingReporter(0))
+
     def test_against_cvode(self):
         # Compare the Simulation1d output with CVODE output
 

myokit/tests/test_simulation_cvodes.py

@@ -227,16 +227,65 @@ class SimulationTest(unittest.TestCase):
         #       sine value, while the solver will be interpolating y
         np.testing.assert_array_almost_equal(d[b], b_e, decimal=3)
 
+    def test_negative_time(self):
+        # Test starting at a negative time
+
+        self.sim.reset()
+        self.sim.set_protocol(
+            myokit.pacing.blocktrain(duration=1, level=1, period=2))
+        self.sim.set_time(-10)
+        self.assertEqual(self.sim.time(), -10)
+        d = self.sim.run(5, log=['engine.pace']).npview()
+        self.assertEqual(self.sim.time(), -5)
+        self.assertTrue(np.all(d['engine.pace'] == 0))
+        d = self.sim.run(5, log=['engine.pace']).npview()
+        self.assertEqual(self.sim.time(), 0)
+        self.assertTrue(np.all(d['engine.pace'][:-1] == 0))
+        self.assertEqual(d['engine.pace'][-1], 1)
+        self.sim.set_protocol(self.protocol)
+
     def test_no_protocol(self):
         # Test running without a protocol.
 
+        # Check if pace was set to zero (see technical notes).
         self.sim.reset()
         self.sim.pre(50)
         self.sim.set_protocol(None)
-        d = self.sim.run(50).npview()
+        d = self.sim.run(50, log=['engine.pace']).npview()
+        self.assertTrue(np.all(d['engine.pace'] == 0))
 
-        # Check if pace was set to zero (see prop 651 / technical docs).
-        self.assertTrue(np.all(d['engine.pace'] == 0.0))
+        # Defined at the start? Then still counts as bound
+        self.assertRaisesRegex(
+            ValueError, 'not a literal',
+            self.sim.set_constant, 'engine.pace', 1)
+
+        # Check that pace is reset to zero when protocol is removed
+        x = 0.01    # Note: Must be low to stop sim crashing :D
+        self.sim.set_protocol(
+            myokit.pacing.blocktrain(duration=1000, level=x, period=1000))
+        d = self.sim.run(5, log=['engine.pace']).npview()
+        self.assertTrue(np.all(d['engine.pace'] == x))
+        self.sim.set_protocol(None)
+        d = self.sim.run(5, log=['engine.pace']).npview()
+        self.assertTrue(np.all(d['engine.pace'] == 0))
+        self.sim.set_protocol(self.protocol)
+
+        # No protocol set from the start? Then "pace" is set anyway for
+        # backwards compatibility
+        m = self.model.clone()
+        m.get('engine.pace').set_rhs(x)
+        s = myokit.Simulation(m)
+        d = s.run(50).npview()
+        self.assertIn('engine.pace', d.keys())
+        self.assertTrue(np.all(d['engine.pace'] == 0))
+
+        # But if user explicitly says no labels, then pace isn't treated in a
+        # special way.
+        s = myokit.Simulation(m, {})
+        self.assertRaises(ValueError, s.set_protocol, self.protocol)
+        d = s.run(50).npview()
+        self.assertNotIn('engine.pace', d.keys())
+        #self.assertTrue(np.all(d['engine.pace'] == x))  constant is not logged
 
     def test_wrong_label_set_pacing(self):
         # Test set_pacing with incorrect label

myokit/tests/test_simulation_fiber_tissue.py

@@ -383,6 +383,27 @@ class FiberTissueSimulationTest(unittest.TestCase):
             ValueError, 'diffusion current must have the same unit',
             FT, mf, m2)
 
+    def test_negative_time(self):
+        # Test starting at a negative time
+
+        p = myokit.pacing.blocktrain(duration=1, level=1, period=2)
+        self.s0.reset()
+        self.s0.set_protocol(p)
+        self.s0.set_time(-10)
+        self.assertEqual(self.s0.time(), -10)
+        df, dt = self.s0.run(5, logf=['engine.pace'], logt=myokit.LOG_NONE)
+        df = df.npview()
+        self.assertEqual(self.s0.time(), -5)
+        self.assertTrue(np.all(df['engine.pace'] == 0))
+        df, dt = self.s0.run(
+            6, logf=['engine.time', 'engine.pace'], logt=myokit.LOG_NONE)
+        df = df.npview()
+        #print(d['engine.time'])
+        #print(d['engine.pace'])
+        self.assertEqual(self.s0.time(), 1)
+        self.assertTrue(np.all(df['engine.pace'][:-1] == 0))
+        self.assertEqual(df['engine.pace'][-1], 1)
+
     def test_pre_reset(self):
         # Tests getting/setting of states and time, and use of pre() and run()
         try:
@@ -468,15 +489,25 @@ class FiberTissueSimulationTest(unittest.TestCase):
             self.assertGreater(df['membrane.V', 0, 0][-1], 0)
             self.s0.reset()
 
-            # Unset protocol, check Vm stays low
+            # Run with constant proto
+            x = 0.0123
+            self.s0.set_protocol(
+                myokit.pacing.blocktrain(level=x, duration=1000, period=1000))
+            self.s0.reset()
+            df, dt = self.s0.run(3, logf=['engine.pace'])
+            df = df.npview()
+            self.assertTrue(np.all(df['engine.pace'] == x))
+
+            # Unset: Must now be zero
             self.s0.set_protocol(None)
-            df, dt = self.s0.run(
-                5, logf=['membrane.V'], logt=myokit.LOG_NONE, log_interval=1)
-            self.assertLess(df['membrane.V', 0, 0][-1], 0)
             self.s0.reset()
+            df, dt = self.s0.run(3, logf=['engine.pace'])
+            df = df.npview()
+            self.assertTrue(np.all(df['engine.pace'] == 0))
 
             # Reset protocol, check Vm goes high
             self.s0.set_protocol(self.p)
+            self.s0.reset()
             df, dt = self.s0.run(
                 5, logf=['membrane.V'], logt=myokit.LOG_NONE, log_interval=1)
             self.assertGreater(df['membrane.V', 0, 0][-1], 0)

myokit/tests/test_simulation_opencl.py

@@ -682,6 +682,24 @@ class SimulationOpenCLTest(unittest.TestCase):
         self.assertEqual(x, m.initial_values(True) * 2)
         self.assertEqual(x, s.default_state())
 
+    def test_negative_time(self):
+        # Test starting at a negative time
+
+        p = myokit.pacing.blocktrain(duration=1, level=1, period=2)
+        self.s0.reset()
+        self.s0.set_protocol(p)
+        self.s0.set_time(-10)
+        self.assertEqual(self.s0.time(), -10)
+        d = self.s0.run(5, log=['engine.pace']).npview()
+        self.assertEqual(self.s0.time(), -5)
+        self.assertTrue(np.all(d['engine.pace'] == 0))
+        d = self.s0.run(6, log=['engine.time', 'engine.pace']).npview()
+        #print(d['engine.time'])
+        #print(d['engine.pace'])
+        self.assertEqual(self.s0.time(), 1)
+        self.assertTrue(np.all(d['engine.pace'][:-1] == 0))
+        self.assertEqual(d['engine.pace'][-1], 1)
+
     def test_neighbors_0d(self):
         # Test listing neighbors in a 0d simulation
 
@@ -813,11 +831,19 @@ class SimulationOpenCLTest(unittest.TestCase):
         self.assertEqual(np.max(d0['engine.pace']), 1)
 
         try:
-            # Unset protocol
+            # Make pace high
+            x = 0.0123
+            self.s0.set_protocol(
+                myokit.pacing.blocktrain(level=x, duration=1000, period=1000))
+            self.s0.reset()
+            d0 = self.s0.run(3, log=['engine.pace']).npview()
+            self.assertTrue(np.all(d0['engine.pace'] == x))
+
+            # Unset protocol: pace must now be 0
             self.s0.reset()
             self.s0.set_protocol(None)
             d0 = self.s0.run(3, log=['engine.pace']).npview()
-            self.assertEqual(np.max(d0['engine.pace']), 0)
+            self.assertTrue(np.all(d0['engine.pace'] == 0))
 
             # Add new protocol
             p = myokit.pacing.blocktrain(period=1000, duration=2, offset=3)
@@ -874,8 +900,6 @@ class SimulationOpenCLTest(unittest.TestCase):
             self.assertEqual(self.s0.time(), 10)
             self.s0.run(1)
             self.assertEqual(self.s0.time(), 11)
-            self.assertRaisesRegex(
-                ValueError, 'negative', self.s0.set_time, -1)
 
             # Test running for a negative amount of time
             self.assertRaisesRegex(

{myokit-1.35.0.dist-info → myokit-1.35.2.dist-info}/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-2022 University of Nottingham. All rights reserved.
+Copyright (c) 2020-2023 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: