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

myokit/tests/test_simulation_cvodes.py

@@ -5,9 +5,6 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import os
 import pickle
 import platform
@@ -26,12 +23,6 @@ from myokit.tests import (
     WarningCollector,
 )
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
 
 class SimulationTest(unittest.TestCase):
     """
@@ -80,6 +71,162 @@ class SimulationTest(unittest.TestCase):
         d2 = self.sim.run(5, log_interval=-5)
         self.assertEqual(d1.time(), d2.time())
 
+    def test_multiple_protocols(self):
+        # Test using multiple protocols
+
+        # Set up a model
+        model = myokit.Model()
+        c = model.add_component('c')
+        t = c.add_variable('t')
+        t.set_binding('time')
+        t.set_rhs(0)
+
+        a = c.add_variable('a')
+        a.set_binding('a')
+        a.set_rhs(0)
+        b = c.add_variable('b')
+        b.set_binding('b')
+        b.set_rhs(0)
+        y = c.add_variable('y')
+        y.promote(1)
+        y.set_rhs('-a * y - b * y')
+
+        # Create two overlapping protocols
+        pa = myokit.Protocol()
+        pa.schedule(level=1, start=0.2, duration=0.5)
+
+        pb = myokit.Protocol()
+        pb.schedule(level=2, start=0.5, duration=0.6)
+
+        # Run a simulation with both
+        s = myokit.Simulation(model, {'a': pa, 'b': pb})
+        s.set_tolerance(1e-8)
+        d = s.run(2).npview()
+        times = d[t]
+
+        # Check that the changing points are in the log
+        self.assertIn(0, times)
+        self.assertIn(0.2, times)
+        self.assertIn(0.5, times)
+        self.assertIn(0.7, times)
+        self.assertIn(1.1, times)
+        self.assertIn(2, times)
+
+        # Check that a, b, and y have the expected values
+        a_up = (times >= 0.2) & (times < 0.7)
+        np.testing.assert_array_equal(d[a], np.where(a_up, 1, 0))
+
+        b_up = (times >= 0.5) & (times < 1.1)
+        np.testing.assert_array_equal(d[b], np.where(b_up, 2, 0))
+
+        # Check that dy/dt has the expected values
+        # dy/dt =
+        #   0   from 0 to 0.2
+        #   -y  from 0.2 to 0.5
+        #   -3y from 0.5 to 0.7
+        #   -2y from 0.7 to 1.1
+        #   0   after 1.1
+        #
+        dy_expect = 0 * times
+        dy_expect[a_up] -= 1 * d[y][a_up]
+        dy_expect[b_up] -= 2 * d[y][b_up]
+        np.testing.assert_array_equal(d['dot(c.y)'], dy_expect)
+
+        # Check that y has the expected values
+        # The solution for dy/dt = -a*y is y(t) = c * exp(-at), so
+        # y =
+        #   1
+        #   exp(-(t - 0.5))
+        #   exp(-0.3) * exp(-3 * (t - 0.5))
+        #   exp(-0.9) * exp(-2 * (t - 0.7))
+        #   exp(-1.7)
+        #
+        y_expect = np.ones(times.shape)
+        i = (times >= 0.2) & (times < 0.5)
+        y_expect[i] = np.exp(-(times[i] - 0.2))
+        i = (times >= 0.5) & (times < 0.7)
+        y_expect[i] = np.exp(-0.3) * np.exp(-3 * (times[i] - 0.5))
+        i = (times >= 0.7) & (times < 1.1)
+        y_expect[i] = np.exp(-0.9) * np.exp(-2 * (times[i] - 0.7))
+        y_expect[times >= 1.1] = np.exp(-1.7)
+        np.testing.assert_array_almost_equal(d[y], y_expect, decimal=3)
+
+        # Test unsetting
+        s.set_protocol(None, label='a')
+        s.reset()
+        d = s.run(2).npview()
+        np.testing.assert_array_equal(d[a], np.zeros(d[a].shape))
+        times = d[t]
+        b_up = (times >= 0.5) & (times < 1.1)
+        np.testing.assert_array_equal(d[b], np.where(b_up, 2, 0))
+        y_expect = np.ones(times.shape)
+        i = (times >= 0.5) & (times < 1.1)
+        y_expect[i] = np.exp(-2 * (times[i] - 0.5))
+        y_expect[times >= 1.1] = np.exp(-1.2)
+        np.testing.assert_array_almost_equal(d[y], y_expect, decimal=3)
+
+        # Test unsetting
+        s.set_protocol(None, label='b')
+        s.reset()
+        d = s.run(2).npview()
+        np.testing.assert_array_equal(d[a], np.zeros(d[a].shape))
+        np.testing.assert_array_equal(d[a], np.zeros(d[a].shape))
+        np.testing.assert_array_equal(d[y], np.ones(d[a].shape))
+
+    def test_mixed_protocols(self):
+        # Test using a step and a time series protocol at the same time
+
+        # Set up a model
+        model = myokit.Model()
+        c = model.add_component('c')
+        t = c.add_variable('t')
+        t.set_binding('time')
+        t.set_rhs(0)
+        a = c.add_variable('a')
+        a.set_binding('a')
+        a.set_rhs(0)
+        b = c.add_variable('b')
+        b.set_binding('b')
+        b.set_rhs(0)
+        y = c.add_variable('y')  # Just to log more points
+        y.promote(1)
+        y.set_rhs('a + b')
+
+        # Set up protocols
+        pa = myokit.pacing.blocktrain(level=2, offset=1, duration=2, period=5)
+        x = np.linspace(0, 10, 100)
+        y = 0.1 + 0.2 * np.sin(x)
+        pb = myokit.TimeSeriesProtocol(x, y)
+
+        # Run a simulation with both
+        s = myokit.Simulation(model, {'a': pa, 'b': pb})
+        s.set_tolerance(1e-8)
+        d = s.run(12).npview()
+        t = d[t]
+
+        # Start, end, and change points visited exactly
+        self.assertIn(0, t)
+        self.assertIn(1, t)
+        self.assertIn(3, t)
+        self.assertIn(6, t)
+        self.assertIn(8, t)
+        self.assertIn(11, t)
+        self.assertIn(12, t)
+
+        # Test a
+        a_e = np.zeros(t.shape)
+        a_e[(t >= 1) & (t < 3)] = 2
+        a_e[(t >= 6) & (t < 8)] = 2
+        a_e[(t >= 11) & (t < 13)] = 2
+        np.testing.assert_array_equal(d[a], a_e)
+
+        # Test b
+        b_e = 0.1 + 0.2 * np.sin(t)
+        b_e[t > 10] = y[-1]
+        # Note: We don't expect a super good match here, as b_e is an exact
+        #       sine value, while the solver will be interpolating y
+        np.testing.assert_array_almost_equal(d[b], b_e, decimal=3)
+
     def test_no_protocol(self):
         # Test running without a protocol.
 
@@ -91,50 +238,74 @@ class SimulationTest(unittest.TestCase):
         # Check if pace was set to zero (see prop 651 / technical docs).
         self.assertTrue(np.all(d['engine.pace'] == 0.0))
 
-    def test_fixed_form_protocol(self):
-        # Test running with a fixed form protocol.
+    def test_wrong_label_set_pacing(self):
+        # Test set_pacing with incorrect label
+        self.sim.reset()
+        self.sim.pre(50)
+        with self.assertRaisesRegex(ValueError, 'Unknown pacing label'):
+            self.sim.set_protocol(None, label='does not exist')
+
+    def test_time_series_protocol(self):
+        # Test running with a time series protocol
 
         n = 10
-        time = list(range(n))
-        pace = [0] * n
-        pace[2:4] = [0.5, 0.5]
+        times = list(range(n))
+        values = [0] * n
+        values[2:4] = [0.5, 0.5]
+        p = myokit.TimeSeriesProtocol(times, values)
 
-        self.sim.set_fixed_form_protocol(time, pace)
+        self.sim.set_protocol(p)
         self.sim.reset()
         d = self.sim.run(n, log_interval=1)
-        self.assertEqual(list(d.time()), time)
-        self.assertEqual(list(d['engine.pace']), pace)
+        self.assertEqual(list(d.time()), times)
+        self.assertEqual(list(d['engine.pace']), values)
 
         # Unset
-        self.sim.set_fixed_form_protocol(None)
+        self.sim.set_protocol(None)
         self.sim.reset()
         d = self.sim.run(n, log_interval=1)
         self.assertEqual(list(d['engine.pace']), [0] * n)
 
         # Reset
-        self.sim.set_fixed_form_protocol(time, pace)
+        self.sim.set_protocol(p)
         self.sim.reset()
         d = self.sim.run(n, log_interval=1)
-        self.assertEqual(list(d.time()), time)
-        self.assertEqual(list(d['engine.pace']), pace)
+        self.assertEqual(list(d.time()), times)
+        self.assertEqual(list(d['engine.pace']), values)
 
         # Unset, replace with original protocol
         self.sim.set_protocol(self.protocol)
         self.sim.reset()
         d = self.sim.run(n, log_interval=1)
-        self.assertNotEqual(list(d['engine.pace']), pace)
+        self.assertNotEqual(list(d['engine.pace']), values)
         self.assertNotEqual(list(d['engine.pace']), [0] * n)
 
-        # Invalid protocols
-        self.assertRaisesRegex(
-            ValueError, 'no times', self.sim.set_fixed_form_protocol,
-            values=pace)
-        self.assertRaisesRegex(
-            ValueError, 'no values', self.sim.set_fixed_form_protocol,
-            times=time)
-        self.assertRaisesRegex(
-            ValueError, 'same size', self.sim.set_fixed_form_protocol,
-            time, pace[:-1])
+        # Deprecated version
+        with WarningCollector() as w:
+            self.sim.set_fixed_form_protocol(times, values)
+        self.assertIn('eprecated', w.text())
+        self.sim.reset()
+        d = self.sim.run(n, log_interval=1)
+        self.assertEqual(list(d.time()), times)
+        self.assertEqual(list(d['engine.pace']), values)
+        with WarningCollector() as w:
+            self.assertRaisesRegex(
+                ValueError, 'No times',
+                self.sim.set_fixed_form_protocol, values=values)
+            self.assertRaisesRegex(
+                ValueError, 'No values',
+                self.sim.set_fixed_form_protocol, times=times)
+            self.sim.set_fixed_form_protocol(None)
+        self.sim.reset()
+        d = self.sim.run(n, log_interval=1)
+        self.assertEqual(list(d['engine.pace']), [0] * n)
+
+        # Reset original protocol
+        self.sim.set_protocol(self.protocol)
+        self.sim.reset()
+        d = self.sim.run(n, log_interval=1)
+        self.assertNotEqual(list(d['engine.pace']), values)
+        self.assertNotEqual(list(d['engine.pace']), [0] * n)
 
     def test_in_parts(self):
         # Test running the simulation in parts.
@@ -154,6 +325,30 @@ class SimulationTest(unittest.TestCase):
         self.assertNotEqual(e['engine.time'][n - 1], e['engine.time'][n])
         self.assertGreater(e['engine.time'][n], e['engine.time'][n - 1])
 
+    def test_initial_value_expressions(self):
+        # Test if initial value expressions are converted to floats
+
+        m = myokit.parse_model('''
+            [[model]]
+            c.x = 1 + sqrt(3)
+            c.y = 1 / c.p
+            c.z = 3
+
+            [c]
+            t = 0 bind time
+            dot(x) = 1
+            dot(y) = 2
+            dot(z) = 3
+            p = log(3)
+        ''')
+        s = myokit.Simulation(m)
+        x = s.state()
+        self.assertIsInstance(x[0], float)
+        self.assertIsInstance(x[1], float)
+        self.assertIsInstance(x[2], float)
+        self.assertEqual(x, m.initial_values(True))
+        self.assertEqual(x, s.default_state())
+
     def test_pacing_values_at_event_transitions(self):
         # Tests the value of the pacing signal at event transitions
 
@@ -239,9 +434,34 @@ class SimulationTest(unittest.TestCase):
             progress=CancellingReporter(0))
 
     def test_apd_tracking(self):
-        # Test the APD calculation method.
+        # Test the APD / rootfinding method.
+        # Tested against offline method in test_datalog.py
 
-        # More testing is done in test_datalog.py!
+        # Test that it works
+        self.sim.reset()
+        res = self.sim.run(
+            1800, log=['engine.time', 'membrane.V'],
+            apd_variable='membrane.V', apd_threshold=-70)
+
+        self.assertIsInstance(res, tuple)
+        self.assertEqual(len(res), 2)
+        d, apds = res
+        self.assertIsInstance(d, myokit.DataLog)
+        self.assertIsInstance(apds, myokit.DataLog)
+        self.assertEqual(len(apds), 2)
+        self.assertEqual(apds.length(), 2)
+        self.assertIn('start', apds)
+        self.assertAlmostEqual(apds['start'][0], 1, places=0)
+        self.assertAlmostEqual(apds['start'][1], 1001, places=0)
+        self.assertIn('start', apds)
+        self.assertAlmostEqual(apds['duration'][0], 383.877194, places=1)
+        self.assertAlmostEqual(apds['duration'][1], 378.315915, places=1)
+
+        # Works with variable objects too
+        self.sim.reset()
+        res = self.sim.run(
+            1000, log=['engine.time', 'membrane.V'],
+            apd_variable=self.model.get('membrane.V'), apd_threshold=-70)
 
         # Apd var is not a state
         self.assertRaisesRegex(
@@ -335,12 +555,53 @@ class SimulationTest(unittest.TestCase):
         self.sim.set_state(s1)
         self.assertEqual(d1, self.sim.eval_derivatives())
 
-    def test_sensitivites_initial(self):
+    def test_eval_derivatives_with_pacing(self):
+        # Test :meth:`Simulation.eval_derivatives()`.
+
+        model = myokit.Model()
+        c = model.add_component('c')
+
+        a = c.add_variable('a')
+        a.set_binding('a')
+        a.set_rhs(0)
+        b = c.add_variable('b')
+        b.set_binding('b')
+        b.set_rhs(0)
+
+        y = c.add_variable('y')
+        t = c.add_variable('t')
+        t.set_binding('time')
+        t.set_rhs(0)
+        y.promote(1)
+        y.set_rhs('- a * y - b * y')
+
+        pa = myokit.Protocol()
+        pa.schedule(1, 0, 0.5)
+
+        pb = myokit.Protocol()
+        pb.schedule(2, 1.0, 0.5)
+
+        sim = myokit.Simulation(model, {'a': pa, 'b': pb})
+        sim.run(1)
+        d1 = sim.eval_derivatives(pacing={'a': 0.5, 'b': 0.5})
+        d2 = sim.eval_derivatives(pacing={'a': 1.5, 'b': 0.5})
+        self.assertNotEqual(d1, d2)
+        d1 = sim.eval_derivatives(pacing={'b': 0.5})
+        d2 = sim.eval_derivatives(pacing={'a': 0.0, 'b': 0.5})
+        self.assertEqual(d1, d2)
+        d1 = sim.eval_derivatives()
+        d2 = sim.eval_derivatives(pacing={'a': 0.0, 'b': 0.0})
+        self.assertEqual(d1, d2)
+        d1 = sim.eval_derivatives(pacing={'a': 0.0, 'b': 0.5})
+        d2 = sim.eval_derivatives(pacing={'aaaaa': 1.0, 'b': 0.5})
+        self.assertEqual(d1, d2)
+
+    def test_sensitivities_initial(self):
         # Test setting initial sensitivity values.
 
         m = myokit.parse_model('''
             [[model]]
-            e.y = 2.3
+            e.y = 1 + 1.3
 
             [e]
             t = 0 bind time
@@ -352,6 +613,26 @@ class SimulationTest(unittest.TestCase):
         #TODO: Test results
         s = myokit.Simulation(m, sensitivities=(['e.y'], ['e.p', 'init(e.y)']))
 
+        # Warn if a parameter sensitivity won't be picked up.
+        m = myokit.parse_model('''
+            [[model]]
+            c.x = 1 / c.p
+
+            [c]
+            t = 0 bind time
+            p = 1 / q
+            q = 5
+            r = 3
+            dot(x) = 2 + r
+            ''')
+        m.validate()
+        s = (['c.x'], ['c.q'])
+        self.assertRaisesRegex(
+            NotImplementedError, 'respect to parameters used in initial',
+            myokit.Simulation, m, sensitivities=s)
+        s = (['c.x'], ['c.r'])
+        s = myokit.Simulation(m, sensitivities=s)
+
         # Test bad initial matrix
         self.assertRaisesRegex(
             ValueError, 'None or a list',
@@ -539,8 +820,8 @@ class SimulationTest(unittest.TestCase):
             ''')
         m.validate()
 
-        x0 = m.get('e.x').state_value()
-        y0 = m.get('e.y').state_value()
+        x0 = m.get('e.x').initial_value(True)
+        y0 = m.get('e.y').initial_value(True)
         p = m.get('e.p').eval()
         q = m.get('e.q').eval()
         r = m.get('e.r').eval()
@@ -693,6 +974,7 @@ class SimulationTest(unittest.TestCase):
 
         # Literal
         self.sim.set_constant('cell.Na_i', 11)
+        self.sim.set_constant(self.model.get('cell.Na_i'), 11)
         self.assertRaises(KeyError, self.sim.set_constant, 'cell.Bert', 11)
 
         # Parameter (needs sensitivies set)
@@ -786,6 +1068,7 @@ class SimulationTest(unittest.TestCase):
         z.promote(0)
 
         # Test without protocol and dynamic logging
+        #myokit.DEBUG_WG = True
         s1 = myokit.Simulation(m1)
         d1 = s1.run(5)
         self.assertEqual(len(d1.time()), 2)
@@ -886,23 +1169,6 @@ class SimulationTest(unittest.TestCase):
         self.assertTrue(np.all(rt[1:] >= rt[:-1]))
         self.assertTrue(np.all(ev[1:] >= ev[:-1]))
 
-    def test_apd(self):
-        # Test the apd rootfinding routine
-
-        s = myokit.Simulation(self.model, self.protocol)
-        s.set_tolerance(1e-8, 1e-8)
-        d, apds = s.run(
-            1800, log=myokit.LOG_NONE,
-            apd_variable='membrane.V', apd_threshold=-70)
-
-        # Check with threshold equal to V
-        self.assertEqual(len(apds['start']), 2)
-        self.assertEqual(len(apds['duration']), 2)
-        self.assertAlmostEqual(apds['start'][0], 1.19, places=1)
-        self.assertAlmostEqual(apds['start'][1], 1001.19, places=1)
-        self.assertAlmostEqual(apds['duration'][0], 383.88262, places=1)
-        self.assertAlmostEqual(apds['duration'][1], 378.31448, places=1)
-
     def test_derivatives(self):
         # Tests logging of derivatives by comparing with a finite difference
         # approximation

myokit/tests/test_simulation_cvodes_from_disk.py

@@ -5,9 +5,6 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import os
 import unittest
 

myokit/tests/test_simulation_fiber_tissue.py

@@ -5,11 +5,9 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import os
 import unittest
+
 import numpy as np
 
 import myokit
@@ -21,13 +19,6 @@ from myokit.tests import (
     WarningCollector,
 )
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
-
 # Show simulation output
 debug = False
 
@@ -535,7 +526,7 @@ class FiberTissueSimulationTest(unittest.TestCase):
         m = self.mf.count_states()
         nx, ny = self.nfx, self.nfy
 
-        sm = self.mf.state()
+        sm = self.mf.initial_values(True)
         for i in range(nx):
             for j in range(ny):
                 self.assertEqual(sm, self.s1.fiber_state(i, j))
@@ -622,6 +613,42 @@ class FiberTissueSimulationTest(unittest.TestCase):
         finally:
             self.s1.reset()
 
+    def test_initial_value_expressions(self):
+        # Test if initial value expressions are converted to floats
+        m = myokit.parse_model('''
+            [[model]]
+            c.x = 1 + sqrt(3)
+            c.y = 1 / c.p
+            c.z = 3
+
+            [c]
+            t = 0 bind time
+            dot(x) = 1 label membrane_potential
+                in [mV]
+            dot(y) = 2
+            dot(z) = 3
+            p = log(3)
+            q = 0 bind diffusion_current
+                in [A/F]
+        ''')
+        s = myokit.FiberTissueSimulation(
+            m, m, ncells_fiber=(1, 1), ncells_tissue=(3, 1))
+        x = s.fiber_state()
+        self.assertIsInstance(x[0], float)
+        self.assertIsInstance(x[1], float)
+        self.assertIsInstance(x[2], float)
+        self.assertEqual(x, m.initial_values(True))
+        self.assertEqual(x, s.default_fiber_state())
+
+        x = s.tissue_state()
+        self.assertIsInstance(x[0], float)
+        self.assertIsInstance(x[1], float)
+        self.assertIsInstance(x[2], float)
+        self.assertEqual(x[:3], x[3:6])
+        self.assertEqual(x[:3], x[6:])
+        self.assertEqual(x, m.initial_values(True) * 3)
+        self.assertEqual(x, s.default_tissue_state())
+
     def test_tissue_state(self):
         # Test the set_tissue_state and set_default_tissue_state methods
 
@@ -629,7 +656,7 @@ class FiberTissueSimulationTest(unittest.TestCase):
         m = self.mt.count_states()
         nx, ny = self.ntx, self.nty
 
-        sm = self.mt.state()
+        sm = self.mt.initial_values(True)
         for i in range(nx):
             for j in range(ny):
                 self.assertEqual(sm, self.s1.tissue_state(i, j))