def set_AMPA_NMDA_synapses(num_of_synapses):
del SynList[:]
del ConList[:]
for j in range(num_of_synapses):
SynList.append(h.Exp2Syn(SPINE_HEAD_X, sec=HCell.spine[(j * 2) + 1]))
ConList.append(h.NetCon(Stim1, SynList[-1]))
SynList[-1].e = E_SYN
SynList[-1].tau1 = TAU_1_AMPA
SynList[-1].tau2 = TAU_2_AMPA
ConList[-1].weight[0] = AMPA_W
ConList[-1].delay = DELAY
for j in range(num_of_synapses):
SynList.append(h.NMDA(SPINE_HEAD_X, sec=HCell.spine[(j * 2) + 1]))
ConList.append(h.NetCon(Stim1, SynList[-1]))
SynList[-1].e = E_SYN
SynList[-1].tau_r_NMDA = TAU_1_NMDA
SynList[-1].tau_d_NMDA = TAU_2_NMDA
ConList[-1].weight[0] = NMDA_W
ConList[-1].delay = DELAY
SynList[-1].n_NMDA = N_NMDA
SynList[-1].gama_NMDA = GAMMA_NMDA
def add_synapses_on_list_of_segments(list_of_segments, HCell, SynList, ConList,
config):
HCell.delete_spine()
if len(list_of_segments) == 0:
return
add_spines_on_segments(HCell, list_of_segments)
num_of_synapses = len(list_of_segments)
for j in range(num_of_synapses):
SynList.append(
h.Exp2Syn(config.SPINE_HEAD_X, sec=HCell.spine[(j * 2) + 1]))
ConList.append(h.NetCon(config.stim, SynList[-1]))
SynList[-1].e = config.E_SYN
SynList[-1].tau1 = config.TAU_1_AMPA
SynList[-1].tau2 = config.TAU_2_AMPA
ConList[-1].weight[0] = config.AMPA_W
for j in range(num_of_synapses):
SynList.append(
h.NMDA(config.SPINE_HEAD_X, sec=HCell.spine[(j * 2) + 1]))
ConList.append(h.NetCon(config.stim, SynList[-1]))
SynList[-1].e = config.E_SYN
SynList[-1].tau_r_NMDA = config.TAU_1_NMDA
SynList[-1].tau_d_NMDA = config.TAU_2_NMDA
SynList[-1].n_NMDA = config.N_NMDA
SynList[-1].gama_NMDA = config.GAMMA_NMDA
ConList[-1].weight[0] = config.NMDA_W
def add_synapses_on_spines(num_of_synapses,
SynList,
ConList,
model_properties,
AMPA_BLOCKED=False):
# Add AMPA synapses
for j in range(num_of_synapses):
SynList.append(h.Exp2Syn(SPINE_HEAD_X, sec=HCell.spine[(j * 2) + 1]))
ConList.append(h.NetCon(Stim1, SynList[-1]))
SynList[-1].e = E_SYN
SynList[-1].tau1 = TAU_1_AMPA
SynList[-1].tau2 = TAU_2_AMPA
ConList[-1].delay = model_properties['DELAY']
if AMPA_BLOCKED:
ConList[-1].weight[0] = AMPA_W_B
else:
ConList[-1].weight[0] = AMPA_W
# Add NMDA synapses
for j in range(num_of_synapses):
SynList.append(h.NMDA(SPINE_HEAD_X, sec=HCell.spine[(j * 2) + 1]))
ConList.append(h.NetCon(Stim1, SynList[-1]))
SynList[-1].e = E_SYN
SynList[-1].tau_r_NMDA = TAU_1_NMDA
SynList[-1].tau_d_NMDA = TAU_2_NMDA
SynList[-1].n_NMDA = N_NMDA
SynList[-1].gama_NMDA = GAMMA_NMDA
ConList[-1].weight[0] = NMDA_W
ConList[-1].delay = model_properties['DELAY']
return SynList, ConList
def add_synapses_on_list_of_segments(list_of_segments, SynList, ConList,
seg_to_num_of_syn):
# delete previous synapses
HCell.delete_spine()
num_of_synapses = add_spines_on_segments(list_of_segments,
seg_to_num_of_syn)
for j in range(num_of_synapses):
SynList.append(h.Exp2Syn(SPINE_HEAD_X, sec=HCell.spine[(j * 2) + 1]))
ConList.append(h.NetCon(Stim1, SynList[-1]))
SynList[-1].e = E_SYN
SynList[-1].tau1 = TAU_1_AMPA
SynList[-1].tau2 = TAU_2_AMPA
ConList[-1].weight[0] = AMPA_W
ConList[-1].delay = DELAY
for j in range(num_of_synapses):
SynList.append(h.NMDA(SPINE_HEAD_X, sec=HCell.spine[(j * 2) + 1]))
ConList.append(h.NetCon(Stim1, SynList[-1]))
SynList[-1].e = E_SYN
SynList[-1].tau_r_NMDA = TAU_1_NMDA
SynList[-1].tau_d_NMDA = TAU_2_NMDA
ConList[-1].weight[0] = NMDA_W
ConList[-1].delay = DELAY
SynList[-1].n_NMDA = N_NMDA
SynList[-1].gama_NMDA = GAMMA_NMDA
return SynList, ConList
def add_synapses_on_spines(num_of_synapses,SynList,ConList,model_properties):
# Add AMPA synapses
for j in range(num_of_synapses):
SynList.append(h.Exp2Syn(SPINE_HEAD_X,sec=HCell.spine[(j*2)+1]))
ConList.append(h.NetCon(Stim1,SynList[-1]))
SynList[-1].e=E_SYN
SynList[-1].tau1=TAU_1_AMPA
SynList[-1].tau2=TAU_2_AMPA
ConList[-1].weight[0] = model_properties['AMPA_W']
ConList[-1].delay = model_properties['DELAY']
# Add NMDA synapses
for j in range(num_of_synapses):
SynList.append(h.NMDA(SPINE_HEAD_X,sec=HCell.spine[(j*2)+1]))
ConList.append(h.NetCon(Stim1,SynList[-1]))
SynList[-1].e=E_SYN
SynList[-1].tau_r_NMDA = model_properties['tau_1_NMDA']
SynList[-1].tau_d_NMDA = model_properties['tau_2_NMDA']
SynList[-1].n_NMDA = model_properties['N_NMDA']
SynList[-1].gama_NMDA = model_properties['GAMMA_NMDA']
ConList[-1].weight[0] = model_properties['NMDA_W']
ConList[-1].delay = model_properties['DELAY']
return SynList,ConList
def initdend (self):
self.dend = h.Section()
self.dend.nseg = 1
self.dend.diam = 2
self.dend.L = 500
self.dend.Ra = 1
self.dend.insert('pas')
self.ampa = h.AMPA(0.5,sec=self.dend)
self.nmda = h.NMDA(0.5,sec=self.dend)
self.gabaa0 = h.GABAa(0.5,sec=self.dend)
def nmda_test(weight, Tau2, Cdur, Beta, Alpha, title):
sece2s = h.Section(name="sece2s")
secdms = h.Section(name="secdms")
e2s = h.MyExp2SynNMDABB(0.5, sec=sece2s)
dms = h.NMDA(0.5, sec=secdms)
e2s.tau2NMDA = Tau2
dms.Cdur = Cdur
dms.Beta = Beta
dms.Alpha = Alpha
t_vec = h.Vector()
t_vec.record(h._ref_t)
v_vece2s = h.Vector()
v_vece2s.record(sece2s(0.5)._ref_v)
v_vecdms = h.Vector()
v_vecdms.record(secdms(0.5)._ref_v)
dms_vec = h.Vector()
dms_vec.record(dms._ref_g)
dms_ivec = h.Vector()
dms_ivec.record(dms._ref_iNMDA)
dms_icavec = h.Vector()
dms_icavec.record(dms._ref_ica)
e2s_vec = h.Vector()
e2s_vec.record(e2s._ref_g)
e2s_ivec = h.Vector()
e2s_ivec.record(e2s._ref_iNMDA)
e2s_icavec = h.Vector()
e2s_icavec.record(e2s._ref_ica)
ns = h.NetStim()
ns.number = 1
ns.interval = 200
ns.start = 50
ns.noise = 0
nc1 = h.NetCon(ns, dms)
nc1.delay = 1.0
nc1.weight[0] = weight
nc2 = h.NetCon(ns, e2s)
nc2.delay = 1.0
nc2.weight[0] = weight
def addSynapses(self):
self.pre_list = []
# E0
syn_ = h.MyExp2Syn(self.lm_thick1(0.5))
self.pre_list.append(syn_) # AMPA EC
syn_.tau1 = 0.5
syn_.tau2 = 3
syn_.e = 0
# E1
syn_ = h.MyExp2Syn(self.lm_thick2(0.5))
self.pre_list.append(syn_) # AMPA EC
syn_.tau1 = 0.5
syn_.tau2 = 3
syn_.e = 0
# E2
syn_ = h.MyExp2Syn(self.radTmed(0.5))
self.pre_list.append(syn_) # AMPA CA3 Shaffer collateral
syn_.tau1 = 0.5
syn_.tau2 = 3
syn_.e = 0
# E3
syn_ = h.NMDA(self.radTmed(0.5))
self.pre_list.append(syn_) # NMDA CA3 Shaffer collateral
syn_.tcon = 2.3
syn_.tcoff = 100
syn_.gNMDAmax = 1 # use connection weight to determine max cond
# E4
syn_ = h.MyExp2Syn(self.radTprox(0.5))
self.pre_list.append(syn_) # AMPA PC Recurrent collateral
syn_.tau1 = 0.5
syn_.tau2 = 3
syn_.e = 0
# I5
syn_ = h.MyExp2Syn(self.soma(0.5))
self.pre_list.append(syn_) # GABA-A basket cell
syn_.tau1 = 1
syn_.tau2 = 8
syn_.e = -75
# I6
syn_ = h.MyExp2Syn(self.axon(0.1))
self.pre_list.append(syn_) # GABA-A AA cell
syn_.tau1 = 1
syn_.tau2 = 8
syn_.e = -75
# I7
syn_ = h.MyExp2Syn(self.lm_thick1(0.5))
self.pre_list.append(syn_) # GABA-A OLM cell
syn_.tau1 = 1
syn_.tau2 = 8
syn_.e = -75
# I8
syn_ = h.MyExp2Syn(self.lm_thick2(0.5))
self.pre_list.append(syn_) # GABA-A OLM cell
syn_.tau1 = 1
syn_.tau2 = 8
syn_.e = -75
# I9
syn_ = h.MyExp2Syn(self.lm_thick1(0.5))
self.pre_list.append(syn_) # GABA-B OLM cell
syn_.tau1 = 35
syn_.tau2 = 100
syn_.e = -75
# I10
syn_ = h.MyExp2Syn(self.lm_thick2(0.5))
self.pre_list.append(syn_) # GABA-B OLM Cell
syn_.tau1 = 35
syn_.tau2 = 100
syn_.e = -75
# I11
syn_ = h.MyExp2Syn(self.radTmed(0.8))
self.pre_list.append(syn_) # GABA-A Bistratified
syn_.tau1 = 1
syn_.tau2 = 8
syn_.e = -75
# I12
syn_ = h.MyExp2Syn(self.radTmed(0.7))
self.pre_list.append(syn_) # GABA-A Bistratified
syn_.tau1 = 1
syn_.tau2 = 8
syn_.e = -75
# I13
syn_ = h.MyExp2Syn(self.radTmed(0.6))
self.pre_list.append(syn_) # GABA-A Bistratified
syn_.tau1 = 1
syn_.tau2 = 8
syn_.e = -75
# I14
syn_ = h.MyExp2Syn(self.radTmed(0.4))
self.pre_list.append(syn_) # GABA-A Bistratified
syn_.tau1 = 1
syn_.tau2 = 8
syn_.e = -75
# I15
syn_ = h.MyExp2Syn(self.radTmed(0.3))
self.pre_list.append(syn_) # GABA-A Bistratified
syn_.tau1 = 1
syn_.tau2 = 8
syn_.e = -75
# I16
syn_ = h.MyExp2Syn(self.radTmed(0.2))
self.pre_list.append(syn_) # GABA-A Bistratified
syn_.tau1 = 1
syn_.tau2 = 8
syn_.e = -75
# I17
syn_ = h.MyExp2Syn(self.radTmed(0.8))
self.pre_list.append(syn_) # GABA-B Bistratified
syn_.tau1 = 35
syn_.tau2 = 100
syn_.e = -75
# I18
syn_ = h.MyExp2Syn(self.radTmed(0.7))
self.pre_list.append(syn_) # GABA-B Bistratified
syn_.tau1 = 35
syn_.tau2 = 100
syn_.e = -75
# I19
syn_ = h.MyExp2Syn(self.radTmed(0.6))
self.pre_list.append(syn_) # GABA-B Bistratified
syn_.tau1 = 35
syn_.tau2 = 100
syn_.e = -75
# I20
syn_ = h.MyExp2Syn(self.radTmed(0.4))
self.pre_list.append(syn_) # GABA-B Bistratified
syn_.tau1 = 35
syn_.tau2 = 100
syn_.e = -75
# I21
syn_ = h.MyExp2Syn(self.radTmed(0.3))
self.pre_list.append(syn_) # GABA-B Bistratified
syn_.tau1 = 35
syn_.tau2 = 100
syn_.e = -75
# I22
syn_ = h.MyExp2Syn(self.radTmed(0.2))
self.pre_list.append(syn_) # GABA-B Bistratified
syn_.tau1 = 35
syn_.tau2 = 100
syn_.e = -75
# I23
syn_ = h.STDPE2(self.radTmed(0.5))
self.pre_list.append(syn_) # AMPA modifiable CA3 Schaffer collaterals
syn_.tau1 = 0.5
syn_.tau2 = 3
syn_.e = 0
def __init__(self, TTX = False, Pool1_num = 9, Pool2_num = 9, Beta = 0.067,
Cdur = 1, Syn_w1 = 0.01, Syn_w2 = 0.01, Loc = [0.2, 0.6]):
"""
Model the Glumate Stimulation.
Model the Receptors in 2 pools:
Pool 1: AMPA + NMDA (same synaptic weight, represent spine conductance)
Pool 2: NMDA only (represent the extrasyanptic NMDARs)
Parameters:
-----------
TTX: True or False.
True: setting all the sodium channel conductance to 0 to mimic
TTX application in experiments
False: default
Pool1_num: syanptic AMPA/NMDA numbers
Pool2_num: extrasyanptic NMDA numbers
Beta: parameter for NMDA Receptors
Cdur: parameter for NMDA Receptors
Syn_w1: the syanptic weight of AMPA/NMDA receptors in pool1
Syn_w2: the syanptic weight of AMPA/NMDA receptors in pool2
Loc: the stimulation location
-----------
Outputs:
Figures: recording from soma and 3 different locations from basal dendrites
json: soma and dendritc voltage recording and parameters info
"""
Cell = de.CA229(HVA_ratio = 0.0, LVA_ratio = 0.0)
self.Cell = Cell
# Can adjust channel conductance ratio here:
# eg. Cell = CA229(KA_ratio = 0.5)
###########################################
timestr = time.strftime("%H%M")
data = time.strftime("%m_%d")
# directory = 'Data_' + data +'/'
directory_root = 'Fig3/'
directory = directory_root + 'DMS/Plot/'
# directory = directory_root + 'DMS/Analysis/'
if (TTX == True):
Cell.TTX()
title = "TTX_Pool1_"+ str(Pool1_num) + "_Pool2_" + str(Pool2_num) + "_NMDA_Beta_" + \
str(Beta) + "_NMDA_Cdur_"+str(Cdur)+ "_Pool1_W_" + str(Syn_w1) + \
"_Pool2_W_" + str(Syn_w2) + "_"+ timestr
else:
title = "Pool1_"+ str(Pool1_num) + "_Pool2_" + str(Pool2_num) + "_NMDA_Beta_" + \
str(Beta) + "_NMDA_Cdur_"+str(Cdur)+ "_Pool1_W_" + str(Syn_w1) + \
"_Pool2_W_" + str(Syn_w2) + "_"+ timestr
###########################################
# Adding Pool 1
###########################################
##### AMPA
SynAMPA = []
nc_AMPA = []
SynNMDA = []
nc_NMDA = []
self.SynAMPA = SynAMPA
self.nc_AMPA = nc_AMPA
self.SynNMDA = SynNMDA
self.nc_NMDA = nc_NMDA
###########################################
loc1 = list(np.linspace(Loc[0], Loc[1], Pool1_num))
###########################################
# Loc and time delay set up
delay1 = random_2(10, 50 + int(Syn_w1*50), Pool1_num)
# delay1 = random_beta(10, 50 + int(Syn_w1*50), Pool1_num)
ns = h.NetStim()
self.ns = ns
ns.interval = 20
ns.number = 1
ns.start = 190
ns.noise = 0
###########################################
for i in range(Pool1_num):
###########################
# Adding AMPA
SynAMPA.append(h.AMPA(Cell.basal[34](loc1[i])))
SynAMPA[-1].gmax = 0.05
nc_AMPA.append(h.NetCon(ns, SynAMPA[i]))
nc_AMPA[-1].delay = delay1[i]
nc_AMPA[-1].weight[0] = Syn_w1
###########################
#Adding NMDA
SynNMDA.append(h.NMDA(Cell.basal[34](loc1[i])))
SynNMDA[-1].gmax = 0.005
SynNMDA[-1].Beta = Beta
SynNMDA[-1].Cdur = Cdur
nc_NMDA.append(h.NetCon(ns, SynNMDA[i]))
nc_NMDA[-1].delay = delay1[i]
nc_NMDA[-1].weight[0] = Syn_w1
###########################################
# Adding Pool 2
###########################################
ExNMDA = []
nc_ExNMDA = []
self.ExNMDA = ExNMDA
self.nc_ExNMDA = nc_ExNMDA
loc2 = list(np.linspace(Loc[0], Loc[1], Pool2_num))
# delay2 = list(np.linspace(5, 10, Pool2_num))
delay2 = random_2(15, 55 + int(Syn_w2*60), Pool2_num)
# delay2 = random_beta(15, 55 + int(Syn_w2*60), Pool2_num)
for i in range(Pool2_num):
###########################
# Adding extrasyanptic NMDA
ExNMDA.append(h.NMDA(Cell.basal[34](loc2[i])))
ExNMDA[-1].gmax = 0.005
ExNMDA[-1].Beta = Beta
ExNMDA[-1].Cdur = Cdur
nc_ExNMDA.append(h.NetCon(ns, ExNMDA[i]))
nc_ExNMDA[-1].delay = delay2[i]
nc_ExNMDA[-1].weight[0] = Syn_w2
###########################################
### Recording
###########################################
t_vec = h.Vector()
t_vec.record(h._ref_t)
v_vec_soma = h.Vector()
v_vec_dend1 = h.Vector()
v_vec_dend2 = h.Vector()
v_vec_dend3 = h.Vector()
cai_soma = h.Vector()
cai_dend = h.Vector()
v_vec_soma.record(Cell.soma[2](0.5)._ref_v)
v_vec_dend1.record(Cell.basal[34](0.8)._ref_v)
v_vec_dend2.record(Cell.basal[34](0.5)._ref_v)
v_vec_dend3.record(Cell.basal[34](0.3)._ref_v)
cai_soma.record(Cell.soma[2](0.5)._ref_cai)
cai_dend.record(Cell.basal[34](0.3)._ref_cai)
###########################################
### Run & Plot
###########################################
h.celsius = 32
h.v_init = -73.6927850677
h.init()
h.tstop = 1000
h.run()
# pdb.set_trace() #Debugging
# print v_vec_soma[-1]
# plt.clf()
# plt.close()
# plt.figure(figsize = (16, 6), dpi = 100)
# plt.plot(t_vec, v_vec_soma, label = 'soma(0.5)', color = 'black')
# plt.plot(t_vec, v_vec_dend1, label = 'bdend[34](0.8)', color = 'red')
# plt.plot(t_vec, v_vec_dend2, label = 'Basal[34](0.5)', color = 'blue')
# plt.plot(t_vec, v_vec_dend3, label = 'Basal[34](0.3)', color = 'green')
# plt.ylim([-90, 40])
# plt.xlim([0, 800])
# plt.legend(loc = 'best')
# plt.ylabel('mV')
# plt.xlabel('Time (ms)')
# plt.title ("Glumate Receptor Activated Plateau Potential")
#
# save(title, directory, ext="png", close=True, verbose=True)
#######################
# Plot the intracelluar calcium concentration
# plt.clf()
# plt.close()
# plt.figure(figsize = (16, 6), dpi = 100)
# plt.plot(t_vec, cai_soma, label = 'soma(0.5)', color = 'black')
# #plt.plot(t_vec, cai_dend, label = 'bdend[34](0.3)', color = 'red')
#
# # plt.ylim([-90, 60])
# plt.xlim([0, 800])
# plt.legend(loc = 'best')
# plt.ylabel('mM')
# plt.xlabel('Time (ms)')
# plt.title ("Calcium concentration")
# title1 = "Calcium_" + title
# ut.save(title1, directory, ext="png", close=True, verbose=True)
data = ut.Vividict()
data['SynAMPA']['num'] = Pool1_num
data['SynAMPA']['locs'] = loc1
data['SynAMPA']['weight'] = Syn_w1
data['SynNMDA']['num'] = Pool1_num
data['SynNMDA']['locs'] = loc1
data['SynNMDA']['weight'] = Syn_w1
data['SynNMDA']['Beta'] = Beta
data['SynNMDA']['Cdur'] = Cdur
data['ExNMDA']['num'] = Pool2_num
data['ExNMDA']['locs'] = loc2
data['ExNMDA']['weight'] = Syn_w2
data['ExNMDA']['Beta'] = Beta
data['ExNMDA']['Cdur'] = Cdur
data['recording']['time'] = list(t_vec)
data['recording']['soma']['voltage'] = list(v_vec_soma)
data['recording']['basal_34']['voltage_0.8'] = list(v_vec_dend1)
data['recording']['basal_34']['voltage_0.5'] = list(v_vec_dend2)
data['recording']['basal_34']['voltage_0.3'] = list(v_vec_dend3)
data['recording']['soma']['ica'] = list(cai_soma)
data['recording']['basal_34']['ica_0.3'] = list(cai_dend)
ut.savejson(data, title, directory, ext = "json", verbose = False)
from neuron import h
import neuron.gui
soma = h.Section(name='soma')
soma.insert('hh')
ampa = h.AMPA(0.5, sec=soma)
#ampa.gbar = 1 # Just increasing, for testing purpose
nmda = h.NMDA(0.5, sec=soma)
vecStim = h.VecStim()
vec = h.Vector([2])
vecStim.play(vec)
# vecStim2 = h.VecStim()
# vec2 = h.Vector([1])
# vecStim2.play(vec2)
netCon = h.NetCon(vecStim, ampa)
netCon.weight[0] = 1
# netCon2 = h.NetCon(vecStim2, nmda)
# netCon2.weight[0] = 1
def synapses(self):
syn_ = h.MyExp2Syn(self.lm_thick1(0.5))
syn_.tau1 = 0.5
syn_.tau2 = 3.0
syn_.e = 0.0
self.prelist.append(syn_)
syn_ = h.MyExp2Syn(self.lm_thick2(0.5))
syn_.tau1 = 0.5
syn_.tau2 = 3.0
syn_.e = 0.0
self.prelist.append(syn_)
syn_ = h.MyExp2Syn(self.radTmed(0.5))
syn_.tau1 = 0.5
syn_.tau2 = 3.0
syn_.e = 0.0
self.prelist.append(syn_)
syn_ = h.NMDA(self.radTmed(0.5))
syn_.tcon = 2.3
syn_.tcoff = 100.
syn_.gNMDAmax = 1.0
self.prelist.append(syn_)
syn_ = h.MyExp2Syn(self.radTprox(0.5))
syn_.tau1 = 0.5
syn_.tau2 = 3.0
syn_.e = 0.0
self.prelist.append(syn_)
syn_ = h.MyExp2Syn(self.soma(0.5))
syn_.tau1 = 1.0
syn_.tau2 = 8.0
syn_.e = -75
self.prelist.append(syn_)
syn_ = h.MyExp2Syn(self.axon(0.5))
syn_.tau1 = 1.0
syn_.tau2 = 8.0
syn_.e = -75.0
self.prelist.append(syn_)
syn_ = h.MyExp2Syn(self.lm_thick1(0.5))
syn_.tau1 = 1.0
syn_.tau2 = 8.0
syn_.e = -75
self.prelist.append(syn_)
syn_ = h.MyExp2Syn(self.lm_thick2(0.5))
syn_.tau1 = 1.0
syn_.tau2 = 8.0
syn_.e = -75
self.prelist.append(syn_)
syn_ = h.MyExp2Syn(self.lm_thick1(0.5))
syn_.tau1 = 35
syn_.tau2 = 100
syn_.e = -75
self.prelist.append(syn_)
syn_ = h.MyExp2Syn(self.lm_thick2(0.5))
syn_.tau1 = 35
syn_.tau2 = 100
syn_.e = -75
self.prelist.append(syn_)
for l in np.arange(0.2, 0.9, 0.1):
if l == 0.5:
continue
syn_ = h.MyExp2Syn(self.radTmed(l))
syn_.tau1 = 1.0
syn_.tau2 = 8.0
syn_.e = -75
self.prelist.append(syn_)
for l in np.arange(0.2, 0.9, 0.1):
if l == 0.5:
continue
syn_ = h.MyExp2Syn(self.radTmed(l))
syn_.tau1 = 35
syn_.tau2 = 100
syn_.e = -75
self.prelist.append(syn_)
syn_ = h.STDPE2(self.radTmed(0.5))
syn_.tau1 = 0.5
syn_.tau2 = 3.0
syn_.e = 0.0
def syn_stim():
spi6 = initcell("SPI6")
num_syns = 1
factor = 3.0
nclist = []
synlist = []
stim = h.NetStim()
stim.number = 1
stim.interval = 0.0
stim.start = 200
h.tstop = 800
time = h.Vector()
time.record(h._ref_t)
v_soma = h.Vector()
v_soma.record(spi6.soma(0.5)._ref_v)
v_bdend = h.Vector()
v_bdend.record(spi6.Bdend1(0.5)._ref_v)
# Currents in Bdend: ih, nax, kdr, kap, cal, can, kBk
i_ih = h.Vector()
i_ih.record(spi6.Bdend1(0.5).ih._ref_i)
i_na = h.Vector()
i_na.record(spi6.Bdend1(0.5)._ref_ina)
i_k = h.Vector()
i_k.record(spi6.Bdend1(0.5)._ref_ik)
i_ca = h.Vector()
i_ca.record(spi6.Bdend1(0.5)._ref_ica)
for ind in range(num_syns):
nmda_syn = h.NMDA(spi6.Bdend1(0.5))
nc_nmda = h.NetCon(stim, nmda_syn)
nc_nmda.weight[0] = 0.055 * factor
nc_nmda.delay = 10
synlist.append(nmda_syn)
nclist.append(nc_nmda)
ampa_syn = h.AMPA(spi6.Bdend1(0.5))
nc_ampa = h.NetCon(stim, ampa_syn)
nc_ampa.weight[0] = 0.0055 * factor
nc_ampa.delay = 10
synlist.append(ampa_syn)
nclist.append(nc_ampa)
i_nmda = h.Vector()
i_nmda.record(synlist[0]._ref_i)
i_ampa = h.Vector()
i_ampa.record(synlist[1]._ref_i)
h.run()
plt.figure()
ax1 = plt.subplot(311)
plt.plot(time, v_soma, label="Soma")
plt.plot(time, v_bdend, label="Bdend")
plt.ylabel("Membrane Potential (mV)")
plt.legend()
ax2 = plt.subplot(312, sharex=ax1)
plt.plot(time, i_nmda, label="NMDA (" + str(nc_nmda.weight[0]) + ")")
plt.plot(time, i_ampa, label="AMPA (" + str(nc_ampa.weight[0]) + ")")
plt.ylabel("Synaptic Currents (nA)")
plt.legend()
ax3 = plt.subplot(313, sharex=ax1)
plt.plot(time, i_ih, label="H")
plt.plot(time, i_na, label="Na")
plt.plot(time, i_k, label="K")
plt.plot(time, i_ca, label="Ca")
plt.ylabel("Membrane Currents (nA)")
plt.xlabel("Time (ms)")
plt.xlim([200, 800])
plt.legend()
plt.show()
"""
import eee_utils as eee
from netpyne.batch import Batch
import matplotlib.pyplot as plt
import numpy as np
import os
import importlib
from neuron import h
from neuron import nrn
plt.ion()
h.load_file('stdrun.hoc')
sec = h.Section()
nmda = h.NMDA(sec(0.5))
print("nmda.mgSlope = " + str(nmda.mgSlope))
# Steepen the mgblock curve
def plot_mgBlock():
voltrange = np.linspace(-80, 20, 100)
def mgblock(slope, voltrange):
voltrange = np.linspace(-80, 20, 100)
block = 1 / (1 + np.exp(-slope * voltrange) * (1 / 3.57))
return block
# Default slope is 0.062
slopes = [0.032, 0.042, 0.052, 0.062, 0.072, 0.082, 0.092]
def run_simulation(params):
"""
Function get parameters and run the model
"""
pc = h.ParallelContext()
pc.timeout(3600)
h.load_file("stdgui.hoc")
h.load_file("stdrun.hoc")
h.load_file("import3d.hoc")
RNG = np.random.default_rng()
load_mechanisms("./mods/")
# h.dt = 0.1 * ms
h.cvode.use_fast_imem(1)
# h.CVode().fixed_step(1)
# h.cvode.use_local_dt(1)
sys.path.append("../LFPsimpy/") # path to LFPsimpy
from LFPsimpy import LfpElectrode
# load all cells
cell_path = "./cells/"
for file in os.listdir(cell_path):
if file.find(".hoc") != -1:
h.load_file(cell_path + file)
gid_vect = np.asarray(
[neuron_param["gid"] for neuron_param in params["neurons"]])
all_cells = h.List()
hh_cells = h.List()
pyramidal_sec_list = h.SectionList()
is_pyrs_thread = False
radius_for_pyramids = params["common_params"]["radius4piramids"]
spike_count_obj = []
spike_times_vecs = []
soma_v_vecs = []
# create objects for neurons simulation
for neuron_param in params["neurons"]:
celltypename = neuron_param["celltype"]
cellclass_name = neuron_param["cellclass"]
gid = neuron_param["gid"]
cellclass = getattr(h, cellclass_name)
cell = cellclass(gid, 0)
pc.set_gid2node(gid, pc.id())
if celltypename == "pyr":
# x and y position of pyramidal cells
angle = 2 * np.pi * (RNG.random() - 0.5)
radius = radius_for_pyramids * 2 * (RNG.random() - 0.5)
pyr_coord_in_layer_x = radius * np.cos(angle)
pyr_coord_in_layer_y = radius * np.sin(angle)
cell.position(pyr_coord_in_layer_x, 0, pyr_coord_in_layer_y)
for sec in cell.all:
pyramidal_sec_list.append(sec)
is_pyrs_thread = True
# set counters for spike generation
if cell.is_art() == 0:
for sec in cell.all:
sec.insert("IextNoise")
sec.myseed_IextNoise = RNG.integers(0, 1000000000000000, 1)
sec.sigma_IextNoise = 0.005
sec.mean_IextNoise = neuron_param["cellparams"]["iext"]
if hasattr(cell, "axon_list"):
mt = h.MechanismType(0)
mt.select('IextNoise')
for sec in cell.axon_list:
mt.remove(sec=sec)
firing = h.NetCon(cell.soma[0](0.5)._ref_v, None, sec=cell.soma[0])
firing.threshold = -30 * mV
else:
cell.celltype = celltypename
for p_name, p_val in neuron_param["cellparams"].items():
if hasattr(cell.acell, p_name):
setattr(cell.acell, p_name, p_val)
setattr(cell.acell, "delta_t", h.dt)
setattr(cell.acell, "myseed", RNG.integers(0, 1000000000000000, 1))
firing = h.NetCon(cell.acell, None)
pc.cell(gid, firing)
fring_vector = h.Vector()
firing.record(fring_vector)
spike_count_obj.append(firing)
spike_times_vecs.append(fring_vector)
# check is need to save Vm of soma
if np.sum(params["save_soma_v"] == gid) == 1:
soma_v = h.Vector()
soma_v.record(cell.soma[0](0.5)._ref_v)
soma_v_vecs.append(soma_v)
else:
soma_v_vecs.append(np.empty(shape=0))
if cell.is_art() == 0:
hh_cells.append(cell)
all_cells.append(cell)
pc.barrier()
if pc.id() == 0:
print("End of neurons settings")
# set connection
connections = h.List()
synapses = h.List()
for syn_params in params["synapses_params"]:
post_idx = np.argwhere(gid_vect == syn_params["post_gid"]).ravel()
post_idx = post_idx[0]
postsynaptic_cell = all_cells[post_idx]
post_list = getattr(postsynaptic_cell,
syn_params["target_compartment"])
len_postlist = sum([1 for _ in post_list])
if len_postlist == 1:
post_idx = 0
else:
post_idx = RNG.integers(0, len_postlist - 1)
for idx_tmp, post_comp_tmp in enumerate(post_list):
if idx_tmp == post_idx: post_comp = post_comp_tmp
syn = h.Exp2Syn(post_comp(0.5))
syn.e = syn_params["Erev"]
syn.tau1 = syn_params["tau_rise"]
syn.tau2 = syn_params["tau_decay"]
conn = pc.gid_connect(syn_params["pre_gid"], syn)
conn.delay = syn_params["delay"]
conn.weight[0] = syn_params["gmax"]
conn.threshold = -30 * mV
connections.append(conn)
synapses.append(syn)
try:
# check NMDA in synapse
gmax_nmda = syn_params["NMDA"]["gNMDAmax"]
syn_nmda = h.NMDA(post_comp(0.5), sec=post_comp)
syn_nmda.tcon = syn_params["NMDA"]["tcon"]
syn_nmda.tcoff = syn_params["NMDA"]["tcoff"]
syn_nmda.gNMDAmax = gmax_nmda
conn2 = pc.gid_connect(syn_params["pre_gid"], syn_nmda)
conn2.delay = syn_params["delay"]
conn2.weight[0] = syn_params["NMDA"]["gNMDAmax"]
conn2.threshold = -30 * mV
connections.append(conn2)
synapses.append(syn_nmda)
except KeyError:
pass
pc.barrier()
# create gap junction objects
gap_junctions = h.List()
for gap_params in params["gap_junctions"]:
idx1 = np.argwhere(gid_vect == gap_params["gid1"]).ravel()
idx2 = np.argwhere(gid_vect == gap_params["gid2"]).ravel()
if idx1.size != 0 and idx2.size != 0:
idx1 = idx1[0]
idx2 = idx2[0]
cell1 = all_cells[idx1]
cell2 = all_cells[idx2]
comp1_list = getattr(cell1, gap_params["compartment1"])
len_list = sum([1 for _ in comp1_list])
if len_list == 1:
idx1 = 0
else:
idx1 = RNG.integers(0, len_list - 1)
for idx_tmp, comp_tmp in enumerate(comp1_list):
if idx_tmp == idx1: comp1 = comp_tmp
comp2_list = getattr(cell2, gap_params["compartment2"])
len_list = sum([1 for _ in comp2_list])
if len_list == 1:
idx2 = 0
else:
idx2 = RNG.integers(0, len_list - 1)
for idx_tmp, comp_tmp in enumerate(comp2_list):
if idx_tmp == idx2: comp2 = comp_tmp
pc.source_var(comp1(0.5)._ref_v, gap_params["sgid_gap"],
sec=comp1) # gap_params["gid1"]
gap = h.GAP(comp1(0.5), sec=comp1)
gap.r = gap_params["r"]
pc.target_var(gap._ref_vgap,
gap_params["sgid_gap"] + 1) # gap_params["gid2"]
gap_junctions.append(gap)
pc.source_var(comp2(0.5)._ref_v,
gap_params["sgid_gap"] + 1,
sec=comp2) # gap_params["gid2"]
gap = h.GAP(comp2(0.5), sec=comp2)
gap.r = gap_params["r"]
pc.target_var(gap._ref_vgap,
gap_params["sgid_gap"]) # gap_params["gid1"]
gap_junctions.append(gap)
elif idx1.size != 0 or idx2.size != 0:
if idx1.size != 0 and idx2.size != 0: continue
if idx1.size != 0:
this_idx = idx1[0]
this_gid = gap_params["gid1"]
out_gid = gap_params["gid2"]
comp_name = gap_params["compartment1"]
sgid_gap_src = gap_params["sgid_gap"]
sgid_gap_trg = gap_params["sgid_gap"] + 1
else:
this_idx = idx2[0]
this_gid = gap_params["gid2"]
out_gid = gap_params["gid1"]
comp_name = gap_params["compartment2"]
sgid_gap_src = gap_params["sgid_gap"] + 1
sgid_gap_trg = gap_params["sgid_gap"]
cell = all_cells[this_idx]
comp_list = getattr(cell, comp_name)
for idx_tmp, comp_tmp in enumerate(comp_list):
if idx_tmp == 0: comp = comp_tmp
pc.source_var(comp(0.5)._ref_v, sgid_gap_src, sec=comp)
gap = h.GAP(0.5, sec=comp)
gap.r = gap_params["r"]
pc.target_var(gap._ref_vgap, sgid_gap_trg)
pc.setup_transfer()
pc.barrier()
if pc.id() == 0:
print("End of connection settings")
# create electrodes objects for LFP simulation
el_x = params["elecs"]["el_x"]
el_y = params["elecs"]["el_y"]
el_z = params["elecs"]["el_z"]
electrodes = []
for idx_el in range(el_x.size):
if is_pyrs_thread:
le = LfpElectrode(x=el_x[idx_el], y=el_y[idx_el], z=el_z[idx_el], sampling_period=h.dt, \
method='Line', sec_list=pyramidal_sec_list)
electrodes.append(le)
else:
electrodes.append(None)
if pc.id() == 0:
t_sim = h.Vector()
t_sim.record(h._ref_t)
else:
t_sim = None
h.tstop = params["duration"] * ms
pc.set_maxstep(5 * ms)
h.finitialize()
pc.barrier()
if pc.id() == 0:
print("Start simulation")
timer = time()
pc.psolve(params["duration"] * ms)
pc.barrier()
if pc.id() == 0:
print("End of the simulation!")
print("Time of simulation in sec ", time() - timer)
# unite data from all threads to 0 thread
comm = MPI.COMM_WORLD
lfp_data = join_lfp(comm, electrodes)
spike_trains = join_vect_lists(comm, spike_times_vecs, gid_vect)
soma_v_list = join_vect_lists(comm, soma_v_vecs, gid_vect)
if (pc.id() == 0) and (params["file_results"] != None):
t_sim = np.asarray(t_sim)
rem_time = params["del_start_time"]
if rem_time > t_sim[-1]:
rem_time = 0
rem_idx = int(rem_time / h.dt)
# save results to file
with h5py.File(params["file_results"], 'w') as h5file:
celltypes = params["cell_types_in_model"]
t_sim = t_sim[rem_idx:] - rem_time
h5file.create_dataset("time", data=t_sim)
# save LFP data
extracellular_group = h5file.create_group("extracellular")
ele_group = extracellular_group.create_group('electrode_1')
lfp_group = ele_group.create_group('lfp')
lfp_group_origin = lfp_group.create_group('origin_data')
lfp_group_origin.attrs['SamplingRate'] = 1000 / h.dt # dt in ms
for idx_el, lfp in enumerate(lfp_data):
lfp_group_origin.create_dataset("channel_" + str(idx_el + 1),
data=lfp[rem_idx:])
# save firing data
firing_group = h5file.create_group(
"extracellular/electrode_1/firing/origin_data")
for celltype in set(celltypes):
cell_friring_group = firing_group.create_group(celltype)
for cell_idx, sp_times in enumerate(spike_trains):
if celltype != celltypes[cell_idx]:
continue
sp_times = sp_times[sp_times >= rem_time] - rem_time
cell_friring_group.create_dataset(
"neuron_" + str(cell_idx + 1),
data=sp_times) # cell_spikes_dataset
# save intracellular membrane potential
intracellular_group = h5file.create_group("intracellular")
intracellular_group_origin = intracellular_group.create_group(
"origin_data")
for soma_v_idx in params["save_soma_v"]:
soma_v = soma_v_list[soma_v_idx]
if soma_v.size == 0: continue
soma_v_dataset = intracellular_group_origin.create_dataset(
"neuron_" + str(soma_v_idx + 1), data=soma_v[rem_idx:])
cell_type = celltypes[soma_v_idx]
soma_v_dataset.attrs["celltype"] = cell_type
pc.done()
h.quit()
return
