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