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

myokit/tests/test_simulation_opencl_log_interval.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

myokit/tests/test_simulation_opencl_vs_cvode.py

@@ -5,24 +5,15 @@
 # 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
 
 from myokit.tests import OpenCL_DOUBLE_PRECISION, DIR_DATA
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
-
 # Show simulation output
 debug = False
 

myokit/tests/test_simulation_opencl_vs_sim1d.py

@@ -5,24 +5,15 @@
 # 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
 
 from myokit.tests import OpenCL_DOUBLE_PRECISION, DIR_DATA
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
-
 # Show simulation output
 debug = False
 

myokit/tests/test_system_info.py

@@ -5,21 +5,11 @@
 # 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 unittest
 
 import myokit
 
 
-# Strings in Python2 and Python3
-try:
-    basestring
-except NameError:   # pragma: no cover
-    basestring = str
-
-
 class SystemInfoTest(unittest.TestCase):
     """
     Tests the system info method.
@@ -29,7 +19,7 @@ class SystemInfoTest(unittest.TestCase):
         import matplotlib
         matplotlib.use('template')
 
-        self.assertIsInstance(myokit.system(), basestring)
+        self.assertIsInstance(myokit.system(), str)
         with myokit.tools.capture():
             myokit.system(live_printing=True)
 

myokit/tests/test_tools.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 re
 import sys
@@ -15,12 +12,6 @@ import threading
 import time
 import unittest
 
-# Strings in Python2 and Python3
-try:
-    basestring
-except NameError:   # pragma: no cover
-    basestring = str
-
 import myokit
 
 from myokit.tests import TemporaryDirectory

myokit/tests/test_unit.py

@@ -5,19 +5,10 @@
 # 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 unittest
 
 import myokit
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
 
 class MyokitUnitTest(unittest.TestCase):
 
@@ -79,7 +70,7 @@ class MyokitUnitTest(unittest.TestCase):
         self.assertFalse(myokit.Unit.close(not_pF2, pF2))
         self.assertFalse(myokit.Unit.close(pF2, not_pF2))
 
-        # The next test is not a requirement, but tests the current behaviour:
+        # The next test is not a requirement, but tests the current behavior:
         u = myokit.units.m * 1.000000001
         self.assertTrue(myokit.Unit.close(u, myokit.units.m))
 

myokit/tests/test_user_functions.py

@@ -5,19 +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 unittest
 import myokit
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
-
 # Further testing in test_model.py
 
 

myokit/tests/test_variable.py

@@ -5,25 +5,20 @@
 # 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 unittest
 
-import myokit
 import numpy as np
-import unittest
 
+import myokit
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
+from myokit.tests import WarningCollector
 
 
 class VariableTest(unittest.TestCase):
     """
     Tests parts of :class:`myokit.Variable`.
     """
+
     def test_clamp(self):
         # Tests clamping a variable to a fixed value
         m = myokit.parse_model("""
@@ -92,7 +87,7 @@ class VariableTest(unittest.TestCase):
         # Clamp simple state
         g = m.get('z.g')
         self.assertTrue(g.is_state())
-        self.assertTrue(g.state_value() != 10)
+        self.assertNotEqual(g.initial_value(True), 10)
         self.assertEqual(g.unit(), myokit.units.m)
         self.assertEqual(g.rhs().unit(), myokit.units.m / myokit.units.s)
         self.assertEqual(m.count_states(), 3)
@@ -158,6 +153,7 @@ class VariableTest(unittest.TestCase):
         m = myokit.parse_model("""
             [[model]]
             membrane.V = -83
+            membrane.w = 10
 
             [env]
             t = 0 [ms] bind time
@@ -168,6 +164,8 @@ class VariableTest(unittest.TestCase):
                 in [mV]
             dotv = 5 [mV/ms] + dot(V)
                 in [mV/ms]
+            dot(w) = 0.1 [mg/ms]
+                in [mg]
 
             [cell]
             Cm = 0.123 [uF]
@@ -194,7 +192,7 @@ class VariableTest(unittest.TestCase):
         v.convert_unit('mV')
         self.assertEqual(code, m.code())
 
-        # Convert state
+        # Convert state (note: initial value is treated as PrefixMinus expr!)
         vdot = v.rhs().eval()
         self.assertNotEqual(v.unit(), myokit.units.V)
         v.convert_unit('V')
@@ -205,6 +203,28 @@ class VariableTest(unittest.TestCase):
         self.assertEqual(vdot, v.rhs().eval())
         m.check_units(myokit.UNIT_STRICT)
 
+        # Check units of the initial value have been converted
+        self.assertEqual(v.initial_value(True), -0.083)
+        # Not sure if this one is desirable, but -83 is parsed as the
+        # expression -(83)
+        self.assertEqual(
+            v.initial_value(),
+            myokit.Multiply(
+                myokit.PrefixMinus(myokit.Number(83)),
+                myokit.Number(0.001, myokit.units.V / myokit.units.mV)))
+
+        # Convert state with number initial value
+        w = m.get('membrane.w')
+        wdot = w.rhs().eval()
+        w.convert_unit('ug')
+        self.assertEqual(w.unit(), myokit.units.g / 1e6)
+        self.assertEqual(wdot * 1000, w.rhs().eval())
+        m.check_units(myokit.UNIT_STRICT)
+        self.assertEqual(w.initial_value(True), 10000)
+        self.assertEqual(w.initial_value(), myokit.Number(10000))
+        #self.assertEqual(
+        #    w.initial_value(), myokit.Number(10000, myokit.units.g / 1e6))
+
         # Convert non-state
         i = m.get('ina.i')
         self.assertNotEqual(i.unit(), myokit.parse_unit('uA/uF'))
@@ -226,6 +246,72 @@ class VariableTest(unittest.TestCase):
         self.assertEqual(vdot, v.rhs().eval())
         m.check_units(myokit.UNIT_STRICT)
 
+    def test_index(self):
+        # Tests the index() method
+
+        m = myokit.Model()
+        c = m.add_component('c')
+        a = c.add_variable('a')
+        a.set_rhs(0)
+        a.promote(0)
+        b = c.add_variable('b')
+        b.set_rhs(0)
+        b.promote(0)
+
+        self.assertEqual(a.index(), 0)
+        self.assertEqual(b.index(), 1)
+        m.reorder_state((b, a))
+        self.assertEqual(a.index(), 1)
+        self.assertEqual(b.index(), 0)
+
+        # Test deprecated alias
+        with WarningCollector() as w:
+            self.assertEqual(a.indice(), 1)
+        self.assertIn('deprecated', w.text())
+
+    def test_initial_value(self):
+        # Tests :meth:`Variable.initial_value`.
+
+        m = myokit.parse_model('''
+            [[model]]
+            c.x = 2
+
+            [c]
+            t = 0 bind time
+            dot(x) = 0
+            p = 3
+            q = 4
+        ''')
+
+        # Test expression version
+        x, p = m.get('c.x'), m.get('c.p')
+        p = m.get('c.p')
+        self.assertEqual(x.initial_value(), myokit.Number(2))
+        x.set_initial_value(3)
+        self.assertEqual(x.initial_value(), myokit.Number(3))
+        x.set_initial_value('3 [kg]')
+        self.assertEqual(x.initial_value(), myokit.Number(3, myokit.units.kg))
+        x.set_initial_value('sqrt(c.p) / log(c.p)')
+        self.assertEqual(x.initial_value(), myokit.Divide(
+            myokit.Sqrt(p.lhs()), myokit.Log(p.lhs())))
+
+        # Test float version
+        p.set_rhs(9)
+        x.set_initial_value('1 + sqrt(c.p)')
+        self.assertEqual(x.initial_value(True), 4)
+
+        # Test deprecated alias
+        with WarningCollector() as w:
+            self.assertEqual(x.state_value(), x.initial_value(True))
+        self.assertIn('deprecated', w.text())
+
+        # Test cycles are detected
+        p.set_rhs('1 - 2 * q')
+        m.get('c.q').set_rhs('7 * sqrt(p)')
+        x.initial_value()  # No evaluation, so no error
+        self.assertRaises(
+            myokit.CyclicalDependencyError, x.initial_value, as_float=True)
+
     def test_is_referenced(self):
         # Test :meth:`Variable.is_referenced().
 
@@ -276,6 +362,8 @@ class VariableTest(unittest.TestCase):
 
         m = myokit.Model()
         c = m.add_component('c')
+        p = c.add_variable('p')
+        p.set_rhs(1)
         v = c.add_variable('v')
         v.set_rhs(3)
 
@@ -285,8 +373,8 @@ class VariableTest(unittest.TestCase):
         self.assertFalse(v.is_state())
         self.assertEqual(v.lhs(), myokit.Name(v))
         self.assertRaises(Exception, v.demote)
-        self.assertRaises(Exception, v.indice)
-        self.assertRaises(Exception, v.state_value)
+        self.assertRaises(Exception, v.index)
+        self.assertRaises(Exception, v.initial_value)
 
         v.promote(3)
         self.assertFalse(v.is_literal())
@@ -294,8 +382,8 @@ class VariableTest(unittest.TestCase):
         self.assertFalse(v.is_intermediary())
         self.assertTrue(v.is_state())
         self.assertEqual(v.lhs(), myokit.Derivative(myokit.Name(v)))
-        self.assertEqual(v.indice(), 0)
-        self.assertEqual(v.state_value(), 3)
+        self.assertEqual(v.index(), 0)
+        self.assertEqual(v.initial_value(), myokit.Number(3))
 
         v.demote()
         self.assertTrue(v.is_literal())
@@ -304,8 +392,8 @@ class VariableTest(unittest.TestCase):
         self.assertFalse(v.is_state())
         self.assertEqual(v.lhs(), myokit.Name(v))
         self.assertRaises(Exception, v.demote)
-        self.assertRaises(Exception, v.indice)
-        self.assertRaises(Exception, v.state_value)
+        self.assertRaises(Exception, v.index)
+        self.assertRaises(Exception, v.initial_value)
 
         # Test errors
         v.promote(3)
@@ -317,6 +405,19 @@ class VariableTest(unittest.TestCase):
         self.assertRaisesRegex(
             Exception, 'only be added to Components', w.promote, 4)
 
+        # Test that promote accepts expressions and strings
+        v.set_binding(None)
+        v.remove_variable(w)
+        v.promote(myokit.Number(3, myokit.units.kg))
+        self.assertEqual(v.initial_value(), myokit.Number(3, myokit.units.kg))
+        v.demote()
+        v.promote('1 + c.p')
+        self.assertEqual(v.initial_value().code(), '1 + c.p')
+        v.demote()
+
+        # Test that promote only works with global syntax references
+        self.assertRaisesRegex(myokit.ParseError, 'Unresolved', v.promote, 'p')
+
         # Test we can't demote a variable with references to its derivative
         m = myokit.Model()
         c = m.add_component('c')
@@ -330,6 +431,15 @@ class VariableTest(unittest.TestCase):
         y.set_rhs('1 + x')
         x.demote()
 
+        # Test deprecated keyword argument
+        with WarningCollector() as w:
+            x.promote(state_value=3)
+        self.assertIn('deprecated', w.text())
+        self.assertEqual(x.initial_value(), myokit.Number(3))
+        x.demote()
+        self.assertRaisesRegex(
+            Exception, 'at the same time as', x.promote, 3, state_value=3)
+
     def test_pyfunc(self):
         # Test :meth:`Variable.pyfunc().
 
@@ -638,31 +748,72 @@ class VariableTest(unittest.TestCase):
         self.assertEqual(v.name(), 'w')
         self.assertEqual(v.qname(), 'c.w')
 
-    def test_set_state_value(self):
-        # Test :meth:`Variable.set_state_value()`.
+    def test_set_initial_value(self):
+        # Test :meth:`Variable.set_initial_value()`.
 
         m = myokit.Model()
         c = m.add_component('c')
+        t = c.add_variable('t')
+        t.set_rhs(0)
+        t.set_binding('time')
         v = c.add_variable('v')
+        v.set_rhs(3)
         w = c.add_variable('w')
+        w.set_rhs('1 + 2')
+        m.validate()
 
         # Test basic functionality
         v.promote(10)
-        self.assertEqual(v.state_value(), 10)
-        v.set_state_value(12)
-        self.assertEqual(v.state_value(), 12)
+        self.assertEqual(v.initial_value(), myokit.Number(10))
+        v.set_initial_value(myokit.Number(12, myokit.units.g))
+        self.assertEqual(v.initial_value(), myokit.Number(12, myokit.units.g))
+
+        # Test setting expressions
+        v.set_initial_value('1 + 11')
+        #self.assertEqual(v.initial_value(),
+        #                 myokit.Plus(myokit.Number(1), myokit.Number(11)))
+        v.set_initial_value('1 + c.w')
+        self.assertEqual(v.initial_value(),
+                         myokit.Plus(myokit.Number(1), myokit.Name(w)))
+
+        # Strings must use global context
+        self.assertRaisesRegex(myokit.ParseError, 'No component specified for',
+                               v.set_initial_value, '1 / w')
 
         # Only states have this option
         v.demote()
         self.assertRaisesRegex(
-            Exception, 'Only state variables', v.set_state_value, 3)
+            Exception, 'Only state variables', v.set_initial_value, 3)
         self.assertRaisesRegex(
-            Exception, 'Only state variables', w.set_state_value, 3)
-
-        # State values must be literals
+            Exception, 'Only state variables', w.set_initial_value, 3)
         v.promote(3)
+        m.validate()
+
+        # Initial values must be constant, but this is only picked up in
+        # validation
+        w.promote(1)
+        v.set_initial_value(myokit.Name(w))
+        self.assertRaises(myokit.IntegrityError, m.validate)
+        w.demote()
+        m.validate()
+
+        # Nested variables may not be used, but this is only picked up when
+        # validating
+        x = v.add_variable('x')
+        x.set_rhs(1)
+        v.set_initial_value(x.lhs())
         self.assertRaises(
-            myokit.NonLiteralValueError, v.set_state_value, w.lhs())
+            myokit.IllegalReferenceInInitialValueError, m.validate)
+        v.set_initial_value(x)
+
+        # InitialValue and PartialDerivative can not be used
+        v.set_initial_value(myokit.PartialDerivative(v.lhs(), x.lhs()))
+
+        # Deprecated alias
+        with WarningCollector() as w:
+            v.set_state_value(1)
+        self.assertIn('deprecated', w.text())
+        self.assertEqual(v.initial_value(), myokit.Number(1))
 
     def test_set_unit(self):
         # Test :meth:`Variable.set_unit()`.
@@ -745,6 +896,59 @@ class VariableTest(unittest.TestCase):
         p.set_rhs('q == 3')
         self.assertRaisesRegex(
             myokit.IntegrityError, 'can not be a condition', p.validate)
+        p.set_rhs(3)
+        p.validate()
+
+        # Initial value can not reference nested variables
+        r = c.add_variable('r')
+        r1 = r.add_variable('r1')
+        r1.set_rhs(1)
+        r.set_rhs('1 + r1')
+        p.validate()
+        p.set_initial_value(myokit.Plus(myokit.Number(1), myokit.Name(r1)))
+        self.assertRaises(
+            myokit.IllegalReferenceInInitialValueError, p.validate)
+
+        # Initial value must be constant
+        p.set_initial_value('1 / c.q')
+        q.promote(3)
+        self.assertRaisesRegex(myokit.IntegrityError, 'not const', p.validate)
+        q.demote()
+        p.validate()
+        q.set_rhs('1 + c.p')
+        self.assertRaisesRegex(myokit.IntegrityError, 'not const', p.validate)
+        q.set_rhs(10)
+        p.validate()
+        q.set_binding('hello')
+        self.assertRaisesRegex(myokit.IntegrityError, 'not const', p.validate)
+        # Don't test everything, is_const() should work!
+
+        # Initial value cannot be a partial, init, or condition
+        p.set_initial_value(myokit.PartialDerivative(p.lhs(), q.lhs()))
+        self.assertRaisesRegex(
+            myokit.IntegrityError, 'Partial derivatives', p.validate)
+        p.set_initial_value(myokit.InitialValue(myokit.Name(p)))
+        self.assertRaisesRegex(
+            myokit.IntegrityError, 'Initial value', p.validate)
+        p.set_initial_value('c.q == 3')
+        self.assertRaisesRegex(
+            myokit.IntegrityError, 'can not be a condition', p.validate)
+
+        # Initial value cycles are caught in validation, don't cause loops
+        m = myokit.parse_model('''
+            [[model]]
+            x.x = 0
+            [x]
+            dot(x) = x
+            t = 0 bind time
+            ''')
+        x = m.get('x.x')
+        x.set_initial_value('x.x')
+        self.assertRaisesRegex(myokit.IntegrityError, 'not const', m.validate)
+        x.set_initial_value(1)
+        m.validate()
+        x.set_initial_value('1 + 1 / x.x')
+        self.assertRaisesRegex(myokit.IntegrityError, 'not const', m.validate)
 
     def test_value(self):
         # Test :meth:`Variable.value()`.

myokit/tools.py

@@ -6,9 +6,7 @@
 # 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 io
 import os
 import re
 import shutil
@@ -18,18 +16,12 @@ import tempfile
 import threading
 import timeit
 
-# StringIO in Python 2 and 3
-try:
-    from cStringIO import StringIO
-except ImportError:  # pragma: no python 2 cover
-    from io import StringIO
-
 
 # Natural sort regex
 _natural_sort_regex = re.compile('([0-9]+)')
 
 
-class Benchmarker(object):
+class Benchmarker:
     """
     Allows benchmarking using the with statement.
 
@@ -97,7 +89,7 @@ class Benchmarker(object):
         return timeit.default_timer() - self._start
 
 
-class capture(object):
+class capture:
     """
     Context manager that temporarily redirects the current standard output and
     error streams, and captures anything that's written to them.
@@ -224,8 +216,8 @@ class capture(object):
         # Redirect
         if not self._fd:
             # Create temporary output and error streams
-            self._tmp_out = StringIO()
-            self._tmp_err = StringIO()
+            self._tmp_out = io.StringIO()
+            self._tmp_err = io.StringIO()
 
             # Redirect, attempting to flush first
             try:
@@ -391,10 +383,6 @@ class capture(object):
             return ''
         text = self._txt_err
 
-        # In Python 2, the text needs to be decoded from ascii
-        if sys.hexversion < 0x03000000:  # pragma: no python 3 cover
-            text = text.decode('ascii', 'ignore')
-
         return text
 
     def out(self):
@@ -406,10 +394,6 @@ class capture(object):
             return ''
         text = self._txt_out
 
-        # In Python 2, the text needs to be decoded from ascii
-        if sys.hexversion < 0x03000000:  # pragma: no python 3 cover
-            text = text.decode('ascii', 'ignore')
-
         return text
 
     def text(self):

myokit/units.py

@@ -4,9 +4,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 myokit
 
 
@@ -263,6 +260,7 @@ _rep('M')
 _rep('mM')
 _rep('mM^2')
 _rep('mM^3')
+_rep('mM^4')
 _rep('uM')
 _rep('1/mM/ms')
 _rep('1/mM^2/ms')
@@ -284,6 +282,7 @@ _rep('S/F')
 _rep('mS/uF')
 _rep('mS/cm^2')
 _rep('mS/mm^2')
+_rep('L/F/s')
 _rep('L/F/ms')
 _rep('mA/cm^2')
 # Capacitance
@@ -296,3 +295,6 @@ _rep('J/mol/K')
 _rep('mJ/mol/K')
 _rep('C/mol')
 _rep('C/mmol')
+_rep('J/K')  # Boltzmann
+_rep('J*s')  # Planck
+_rep('J*ms')