myokit 1.37.0__py3-none-any.whl → 1.37.2__py3-none-any.whl

myokit/tests/data/io/block1d.mmt

@@ -0,0 +1,187 @@
+[[model]]
+author: Michael Clerx
+desc: """
+Implementation of the Luo-Rudy model I for the ventricular myocyte.
+Based on an updated formulation downloaded from http://rudylab.wustl.edu
+
+Original copyright notice:
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Copyright (C) 2006 by Leonid Livshitz and Yoram Rudy
+Email rudy@wustl.edu
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the
+Free Software Foundation, Inc.,
+59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+"""
+name: Luo-Rudy model (1991)
+# Initial conditions
+membrane.V = -84.5286
+ina.m      = 0.0017
+ina.h      = 0.9832
+ina.j      = 0.995484
+ica.d      = 0.000003
+ica.f      = 1
+ik.x       = 0.0057
+ica.Ca_i   = 0.0002
+
+# Engine variables
+[engine]
+time = 0 bind time
+pace = 1 bind pace  # Set to 1 to test if it becomes 0 without a protocol
+
+# Membrane potential and stimulus
+[membrane]
+dot(V) = -(i_ion + i_stim + i_diff)
+    label membrane_potential
+    in [mV]
+    desc: The membrane potential
+i_ion = ina.INa + ik.IK + ib.Ib + ikp.IKp + ik1.IK1 + ica.ICa
+i_stim = engine.pace * stim_amplitude
+    stim_amplitude = -80 [uA/cm^2]
+        desc: """
+        Stimulus amplitude.
+        The online matlab implementation features this 80 uA/cm^2, 0.5 millisecond
+        pulse. The cellml version uses a 2 millisecond 25.5 uA/cm^2 pulse.
+        """
+i_diff = 0 bind diffusion_current
+    in [uA/cm^2]
+
+# Fast Sodium current
+[ina]
+use membrane.V as V
+ENa = cell.RTF * log(cell.Na_o / cell.Na_i)
+    desc: Nernst potential of Na
+    in [mV]
+a = 1 - 1 / (1 + exp(-(V + 40) / 0.24))
+    desc: Used instead of if statement.
+dot(m) =  alpha * (1 - m) - beta * m
+    alpha = if(V == -47.13, -3.2,
+            0.32 * (V + 47.13) / (1 - exp(-0.1 * (V + 47.13))))
+    beta  = 0.08 * exp(-V / 11)
+    desc: """
+    Activation parameter of the fast sodium channel, based on Ebihara-Johnson
+    (E-J) model of cardiac cells (chicken embryo)
+    """
+dot(h) = alpha * (1 - h) - beta * h
+    alpha = a * 0.135 * exp((80 + V) / -6.8)
+    beta  = a * (3.56 * exp(0.079 * V) + 3.1e5 * exp(0.35 * V)) \
+          + (1 - a) / (0.13 * (1 + exp((V + 10.66) / -11.1)))
+    desc: """
+    (Fast) Inactivation parameter of the fast sodium channel, based on
+    Ebihara-Johnson (E-J) model of cardiac cells (chicken embryo)
+    """
+dot(j) =  alpha * (1 - j) - beta * j
+    alpha = a * ( -127140 * exp(0.2444 * V) - 3.474e-5 * exp(-0.04391 * V)) \
+              * (V + 37.78) / (1 + exp(0.311 * (V + 79.23)))
+    beta  = a * (0.1212 * exp(-0.01052 * V) / (1 + exp(-0.1378 * (V + 40.14)))) \
+          + (1 - a) * (0.3 * exp(-2.535e-7 * V) / (1 + exp(-0.1 * (V + 32))))
+    desc: """
+    Slow inactivation gate. Inspired by Beeler-Reuter and Haas. Steady-state
+    value (j_inf) is set to value from h gate (h_inf). Time constant obtained
+    from Beeler-Reuter model.
+    """
+gNa = 16
+INa = gNa * m^3 * h * j * (V - ENa)
+    desc: Fast sodium current
+    in [uA/cm^2]
+
+# Time-dependent Potassium current
+[ik]
+use membrane.V as V
+PNa_K = 0.01833 : Permability ratio of Na to K
+gK = 0.282 * sqrt(cell.K_o / 5.4)
+    in [mS/uF]
+E = cell.RTF * log((cell.K_o + PNa_K * cell.Na_o) / (cell.K_i + PNa_K * cell.Na_i))
+    in [mV]
+xi = if(V < -100,
+    1,
+    if(V == -77,
+        2.837 * 0.04 / exp(0.04 * (V + 35)),
+        2.837 * (exp(0.04 * (V + 77)) - 1) / ((V + 77) * exp(0.04 * (V + 35)))
+        ))
+dot(x) = alpha * (1 - x) - beta * x
+    alpha = 0.0005 * exp(0.083 * (V + 50)) / (1 + exp(0.057 * (V + 50)))
+    beta  = 0.0013 * exp(-0.06 * (V + 20)) / (1 + exp(-0.04 * (V + 20)))
+IK = gK * xi * x * (V - E)
+    desc: Time-dependent Potassium current
+
+# Plateau Potassium current
+[ikp]
+use membrane.V as V
+gKp = 0.0183
+IKp = gKp * (V + 87.8789) / (1 + exp((7.488 - V) / 5.98))
+    desc: Plateau Potassium current
+
+# Slow inward Calcium current
+[ica]
+use membrane.V as V
+dot(Ca_i) =  -1e-4 * ICa + 0.07 * (1e-4 - Ca_i)
+    desc: Intracellular Calcium concentration
+E = 7.7 - 13.0287 * log(Ca_i / cell.Ca_o)
+    desc: Nernst potential
+    in [mV]
+dot(d) =  alpha * (1 - d) - beta * d
+    alpha = 0.095 * exp(-0.01 * (V - 5)) / (1 + exp(-0.072 * (V - 5)))
+    beta  = 0.07 * exp(-0.017 * (V + 44)) / (1 + exp(0.05 * (V + 44)))
+dot(f) =  alpha * (1-f) - beta * f
+    alpha = 0.012 * exp(-0.008 * (V + 28)) / (1 + exp(0.15 * (V + 28)))
+    beta  = 0.0065 * exp(-0.02 * (V + 30)) / (1 + exp(-0.2 * (V + 30)))
+gCa = 0.09
+ICa = gCa * d * f * (V - E)
+
+# Time-independent potassium current
+[ik1]
+use membrane.V as V
+E = cell.RTF * log(cell.K_o / cell.K_i)
+gK1 = 0.6047 * sqrt(cell.K_o / 5.4) * alpha / (alpha + beta)
+    alpha = 1.02 / (1 + exp(0.2385 * (V - E - 59.215)))
+    beta  = (0.49124 * exp(0.08032 * (V - E + 5.476)) + exp(0.06175 * (V - E - 594.31)))  \
+          / (1 + exp(-0.5143 * (V - E + 4.753)))
+IK1 = gK1 * (V - E)
+
+# Background current
+[ib]
+gb = 0.03921
+Ib = gb * (membrane.V + 59.87) : Background current
+
+# Cell parameters (ventricular mammalian cell)
+[cell]
+K_o = 5.4 [mM]
+K_i = 145 [mM]
+Na_o = 140 [mM]
+Na_i = 10 [mM]
+Ca_o = 1.8 [mM]
+RTF = R*T/F
+    R = 8.314 [J/K] : Gas constant
+    T = 273 + 37 [K] : Absolute temperature
+    F = 96.5 [C/mol] : Faraday constant
+
+[[protocol]]
+# Level Start Length Period Multiplier
+1.0     1     0.5    1000   0
+
+[[script]]
+import matplotlib.pyplot as pl
+import myokit
+
+# Create simulation
+m = get_model()
+p = get_protocol()
+s = myokit.SimulationOpenCL(m, p, 16)
+
+# Run
+d = s.run(5, log=['engine.time', 'membrane.V', 'engine.pace'])
+b = d.block1d()
+b.save('block1d.zip')
+

myokit/tests/data/io/datalog-18-duplicate-keys.csv

@@ -0,0 +1,4 @@
+"time","x","x","ys-2","x","ys-2","x-2"
+1, 0, 2, 4, 6, 8, 5
+2, 1, 3, 5, 7, 9, 4
+

myokit/tests/test_aux.py

@@ -526,6 +526,10 @@ class AuxTest(unittest.TestCase):
             self.assertEqual(a, b)
         self.assertEqual(len(x), len(y))
 
+        # No issues when passing initial state from a model
+        # See https://github.com/myokit/myokit/pull/1083
+        myokit.step(m1, reference=m2, initial=m1.initial_values())
+
     def test_strfloat(self):
         # Deprecated alias of myokit.float.str
         args = ['-1.234', True, myokit.SINGLE_PRECISION]

myokit/tests/test_datablock.py

@@ -397,19 +397,19 @@ class DataBlock1dTest(unittest.TestCase):
         # Not enough data: detected at time level
         path = os.path.join(DIR_IO, 'bad1d-6-time-too-short.zip')
         self.assertRaisesRegex(
-            myokit.DataBlockReadError, 'larger data',
+            myokit.DataBlockReadError, 'more time data',
             myokit.DataBlock1d.load, path)
 
         # Not enoug data: detected at 0d level
         path = os.path.join(DIR_IO, 'bad1d-7-0d-too-short.zip')
         self.assertRaisesRegex(
-            myokit.DataBlockReadError, 'larger data',
+            myokit.DataBlockReadError, 'more 0d data',
             myokit.DataBlock1d.load, path)
 
         # Not enough data: detected at 1d level
         path = os.path.join(DIR_IO, 'bad1d-8-1d-too-short.zip')
         self.assertRaisesRegex(
-            myokit.DataBlockReadError, 'larger data',
+            myokit.DataBlockReadError, 'more 1d data',
             myokit.DataBlock1d.load, path)
 
         # Test progress reporter
@@ -1324,19 +1324,19 @@ class DataBlock2dTest(unittest.TestCase):
         # Unknown data type in data
         path = os.path.join(DIR_IO, 'bad2d-6-time-too-short.zip')
         self.assertRaisesRegex(
-            myokit.DataBlockReadError, 'larger data',
+            myokit.DataBlockReadError, 'more time data',
             myokit.DataBlock2d.load, path)
 
         # Unknown data type in data
         path = os.path.join(DIR_IO, 'bad2d-7-0d-too-short.zip')
         self.assertRaisesRegex(
-            myokit.DataBlockReadError, 'larger data',
+            myokit.DataBlockReadError, 'more 0d data',
             myokit.DataBlock2d.load, path)
 
         # Unknown data type in data
         path = os.path.join(DIR_IO, 'bad2d-8-2d-too-short.zip')
         self.assertRaisesRegex(
-            myokit.DataBlockReadError, 'larger data',
+            myokit.DataBlockReadError, 'more 2d data',
             myokit.DataBlock2d.load, path)
 
         # Test progress reporter

myokit/tests/test_datalog.py

@@ -683,6 +683,26 @@ class DataLogTest(unittest.TestCase):
         d = myokit.DataLog.load(path, progress=p)
         self.assertIsNone(d)
 
+    def test_load_csv_duplicate_keys(self):
+        # Test loading a CSV with duplicate key names
+
+        path = os.path.join(DIR_IO, 'datalog-18-duplicate-keys.csv')
+        d = myokit.DataLog.load_csv(path)
+        self.assertEqual(len(d), 7)
+        self.assertEqual(
+            list(d.keys()),
+            ['time', 'x-1', 'x-3', 'ys-2-1', 'x-4', 'ys-2-2', 'x-2'])
+
+    def test_load_csv_ufeff(self):
+        # Test ignoring byte order marker (BOM) at start of file
+
+        with TemporaryDirectory() as td:
+            path = td.path('test.csv')
+            with open(path, 'w', encoding='utf-8-sig') as f:
+                f.write('time,x\n0,2\n1,3\n')
+            d = myokit.DataLog.load_csv(path)
+            self.assertEqual(list(d.keys()), ['time', 'x'])
+
     def test_load_csv_errors(self):
         # Test for errors during csv loading.