def test_100_channel(self):
self.assertEqual(Channel.open_channel_TS(1, 1, 100, 1, 0), [100])
self.assertEqual(Channel.open_channel_TS(1, 1, 100, 0, 1), [0])
self.assertEqual(Channel.open_channel_TS(1, 0.5, 100, 1, 0),
[100, 100])
self.assertEqual(Channel.open_channel_TS(0, 0.5, 100, 1, 0), [])
self.assertEqual(Channel.open_channel_TS(1, 0.5, 100, 0, 1), [0, 0])
def setUp(self):
myDict = {'name': 'test', 'lifeo': 1, 'lifec': 1,
'zg': 1, 'd': 0.5, 'N': 1,
'gamma': 10e-9, 'E0': 0}
self.standard_channel = Channel(**myDict)
myDict = {'name': 'test', 'lifeo': 1, 'lifec': 1,
'zg': 1, 'd': 0, 'N': 1,
'gamma': 10e-9, 'E0': 0}
self.zero_delta_channel = Channel(**myDict)
myDict = {'name': 'test', 'lifeo': 1, 'lifec': 1,
'zg': 0, 'd': 0.5, 'N': 1,
'gamma': 10e-9, 'E0': 0}
self.zero_valence_channel = Channel(**myDict)
class TestComputeCurrentTS(unittest.TestCase):
def setUp(self):
myDict = {'name': 'Na', 'lifeo': 10, 'lifec': 30,
'zg': 0, 'd': 0.5, 'N': 100,
'gamma': 10e-9, 'E0': 60}
self.channel = Channel(**myDict)
def test_no_driving(self):
current_TS = self.channel.compute_current_TS(60, 100, 0.01, 300)
mean_current_TS = sum(current_TS) / float(len(current_TS))
self.assertEqual(len(current_TS), 10000)
self.assertEqual(mean_current_TS, 0)
def test_minus_100mV_driving(self):
current_TS = self.channel.compute_current_TS(-40, 10000, 0.01, 300)
mean_current_TS = sum(current_TS) / float(len(current_TS))
self.assertEqual(len(current_TS), 1000000)
self.assertAlmostEqual(mean_current_TS, -2.5e-8, 8)
def test_single_channel(self):
self.channel.N = 1
current_TS = self.channel.compute_current_TS(-40, 10000, 0.01, 300)
mean_current_TS = sum(current_TS) / float(len(current_TS))
self.assertEqual(len(current_TS), 1000000)
self.assertAlmostEqual(mean_current_TS, -2.5e-10, 10)
def test_two_channels(self):
self.channel.N = 2
current_TS = self.channel.compute_current_TS(-40, 10000, 0.01, 300)
mean_current_TS = sum(current_TS) / float(len(current_TS))
self.assertEqual(len(current_TS), 1000000)
self.assertAlmostEqual(mean_current_TS, -5.0e-10, 10)
def test_voltage_dependence(self):
self.channel.zg = 4
self.channel.d = 0.8
Vm = -40
# k+ = k+_0*exp(4*96485*(-40/1000)*0.2/(8.314*300))
# lifec = lifec * exp(-(4*96485*(-40/1000)*0.2/(8.314*300)))
# = lifec * 3.448 = 103.449
# k- = k- *exp(4*96485*(-40/1000)*-0.8/(8.314*300))
# lifeo = lifeo *exp(-(4*96485*(-40/1000)*-0.8/(8.314*300)))
# = lifeo * 7.0727 * 10^-3 = 0.070727
# I = (Vm-Ex)*gamma*N*(lifeo/(lifec+lifeo))
# I = (-0.1)*10E-9*100*(0.070727 / (103.449 + 0.070727)) = 6.8322E-11
current_TS = self.channel.compute_current_TS(Vm, 10000, 0.01, 300)
mean_current_TS = sum(current_TS) / float(len(current_TS))
self.assertAlmostEqual(mean_current_TS, -6.83e-7, 4)
def testDrivingForce(self):
timeseries = [1 for i in range(0, 1000)]
gamma = 1
Vm = 20
Ex = 20
currentTimeSeries = Channel.compute_current_from_open_TS(timeseries,
gamma, Vm, Ex)
self.assertEqual(sum(currentTimeSeries), 0)
timeseries = [1 for i in range(0, 1000)]
gamma = 1
Vm = 20
Ex = 10
currentTimeSeries = Channel.compute_current_from_open_TS(timeseries,
gamma, Vm, Ex)
self.assertAlmostEqual(.010 * len(timeseries), sum(currentTimeSeries))
def testIfRuns(self):
timeseries = [0 for i in range(0, 1000)]
gamma = 0
Vm = 0
Ex = 0
currentTimeSeries = Channel.compute_current_from_open_TS(timeseries,
gamma, Vm, Ex)
self.assertEqual(sum(currentTimeSeries), 0)
def testGamma(self):
timeseries = [1 for i in range(0, 1000)]
gamma = 0.5
Vm = 20
Ex = 19
currentTimeSeries = Channel.compute_current_from_open_TS(timeseries,
gamma, Vm, Ex)
self.assertAlmostEqual(gamma*0.001*len(timeseries),
sum(currentTimeSeries))
class TestVoltageDependence(unittest.TestCase):
def setUp(self):
myDict = {'name': 'test', 'lifeo': 1, 'lifec': 1,
'zg': 1, 'd': 0.5, 'N': 1,
'gamma': 10e-9, 'E0': 0}
self.standard_channel = Channel(**myDict)
myDict = {'name': 'test', 'lifeo': 1, 'lifec': 1,
'zg': 1, 'd': 0, 'N': 1,
'gamma': 10e-9, 'E0': 0}
self.zero_delta_channel = Channel(**myDict)
myDict = {'name': 'test', 'lifeo': 1, 'lifec': 1,
'zg': 0, 'd': 0.5, 'N': 1,
'gamma': 10e-9, 'E0': 0}
self.zero_valence_channel = Channel(**myDict)
def test_at_0mV(self):
loVm, lcVm = self.standard_channel.compute_voltage_dependence(295, 0)
self.assertAlmostEqual(loVm, 1, places=5)
self.assertAlmostEqual(lcVm, 1, places=5)
def test_at_0delta(self):
loVm, lcVm = self.zero_delta_channel.compute_voltage_dependence(295,
-70)
self.assertAlmostEqual(loVm, 1, places=5)
self.assertAlmostEqual(lcVm, 15.70153, places=5)
def test_at_0valence(self):
loVm, lcVm = self.zero_valence_channel.compute_voltage_dependence(295,
-70)
self.assertAlmostEqual(loVm, 1, places=5)
self.assertAlmostEqual(lcVm, 1, places=5)
def test_at_neg70mV(self):
loVm, lcVm = self.standard_channel.compute_voltage_dependence(295, -70)
self.assertAlmostEqual(loVm, 0.25236, places=5)
self.assertAlmostEqual(lcVm, 3.96252, places=5)
def test_at_neg80mV(self):
loVm, lcVm = self.standard_channel.compute_voltage_dependence(295, -80)
self.assertAlmostEqual(loVm, 0.20730, places=5)
self.assertAlmostEqual(lcVm, 4.82387, places=5)
def test_at_neg90mV(self):
loVm, lcVm = self.standard_channel.compute_voltage_dependence(295, -90)
self.assertAlmostEqual(loVm, 0.17029, places=5)
self.assertAlmostEqual(lcVm, 5.87246, places=5)
def test_at_70mV(self):
loVm, lcVm = self.standard_channel.compute_voltage_dependence(295, 70)
self.assertAlmostEqual(loVm, 3.96252, places=5)
self.assertAlmostEqual(lcVm, 0.25236, places=5)
def test_at_80mV(self):
loVm, lcVm = self.standard_channel.compute_voltage_dependence(295, 80)
self.assertAlmostEqual(loVm, 4.82387, places=5)
self.assertAlmostEqual(lcVm, 0.20730, places=5)
def test_at_90mV(self):
loVm, lcVm = self.standard_channel.compute_voltage_dependence(295, 90)
self.assertAlmostEqual(loVm, 5.87246, places=5)
self.assertAlmostEqual(lcVm, 0.17029, places=5)
def setUp(self):
myDict = {'name': 'Na', 'lifeo': 10, 'lifec': 30,
'zg': 0, 'd': 0.5, 'N': 100,
'gamma': 10e-9, 'E0': 60}
self.channel = Channel(**myDict)
def test_two_channel(self):
self.assertEqual(Channel.open_channel_TS(1, 1, 2, 1, 0), [2])
self.assertEqual(Channel.open_channel_TS(1, 1, 2, 0, 1), [0])
self.assertEqual(Channel.open_channel_TS(1, 0.5, 2, 1, 0), [2, 2])
self.assertEqual(Channel.open_channel_TS(0, 0.5, 2, 1, 0), [])
self.assertEqual(Channel.open_channel_TS(1, 0.5, 2, 0, 1), [0, 0])
def test_zero_channels(self):
self.assertEqual(Channel.open_channel_TS(1, 0.1, 0, 1, 1), [])
self.assertEqual(Channel.open_channel_TS(0, 0.1, 0, 1, 1), [])
