def __init__(
self,
size,
tau_neu=10.,
tau_syn=0.5,
tau_ref=2.,
V_reset=-65.,
V_th=-50.,
Cm=0.25,
):
super(LIF, self).__init__(size=size)
# parameters
self.tau_neu = tau_neu # membrane time constant [ms]
self.tau_syn = tau_syn # Post-synaptic current time constant [ms]
self.tau_ref = tau_ref # absolute refractory period [ms]
self.Cm = Cm # membrane capacity [nF]
self.V_reset = V_reset # reset potential [mV]
self.V_th = V_th # fixed firing threshold [mV]
self.Iext = 0. # constant external current [nA]
# variables
self.V = bm.Variable(-65. + 5.0 * bm.random.randn(self.num)) # [mV]
self.I = bm.Variable(bm.zeros(self.num)) # synaptic currents [nA]
self.spike = bm.Variable(bm.zeros(self.num, dtype=bool))
self.t_last_spike = bm.Variable(bm.ones(self.num) * -1e7)
# function
self.integral = bp.odeint(bp.JointEq([self.dV, self.dI]),
method='exp_auto')
def test_ode2(self):
a, b, tau=0.7, 0.8, 12.5
dV = lambda V, t, w, Iext: V - V * V * V / 3 - w + Iext
dw = lambda w, t, V: (V + a - b * w) / tau
fhn = bp.odeint(bp.JointEq([dV, dw]), method='rk4', dt=0.1)
runner = bp.IntegratorRunner(fhn, monitors=['V', 'w'], inits=[1., 1.], args=dict(Iext=1.5))
runner.run(100.)
bp.visualize.line_plot(runner.mon.ts, runner.mon['V'], legend='V')
bp.visualize.line_plot(runner.mon.ts, runner.mon['w'], legend='w', show=True)
def test_ode3(self):
a, b, tau=0.7, 0.8, 12.5
dV = lambda V, t, w, Iext: V - V * V * V / 3 - w + Iext
dw = lambda w, t, V: (V + a - b * w) / tau
fhn = bp.odeint(bp.JointEq([dV, dw]), method='rk4', dt=0.1)
Iext, duration = bp.inputs.section_input([0., 1., 0.5], [200, 500, 200], return_length=True)
runner = bp.IntegratorRunner(fhn, monitors=['V', 'w'], inits=[1., 1.],
dyn_args=dict(Iext=Iext))
runner.run(duration)
bp.visualize.line_plot(runner.mon.ts, runner.mon['V'], legend='V')
bp.visualize.line_plot(runner.mon.ts, runner.mon['w'], legend='w', show=True)
def __init__(self, size, method='exp_auto'):
super(HH, self).__init__(size)
# variables
self.V = bm.Variable(El + (bm.random.randn(self.num) * 5 - 5))
self.m = bm.Variable(bm.zeros(self.num))
self.n = bm.Variable(bm.zeros(self.num))
self.h = bm.Variable(bm.zeros(self.num))
self.spike = bm.Variable(bm.zeros(self.num, dtype=bool))
self.input = bm.Variable(bm.zeros(size))
def dV(V, t, m, h, n, Isyn):
gna = g_Na * (m * m * m) * h
gkd = g_Kd * (n * n * n * n)
dVdt = (-gl * (V - El) - gna * (V - ENa) - gkd *
(V - EK) + Isyn) / Cm
return dVdt
def dm(
m,
t,
V,
):
m_alpha = 0.32 * (13 - V + VT) / (bm.exp((13 - V + VT) / 4) - 1.)
m_beta = 0.28 * (V - VT - 40) / (bm.exp((V - VT - 40) / 5) - 1)
dmdt = (m_alpha * (1 - m) - m_beta * m)
return dmdt
def dh(h, t, V):
h_alpha = 0.128 * bm.exp((17 - V + VT) / 18)
h_beta = 4. / (1 + bm.exp(-(V - VT - 40) / 5))
dhdt = (h_alpha * (1 - h) - h_beta * h)
return dhdt
def dn(n, t, V):
c = 15 - V + VT
n_alpha = 0.032 * c / (bm.exp(c / 5) - 1.)
n_beta = .5 * bm.exp((10 - V + VT) / 40)
dndt = (n_alpha * (1 - n) - n_beta * n)
return dndt
# functions
self.integral = bp.odeint(bp.JointEq([dV, dm, dh, dn]), method=method)
def __init__(self, num, C=135., method='exp_auto'):
super(JansenRitModel, self).__init__()
self.num = num
# parameters #
self.v_max = 5. # maximum firing rate
self.v0 = 6. # firing threshold
self.r = 0.56 # slope of the sigmoid
# other parameters
self.A = 3.25
self.B = 22.
self.a = 100.
self.tau_e = 0.01 # second
self.tau_i = 0.02 # second
self.b = 50.
self.e0 = 2.5
# The connectivity constants
self.C1 = C
self.C2 = 0.8 * C
self.C3 = 0.25 * C
self.C4 = 0.25 * C
# variables #
# y0, y1 and y2 representing the firing rate of
# pyramidal, excitatory and inhibitory neurones.
self.y0 = bm.Variable(bm.zeros(self.num))
self.y1 = bm.Variable(bm.zeros(self.num))
self.y2 = bm.Variable(bm.zeros(self.num))
self.y3 = bm.Variable(bm.zeros(self.num))
self.y4 = bm.Variable(bm.zeros(self.num))
self.y5 = bm.Variable(bm.zeros(self.num))
self.p = bm.Variable(bm.ones(self.num) * 220.)
# integral function
self.derivative = bp.JointEq(
[self.dy0, self.dy1, self.dy2, self.dy3, self.dy4, self.dy5])
self.integral = bp.odeint(self.derivative, method=method)
def derivative(self):
return bp.JointEq([self.dp, self.dq])
def derivative(self): return bp.JointEq([self.dV, self.dw])
def derivative(self):
dg = lambda g, t, h: -g / self.tau_decay + h
dh = lambda h, t: -h / self.tau_rise
return bp.JointEq([dg, dh])
def derivative(self):
dg = lambda g, t, x: -g / self.tau_decay + self.a * x * (1 - g)
dx = lambda x, t: -x / self.tau_rise
return bp.JointEq([dg, dx])
def derivative(self):
return bp.JointEq([self.dI1, self.dI2, self.dVth, self.dV])
def derivative(self):
return bp.JointEq([self.dV, self.dm, self.dh, self.dn])
