# Simulation parameters h.tstop = 500 # ms, more than long enough for 15 spikes at ISI = 25 ms AMP0 = 0.1 # nA -- minimum stimulus D_AMP = 0.02 # nA -- stim increment between runs NRUNS = 30 # model specification from cell import Cell cell = Cell() # instrumentation # experimental manipulations stim = h.IClamp(cell.soma(0.5)) stim.delay = 1 # ms stim.dur = 1e9 stim.amp = 0.1 # nA def fstimamp(run_id): """takes run i_d, returns corresponding stimulus amplitude""" return AMP0 + run_id * D_AMP def set_params(run_id): """sets stimulus amplitude to appropriate value for this run""" stim.amp = fstimamp(run_id)
STIM_POINT = 187 STOPTIME = 8000 TIMESTEP = 0.025 LENGTH = 0.5 AMPLITUDE = 15 FREQUENCY = 300 L_RATIO = 2.0 # ratio of length (pre+post)/pre A_RATIO = 0.3 # ratio of amplitude POLAR_T = 0.0 volt_time = h.Vector() RN1 = h.Vector() RN2 = h.Vector() RN3 = h.Vector() vec_i = h.Vector() ic = h.IClamp(0.5, sec=cell.Dend[STIM_POINT]) def setVoltageRecord(): volt_time.record(h._ref_t) RN1.record(cell.Dend[STIM_POINT](0.5)._ref_v) RN2.record(cell.Dend[0](0.5)._ref_v) RN3.record(cell.Dend[343](0.5)._ref_v) vec_i.record(ic._ref_i) def writeVoltage(): h('objref mt,outfile') h('mt = new Matrix()') h('outfile = new File()')
soma.e_leak = -65 The Hodgkin-Huxley channels add the following new properties to the section: gnabar_hh: The maximum specific sodium channel conductance [Default value = 0.120 S/cm^2] gkbar_hh: The maximum specific potassium channel conductance [Default value = 0.036 S/cm^2] gl_hh: The maximum specific leakage conductance [Default value = 0.0003 S/cm^2] ena: The reversal potential for the sodium channel [Default value = 50 mV] ek: The reversal potential for the potassium channel [Default value = -77 mV] el_hh: The reversal potential for the leakage channel [Default value = -54.3 mV] ''' ## POINT PROCESSES ################################ stim = h.IClamp(0.5, soma) time = h.Vector() time.record(h._ref_t) ## Current to be applied VecT = h.Vector([0, 100, 200]) VecStim = h.Vector([0.2, 0.4]) stim.delay = 5 stim.dur = 1e9 ##stim.amp = 0.4 VecStim.play(stim._ref_amp, VecT)
from neuron import h soma = h.Section(name='soma') soma.insert('hh') istim = h.IClamp(soma(.5)) print(dir(soma(.5).hh))
def simulate_models_IF(cells_list, models_dirs, models_path="../ActiveModels/", morphs_path="../Morphs/", save_traces=False, save_path='simulated_models_IF_Curve/', thresh=0): h.load_file("import3d.hoc") h.steps_per_ms = 25 h.dt = 1.0 / h.steps_per_ms h.tstop = 1500 h.celsius = 37 h.v_init = -86 for ix, cell in enumerate(cells_list): model = models_dirs[cell]['model'] print "simulates model", model h.load_file(models_path + model + ".hoc") h("objref HCell") h("HCell = new " + model + "()") HCell = h.HCell nl = h.Import3d_Neurolucida3() # Creating the model nl.quiet = 1 nl.input(morphs_path + models_dirs[cell]['morph']) imprt = h.Import3d_GUI(nl, 0) imprt.instantiate(HCell) HCell.indexSections(imprt) HCell.geom_nsec() HCell.geom_nseg() HCell.delete_axon() HCell.insertChannel() HCell.init_biophys() HCell.biophys() # The stimulus icl = h.IClamp(0.5, sec=HCell.soma[0]) icl.dur = 1000 icl.delay = 120.33 icl.amp = 0 # Record the voltage at the soma Vsoma = h.Vector() Vsoma.record(HCell.soma[0](.5)._ref_v) tvec = h.Vector() tvec.record(h._ref_t) HCell.soma[0].push() MODEL_IF = [] range_amps = range(0, 3000, 100) bar = progressbar.ProgressBar(max_value=len(range_amps), widgets=[ ' [', progressbar.Timer(), '] ', progressbar.Bar(), ' (', progressbar.ETA(), ') ', ]) for jx, amp1000 in enumerate(range_amps): amp = amp1000 / 1000.0 icl.amp = amp h.init(h.v_init) h.run() n = count_spikes(np.array(Vsoma), thresh) MODEL_IF.append((amp, n)) bar.update(jx) MODEL_IF = np.array(MODEL_IF) models_dirs[cell]['I'] = MODEL_IF[:, 0] models_dirs[cell]['F'] = MODEL_IF[:, 1] if save_traces: if not os.path.exists(save_path): os.mkdir(save_path) np.savetxt(save_path + model + "IF.txt", np.array(MODEL_IF))
h.load_file("nrngui.hoc") h.celsius = 34 # create one of each cell type # olm_cell2, axoaxonic_cell17S, basket_cell17S, bistratified_cell13S, pyramidal_cell_14Vb.hoc h.load_file("pyramidal_cell_14Vb.hoc") h('objref hoccell') h('hoccell = new PyramidalCell()') print("Made a hoc cell") from model import cellClasses pycell = cellClasses.PyramidalCell() print("Made a python cell") # add a current clamp to each one newclamp = h.IClamp(pycell.soma(0.5)) newclamp.delay = 10 newclamp.dur = 500 newclamp.amp = .1 h('objref oldclamp') h('hoccell.soma oldclamp = new IClamp(0.5)') h.oldclamp.delay = 10 h.oldclamp.dur = 500 h.oldclamp.amp = .1 h.tstop = 500 print("Set current injection") #%% # record membrane potential, run a simulation, and compare results py_soma_v = h.Vector().record(pycell.soma(0.5)._ref_v)
def run_cell(diam,cm,el,gl,gna,gh,gk,tstop,dur,amp,mhalf,hhalf,mk,hk,nhalf,kn,multiply,multiply1,multiply2,seg1,seg2,seg3): #Load the mechanisms in the current directory neuron.load_mechanisms(os.path.dirname(os.path.abspath(__file__))) Passive = [1,-1,-65] soma = h.Section(name='soma') soma.L = 100 # um soma.insert('hh') v0_vec = h.Vector() t_vec = h.Vector() v0_vec.record(soma(0.5)._ref_v) t_vec.record(h._ref_t) soma.insert('na1') soma.insert('k1') soma.insert('hd') m_na = h.Vector() h_hd = h.Vector() n_k = h.Vector() tau_m = h.Vector() tau_h = h.Vector() tau_n = h.Vector() m_na.record(soma(0.5)._ref_minf_na1) h_hd.record(soma(0.5)._ref_linf_hd) n_k.record(soma(0.5)._ref_ninf_k1) tau_m.record(soma(0.5)._ref_mtau_na1) tau_h.record(soma(0.5)._ref_taul_hd) tau_n.record(soma(0.5)._ref_taun_k1) soma.diam = diam soma.cm = cm*1.4884e-4/6.2832e-4 soma.gbar_na1 = gna*1e-3 soma.gbar_k1 = gk*1e-3 soma.gl_hh = gl*1e-6 soma.ghdbar_hd = gh*1e-4 soma.el_hh = el soma.mhalf_na1 = mhalf soma.vhalfl_hd = hhalf soma.mk_na1 = mk soma.kl_hd = hk soma.vhalfn_k1 = nhalf soma.kn_k1 = kn soma.multiply1_na1 = multiply1 soma.multiply2_na1 = multiply2 soma.multiply_k1 = multiply soma.seg_value1_k1 = seg1 soma.seg_value2_na1 = seg2 soma.seg_value3_hd = seg3 Source = h.IClamp(soma(0.5)) Source.delay = dur[0] Source.dur = dur[1]-dur[0] Source.amp = amp h.tstop = tstop h.v_init = el nc = h.NetCon(soma(0.5)._ref_v,None,sec=soma) nc.threshold = 0 spvec = h.Vector() nc.record(spvec) if Source.amp < 0: h.run() print('number of spikes:',len(spvec)) R_in_1 = 1/(soma.gl_hh*1000) tau_1 = soma.cm*R_in_1 V_rest_1 = v0_vec[int(tstop)-20] R_in_2 = Passive[1] tau_2 = Passive[0] V_rest_2 = Passive[2] df1 = pd.DataFrame([[tau_1],[V_rest_1],[R_in_1],[tau_2],[V_rest_2],[R_in_2]], columns=['value '], index = ['tau_seg ', 'Vrest_seg ', 'Rin_seg ','tau_ori ', 'Vrest_ori ', 'Rin_ori ']) print (df1) plt.figure(figsize=(10,6)) plt.plot(t_vec, v0_vec,'b') plt.xlim(0, tstop) plt.ylabel('mV') frequency =["all"] amplitude =["all"] # FIR Curve freq1 = [] I1 = [] freq2 = [] I2 = [] if (Source.amp > 0): for Source.amp in np.arange(amp,amp+1,0.1): h.run() freq1.append(len(spvec)*1000/Source.dur) I1.append(Source.amp) plt.figure(figsize=(16,14)) plt.subplot(4,1,1) plt.plot(t_vec, v0_vec,'b') plt.xlim(0, tstop) plt.ylabel('mV') plt.subplot(4,1,2) plt.plot(amplitude,frequency,'bo') plt.plot(I1,freq1,'yo') #plt.legend([soma.flag_k1,1-soma.flag_k1]) plt.xlabel('Injected current (nA)') plt.ylabel('frequency') plt.subplot(4,1,3) plt.plot(v0_vec, m_na,'r.') plt.plot(v0_vec, h_hd,'b.') plt.plot(v0_vec, n_k, 'g.') #plt.xlim(0, tstop) plt.xlabel('voltage (mV)') plt.ylabel('Probability') plt.legend(['minf','hinf','ninf']) plt.subplot(4,1,4) plt.plot(v0_vec, tau_m,'r.') plt.plot(v0_vec, tau_h,'b.') plt.plot(v0_vec, tau_n, 'g.') plt.xlabel('voltage (mV)') plt.ylabel('tau') plt.legend(['minf','hinf','ninf']) image = BytesIO() #plt.show() plt.savefig(image, format='png') ret = base64.b64encode(image.getvalue()) return str(ret)
hoc_setup() cable = h.Section(name='cable') h.pt3dadd(0.0, 0.0, 0.0, d0, sec=cable) h.pt3dadd(length, 0.0, 0.0, d1, sec=cable) cable.cm = 100*cm # [µF/cm² = 0.01 F/m²] cable.Ra = 100*ra # [Ω cm = 0.01 Ω m] cable.nseg = int(n) cable.insert('pas') cable.g_pas = 0.0001/rm # [S/cm² = 10000 S/m²] cable.e_pas = Erev stim = h.IClamp(cable(1)) stim.delay = 0 stim.dur = tend stim.amp = iinj h.v_init = Erev # Run model # Take samples from the middle of each compartment. xs = [(2.0*i+1)/(2*n) for i in range(int(n))] tvec = h.Vector([tsample]) vrecs = [] for x in xs: vrecs.append(h.Vector())
def update_vclamp(vclamp, dur, amp): vclamp.dur[0] = float(dur) # in ms vclamp.amp[0] = float(amp) # in mV # ----- Create Single Cell ----- simpleCell = CellTemplate.Cell() # ----- Simulation Parameters ----- h.v_init = -60 h.tstop = 100 h.dt = 0.001 h.steps_per_ms = 1000.0 # ----- Stimulation Parameters ----- ccl = h.IClamp(simpleCell.soma(0.8)) update_iclamp(ccl, 10, 50, -1) # ----- Create Vectors to Record Plotting Parameters ----- t_vec = h.Vector() ccl_vec = h.Vector() vcl_vec = h.Vector() v_vec = h.Vector() i_cadyn_vec = h.Vector() i_im_vec = h.Vector() il_leak_vec = h.Vector() # ----- Create Recording for Each Parameter ----- t_vec.record(h._ref_t) ccl_vec.record(ccl._ref_i) v_vec.record(simpleCell.soma(0.5)._ref_v)
def plot_voltage(self, ax=None, delay=2, duration=100, dt=0.2, amplitude=1, show=True): """Plot voltage on soma for an injected current Parameters ---------- ax : instance of matplotlib axis | None An axis object from matplotlib. If None, a new figure is created. delay : float (in ms) The start time of the injection current. duration : float (in ms) The duration of the injection current. dt : float (in ms) The integration time step amplitude : float (in nA) The amplitude of the injection current. show : bool Call plt.show() if True. Set to False if working in headless mode (e.g., over a remote connection). """ import matplotlib.pyplot as plt from neuron import h h.load_file('stdrun.hoc') soma = self.soma h.tstop = duration h.dt = dt h.celsius = 37 iclamp = h.IClamp(soma(0.5)) iclamp.delay = delay iclamp.dur = duration iclamp.amp = amplitude v_membrane = h.Vector().record(self.soma(0.5)._ref_v) times = h.Vector().record(h._ref_t) print('Simulating soma voltage') h.finitialize() def simulation_time(): print('Simulation time: {0} ms...'.format(round(h.t, 2))) for tt in range(0, int(h.tstop), 10): h.CVode().event(tt, simulation_time) h.continuerun(duration) print('[Done]') if ax is None: fig, ax = plt.subplots(1, 1) ax.plot(times, v_membrane) ax.set_xlabel('Time (ms)') ax.set_ylabel('Voltage (mV)') if show: plt.show()
# The model that I choose is: # A model of spike initiation in neocortical pyramidal neurons # Z. F. Mainen, J. Joerges, J. R. Huguenard and T. J. Sejnowski # Neuron 15, 1427-1439 (1995) # From the original demo I deleted the synapses and the interview panel for clarity. # You need to compile the hoc file before launching it # $ nrnivmodl # Importing the NeuronVisio from neuronvisio.controls import Controls controls = Controls() # Importing hoc interpreter from neuron import h # loading the model # importing the interview so the GUI does not freeze # Uncomment this if you want to use also the interview GUI #import neuron.gui # Load the script h.load_file("demo.hoc") ## Insert an IClamp st = h.IClamp(0.5, sec=h.soma) st.amp = 0.25 st.delay = 3 st.dur = 40
# Channels soma.insert('hh') soma.gnabar_hh = 0.12 soma.gkbar_hh = 0.036 soma.gl_hh = 0.0003 soma.el_hh = -54.3 ''' dend.insert('hh') dend.gkbar_hh = 0.05 # Your channel conductance. # try 0, 0.05 and 0.5 dend.gl_hh = 0.0003 dend.el_hh = -54.3 ''' # Connect soma and dendrite # stimulation at dend stim = h.IClamp(dend(1.0)) stim.amp = 0.003 # Try variations 0, 0.003, 0.03, 0.3 and 3. stim.delay = 40 stim.dur = 1 # recordings t_vec = h.Vector() v_vec_soma = h.Vector() v_vec_dend = h.Vector() v_vec_soma.record(soma(1.0)._ref_v) v_vec_dend.record(dend(1.0)._ref_v) t_vec.record(h._ref_t) h.tstop = 60 for g in [0, 0.05, 0.5, 5, 50]:
def ap_rate_test(tree, v_init): cell = cells.make_neurotree_cell("NGFCell", neurotree_dict=tree) h.dt = 0.025 prelength = 1000.0 mainlength = 2000.0 tstop = prelength + mainlength stimdur = 1000.0 stim1 = h.IClamp(cell.sections[0](0.5)) stim1.delay = prelength stim1.dur = stimdur stim1.amp = 0.2 h.tlog = h.Vector() h.tlog.record(h._ref_t) h.Vlog = h.Vector() h.Vlog.record(cell.sections[0](0.5)._ref_v) h.spikelog = h.Vector() nc = h.NetCon(cell.sections[0](0.5)._ref_v, h.nil) nc.threshold = -40.0 nc.record(h.spikelog) h.tstop = tstop it = 1 ## Increase the injected current until at least 60 spikes occur ## or up to 5 steps while (h.spikelog.size() < 60): utils.simulate(h, v_init, prelength, mainlength) if ((h.spikelog.size() < 50) & (it < 5)): print("ap_rate_test: stim1.amp = %g spikelog.size = %d\n" % (stim1.amp, h.spikelog.size())) stim1.amp = stim1.amp + 0.1 h.spikelog.clear() h.tlog.clear() h.Vlog.clear() it += 1 else: break print("ap_rate_test: stim1.amp = %g spikelog.size = %d\n" % (stim1.amp, h.spikelog.size())) isivect = h.Vector(h.spikelog.size() - 1, 0.0) tspike = h.spikelog.x[0] for i in range(1, int(h.spikelog.size())): isivect.x[i - 1] = h.spikelog.x[i] - tspike tspike = h.spikelog.x[i] print("ap_rate_test: isivect.size = %d\n" % isivect.size()) isimean = isivect.mean() isivar = isivect.var() isistdev = isivect.stdev() isilast = int(isivect.size()) - 1 if (isivect.size() > 10): isi10th = 10 else: isi10th = isilast ## Compute the last spike that is largest than the first one. ## This is necessary because some variants of the model generate spike doublets, ## (i.e. spike with very short distance between them, which confuse the ISI statistics. isilastgt = int(isivect.size()) - 1 while (isivect.x[isilastgt] < isivect.x[1]): isilastgt = isilastgt - 1 if (not (isilastgt > 0)): isivect.printf() raise RuntimeError( "Unable to find ISI greater than first ISI: forest_path = %s gid = %d" % (forest_path, gid)) f = open("NGFCell_ap_rate_results.dat", 'w') f.write("## number of spikes: %g\n" % h.spikelog.size()) f.write("## FR mean: %g\n" % (1.0 / isimean)) f.write("## ISI mean: %g\n" % isimean) f.write("## ISI variance: %g\n" % isivar) f.write("## ISI stdev: %g\n" % isistdev) f.write("## ISI adaptation 1: %g\n" % (old_div(isivect.x[0], isimean))) f.write("## ISI adaptation 2: %g\n" % (old_div(isivect.x[0], isivect.x[isilast]))) f.write("## ISI adaptation 3: %g\n" % (old_div(isivect.x[0], isivect.x[isi10th]))) f.write("## ISI adaptation 4: %g\n" % (old_div(isivect.x[0], isivect.x[isilastgt]))) f.close() f = open("NGFCell_voltage_trace.dat", 'w') for i in range(0, int(h.tlog.size())): f.write('%g %g\n' % (h.tlog.x[i], h.Vlog.x[i])) f.close()
def gap_junction_test(tree, v_init): h('objref gjlist, cells, Vlog1, Vlog2') h.pc = h.ParallelContext() h.cells = h.List() h.gjlist = h.List() cell1 = cells.make_neurotree_cell("NGFCell", neurotree_dict=tree) cell2 = cells.make_neurotree_cell("NGFCell", neurotree_dict=tree) h.cells.append(cell1) h.cells.append(cell2) ggid = 20000000 source = 10422930 destination = 10422670 srcbranch = 1 dstbranch = 2 weight = 5.4e-4 stimdur = 500 tstop = 2000 h.pc.set_gid2node(source, int(h.pc.id())) nc = cell1.connect2target(h.nil) h.pc.cell(source, nc, 1) h.pc.set_gid2node(destination, int(h.pc.id())) nc = cell2.connect2target(h.nil) h.pc.cell(destination, nc, 1) stim1 = h.IClamp(cell1.sections[0](0.5)) stim1.delay = 250 stim1.dur = stimdur stim1.amp = -0.1 stim2 = h.IClamp(cell2.sections[0](0.5)) stim2.delay = 500 + stimdur stim2.dur = stimdur stim2.amp = -0.1 log_size = old_div(tstop, h.dt) + 1 h.tlog = h.Vector(log_size, 0) h.tlog.record(h._ref_t) h.Vlog1 = h.Vector(log_size) h.Vlog1.record(cell1.sections[0](0.5)._ref_v) h.Vlog2 = h.Vector(log_size) h.Vlog2.record(cell2.sections[0](0.5)._ref_v) h.mkgap(h.pc, h.gjlist, source, srcbranch, ggid, ggid + 1, weight) h.mkgap(h.pc, h.gjlist, destination, dstbranch, ggid + 1, ggid, weight) h.pc.setup_transfer() h.pc.set_maxstep(10.0) h.stdinit() h.finitialize(v_init) h.pc.barrier() h.tstop = tstop h.pc.psolve(h.tstop) f = open("NGFCellGJ.dat", 'w') for (t, v1, v2) in zip(h.tlog, h.Vlog1, h.Vlog2): f.write("%f %f %f\n" % (t, v1, v2)) f.close()
def test_spikes( use_mpi4py=mpi4py_option, use_nrnmpi_init=nrnmpi_init_option, file_mode=file_mode_option, ): print( "test_spikes(use_mpi4py={}, use_nrnmpi_init={}, file_mode={})".format( use_mpi4py, use_nrnmpi_init, file_mode)) h("""create soma""") h.soma.L = 5.6419 h.soma.diam = 5.6419 h.soma.insert("hh") h.soma.nseg = 3 ic = h.IClamp(h.soma(0.25)) ic.delay = 0.1 ic.dur = 0.1 ic.amp = 0.3 ic2 = h.IClamp(h.soma(0.75)) ic2.delay = 5.5 ic2.dur = 1 ic2.amp = 0.3 h.tstop = 10 h.cvode.use_fast_imem(1) h.cvode.cache_efficient(1) pc = h.ParallelContext() pc.set_gid2node(pc.id() + 1, pc.id()) myobj = h.NetCon(h.soma(0.5)._ref_v, None, sec=h.soma) pc.cell(pc.id() + 1, myobj) # NEURON run nrn_spike_t = h.Vector() nrn_spike_gids = h.Vector() # rank 0 record spikes for all gid while others # for specific gid. this is for better test coverage. pc.spike_record(-1 if pc.id() == 0 else (pc.id() + 1), nrn_spike_t, nrn_spike_gids) h.run() nrn_spike_t = nrn_spike_t.to_python() nrn_spike_gids = nrn_spike_gids.to_python() # CORENEURON run from neuron import coreneuron coreneuron.enable = True coreneuron.gpu = enable_gpu coreneuron.file_mode = file_mode coreneuron.verbose = 0 corenrn_all_spike_t = h.Vector() corenrn_all_spike_gids = h.Vector() pc.spike_record(-1, corenrn_all_spike_t, corenrn_all_spike_gids) pc.set_maxstep(10) def run(mode): h.stdinit() if mode == 0: pc.psolve(h.tstop) elif mode == 1: while h.t < h.tstop: pc.psolve(h.t + 1.0) else: while h.t < h.tstop: h.continuerun(h.t + 0.5) pc.psolve(h.t + 0.5) corenrn_all_spike_t_py = corenrn_all_spike_t.to_python() corenrn_all_spike_gids_py = corenrn_all_spike_gids.to_python() # check spikes match assert len(nrn_spike_t) # check we've actually got spikes assert len(nrn_spike_t) == len(nrn_spike_gids) # matching no. of gids if nrn_spike_t != corenrn_all_spike_t_py: print(mode) print(nrn_spike_t) print(nrn_spike_gids) print(corenrn_all_spike_t_py) print(corenrn_all_spike_gids_py) print([ corenrn_all_spike_t[i] - nrn_spike_t[i] for i in range(len(nrn_spike_t)) ]) assert nrn_spike_t == corenrn_all_spike_t_py assert nrn_spike_gids == corenrn_all_spike_gids_py if file_mode is False: for mode in [0, 1, 2]: run(mode) else: run(0) return h
print syn #Create vectors for recording potentials, currents, etc in the neural network during the simulation. vec = recordData(numNeurons, Soma) #Create random, unique simulation for the network. """ numberStimulations = random.randint(1,numNeurons-1) stim = [] for i in range(0,numberStimulations): stim.append(constructStimulations( numNeurons-1, simTime, Soma, Axon, BD, AD )) print stim """ stim = h.IClamp(Soma[0](0.5)) stim.delay = 5 stim.dur = 1 stim.amp = 1 """ stim1 = h.IClamp(Soma[7](0.5) ) stim1.delay = 5 stim1.dur = 1 stim1.amp = 10 """ # run the simulation h.load_file("stdrun.hoc") h.init() h.tstop = simTime h.run()
# Make model hoc_setup() cable = h.Section(name='cable') cable.diam = diam cable.L= length cable.cm = 100*cm # [µF/cm² = 0.01 F/m²] cable.Ra = 100*ra # [Ω cm = 0.01 Ω m] cable.nseg = int(n) cable.insert('pas') cable.g_pas = 0.0001/rm # [S/cm² = 10000 S/m²] cable.e_pas = Erev stim = h.IClamp(cable(0)) stim.delay = 0 stim.dur = tend stim.amp = iinj h.v_init = Erev # Run model v0 = h.Vector() v0.record(cable(x0)._ref_v, sample_dt) v1 = h.Vector() v1.record(cable(x1)._ref_v, sample_dt) t = h.Vector()
def main( cell_type=None, mdl_ID=0 ): modeldir = './Striatal_network_models/{}/{}'.format(cell_type, cells_dirs[cell_type][mdl_ID]) par = '{}/parameters_with_modulation.json'.format(modeldir) mech = '{}/mechanisms.json'.format(modeldir) protocols = '{}/protocols.json'.format(modeldir) morphology = glob.glob(modeldir+'/*.swc')[0] # ONLY 1 swc file / model allowed. # initiate cell cell = build.CELL( params=par, mechanisms=mech, morphology=morphology, replace_axon=True, N=40.0, ffactor=ffactor ) # ADD SPINES---- SPINES = {} ID = 0 for sec in cell.dendlist: SPINES[sec.name()] = {} for i,seg in enumerate(sec): for j in range(10): SPINES[sec.name()][ID] = spine.Spine(h,sec,seg.x) ID += 1 print(ID) #return [1,1] #h.topology() # THIS PART IS OPTIONAL oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo # set input here # set current injection with open(protocols) as file: prot = json.load(file) # select first spiking prot all_keys = sorted(prot.keys()) key = all_keys[0] i=1 while 'sub' in key: key = all_keys[i] i += 1 print(key) stim = h.IClamp(0.5, sec=cell.soma) s0 = h.IClamp(0.5, sec=cell.soma) for stim_prot, stimuli, j in zip(prot[key]['stimuli'], [stim,s0], [0,1]): stimuli.amp = stim_prot['amp'] stimuli.delay = [200,0][j] stimuli.dur = stim_prot['duration'] # oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo # record vectors: set recordings here tm = h.Vector() tm.record(h._ref_t) vm = h.Vector() vm.record(cell.soma(0.5)._ref_v) tstop = 600 # sim time (ms) h.finitialize(cell.v_init) # run simulation while h.t < tstop: h.fadvance() # save output ------------------------------------------------------------------------ time = tm.to_python() voltage = vm.to_python() return [time, voltage]
from neuron import h import axonA vvec = [h.Vector() for i in range(3)] svec, ivec = h.Vector(), h.Vector() ncl = [] axon = axonA.AxonA() axon.axon.nseg = 100 axon.axon.gnabar_hh, axon.axon.gkbar_hh, axon.axon.gl_hh, axon.axon.el_hh = 0.12, 0.036, 3e-4, -54.3 # set for all segments with underscore notation stim = h.IClamp() stim.loc(0.0, sec=axon.axon) stim.amp = 2 stim.dur = 5 ena = 50 def setena(en=50): global ena ena = en for x in axon.axon: x.ena = ena def ae(): for x, v, i in zip(np.linspace(0, 1, len(vvec)), vvec, range(len(vvec))): v.record(axon.axon(x)._ref_v) nc = h.NetCon(axon.axon(x)._ref_v, None, sec=axon.axon) ncl.append(nc) nc.threshold = -20 nc.record(svec, ivec, i + 1)
gna = pA * gnabar * mgate ** 3 * hgate gk = pA * gkbar * ngate ** 4 na_current = rxd.MultiCompartmentReaction( nai, nao, gna * (v - ena), mass_action=False, membrane=mem, membrane_flux=True ) k_current = rxd.MultiCompartmentReaction( ki, ko, gk * (v - ek), mass_action=False, membrane=mem, membrane_flux=True ) leak_current = rxd.MultiCompartmentReaction( xi, xo, pA * gl * (v - el), mass_action=False, membrane=mem, membrane_flux=True ) # stimulate stimA = h.IClamp(mycellA.soma[0](0.5)) stimA.delay = 50 stimA.amp = 5 stimA.dur = 50 stimB = h.IClamp(mycellB.soma[0](0.5)) stimB.delay = 50 stimB.amp = 5 stimB.dur = 50 # record tvec = h.Vector().record(h._ref_t) vvecA = h.Vector().record(mycellA.soma[0](0.5)._ref_v) mvecA = h.Vector().record(mgate.nodes(mycellA.soma[0](0.5))[0]._ref_value) nvecA = h.Vector().record(ngate.nodes(mycellA.soma[0](0.5))[0]._ref_value)
def mkstim(self): self.ic = h.IClamp(self.cells[0].soma(0.5)) self.ic.delay = 1 self.ic.dur = 0.2 self.ic.amp = 0.3
sec4 = h.Section() fill_section(sec) fill_section(sec2) fill_section(sec3) fill_section(sec4) sec2.connect(sec) sec3.connect(sec) sec4.connect(sec, .3, 0) nstim = 5 st_dur = 2 st_interv = 50 st_start = 1000 stims = [] for i in range(nstim): stim = h.IClamp(0.5, sec=sec) stim.delay = st_start + i * (st_interv) stim.dur = st_dur stim.amp = 1.0 / 8000 * 1200 stims.append(stim) h.CVode().active(1) h.cvode.atol(1e-6) def set_plotshape_colormap(plotshape, cmap='jet'): import matplotlib.cm s = matplotlib.cm.ScalarMappable(cmap=cmap) cmap = s.get_cmap() s.set_clim(0, cmap.N) rs, gs, bs = itertools.islice(zip(*s.to_rgba(list(range(cmap.N)))), 0, 3)
h.load_file('stdrun.hoc') fig, axi = None, None datestr = os.popen('datestring').read() def setparams(pnafjr=0.0, gnabar=0.12): soma.gnabar_nafjr = pnafjr * gnabar soma.gnabar_hh = (1.0 - pnafjr) * gnabar return 1.0 soma = h.Section(name='soma') soma.insert('hh') soma.insert('nafjr') soma.gnabar_nafjr = 0 stim = h.IClamp(soma(0.5)) stim.delay, stim.dur, stim.amp = 0, 1, 15 h.tstop = 10 fig, axi = plt.subplots(1, 1) tvec = h.Vector() vecl = [h.Vector()] tvec.record(h._ref_t) vecl[0].record(soma(0.5)._ref_v) # sim runs axi.clear() setparams(0.0) h.run() plt.plot(tvec, vecl[0], color='red', linewidth=5) setparams(1.0) h.run()
def simulate_single_param(args): """ Simulates a specific input parameter vector :param args: The parameters for the simulation: The list of excitatory presynpatic inputs, The list of inhibitory presynpatic inputs, and the input parameter dictionary :returns: The voltage trace of the simulation """ from neuron import h from neuron import gui h.load_file("nrngui.hoc") h.load_file("import3d.hoc") param_dict = args[0] hoc_code = '''h("create soma") h("access soma") h("nseg = 1") h("L = 20") h("diam = 20") h("insert pas") h("cm = 1") h("Ra = 150") h("forall nseg = 1") h("forall e_pas = -90") h("soma insert Ca_LVAst ") h("soma insert Ca_HVA ") h("soma insert SKv3_1 ") h("soma insert SK_E2 ") h("soma insert K_Tst ") h("soma insert K_Pst ") h("soma insert Nap_Et2 ") h("soma insert NaTa_t") h("soma insert CaDynamics_E2") h("soma insert Ih") h("ek = -85") h("ena = 50") h("gIhbar_Ih = 0.0002") h("g_pas = 1.0 / 12000 ") h("celsius = 36") ''' exec(hoc_code) exec('h("tstop = {}")'.format(simulation_length)) exec('h("v_init = {}")'.format(v_init)) for key in param_dict.keys(): h(key + " = " + str(param_dict[key])) iclamp = h.IClamp(0.5) iclamp.delay = 500 iclamp.dur = 1400 amp = 0.05 iclamp.amp = amp im = h.Impedance() h("access soma") h("nseg = 1") im.loc(0.5) im.compute(0) Ri = im.input(0.5) semitrial_start = time.time() ### Set the protocol h.finitialize() ### Simulate! voltageVector = h.Vector() voltageVector.record(eval("h.soma(0.5)._ref_v")) timeVector = h.Vector() timeVector.record(h._ref_t) h.run() timeVector = np.array(timeVector) voltageVector = np.array(voltageVector) trace = {} trace['T'] = timeVector[4000:] trace['V'] = np.array(voltageVector)[4000:] trace['stim_start'] = [500] trace['stim_end'] = [1900] del voltageVector, timeVector return trace
from neuron import h from pylab import * import timeit start = timeit.default_timer() cell = h.Section() cell.insert('hha2') stimulus = h.IClamp(0.5) stimulus.delay = 100 stimulus.dur = 800 stimulus.amp = 7 trec = h.Vector() vrec = h.Vector() trec.record(h._ref_t) vrec.record(cell(0.5)._ref_v) stimuli_rec = h.Vector() stimuli_rec.record(stimulus._ref_i) h.load_file("stdrun.hoc") h.init() h.v_init = -65 h.tstop = 1000 before_run = timeit.default_timer() print('initial time:%f' % (before_run - start))
from neuron import h # create pre-and post-synaptic sections pre = h.Section() post = h.Section() for sec in pre, post: sec.insert('hh') # inject current in the pre-synaptic section stim = h.IClamp(0.5, sec=pre) stim.amp = 10.0 stim.delay = 5.0 stim.dur = 5.0 # create a synapse in the pre-synaptic section syn = h.ExpSyn(0.5, sec=post) # connect the pre-synaptic section to the # synapse object nc = h.NetCon(pre(0.5)._ref_v, syn, sec=pre) vec = {} for var in 'v_pre', 'v_post', 'i_syn', 't': vec[var] = h.Vector() # record the membrane potentials and # synaptic currents vec['v_pre'].record(pre(0.5)._ref_v) vec['v_post'].record(post(0.5)._ref_v) vec['i_syn'].record(syn._ref_i)
membrane_flux=True) k_current = rxd.MultiCompartmentReaction(ki, ko, gk * (v - ek), mass_action=False, membrane=mem, membrane_flux=True) leak_current = rxd.MultiCompartmentReaction(xi, xo, pA * gl * (v - el), mass_action=False, membrane=mem, membrane_flux=True) # stimulate stimA = h.IClamp(somaA(0.5)) stimA.delay = 50 stimA.amp = 1 stimA.dur = 50 stimB = h.IClamp(somaB(0.5)) stimB.delay = 50 stimB.amp = 1 stimB.dur = 50 # record tvec = h.Vector().record(h._ref_t) vvecA = h.Vector().record(somaA(0.5)._ref_v) mvecA = h.Vector().record(mgate.nodes(somaA(0.5))[0]._ref_value) nvecA = h.Vector().record(ngate.nodes(somaA(0.5))[0]._ref_value)
##-----------------------------------------------------------------## ##----Add a bit of the Ornstein-Uhlenbeck noise (colored noise)----## for sec in h.allsec(): sec.insert("OU") sec.tau_OU = 20 #seems to reduce noise if increase sec.D_OU = 0.025 ##-----------------------------------------------------------------## ##------------------------Recording conditions---------------------## soma.push() #record voltage at the soma #h.celsius = 22 #typical lab temperature h.tstop = 5000 h.xopen("de3_1.ses") ic = h.IClamp(0.5, sec=axthick) #current injection to axthick w/ electrode if want ic.delay = 100 ic.dur = 25000 ic.amp = 0.5 #current amplitude ##-----------------------------------------------------------------## ##--------------------US-activated channel-------------------------## soma.insert("uschan") soma.onset_uschan = 5000 #US time on soma.dur_uschan = 10000 #duration of US stimulus soma.tact_uschan = 20000 # tau activation US-activated channel ##--------------------------------------------------------------## ##----Local temperature fluctuation ----##
h.pt3dadd(10, 10, 15, 3, sec=dend3) h.pt3dadd(15, 10, 15, 2, sec=dend3) h.pt3dadd(5, 5, 5, 1, sec=dend3) dend4 = h.Section() h.pt3dadd(10, 10, 5, 3, sec=dend4) h.pt3dadd(5, 10, 5, 4, sec=dend4) h.pt3dadd(5, 6, 5, 5, sec=dend4) dend3.connect(soma1, 0, 0) dend4.connect(soma1, 1, 0) #Display what happens when you drive a current through the neuron.. for sec in soma, dend1, dend2, soma1, dend3, dend4: sec.insert('hh') # inject current in the pre - synaptic section stim = h.IClamp(0.5, sec=soma) stim.amp = 10.0 stim.delay = 5.0 stim.dur = 5.0 stim1 = h.IClamp(0.5, sec=soma1) stim1.amp = 10.0 stim1.delay = 5.0 stim1.dur = 5.0 vec = {} for var in 'v_pre ', 'v_post ', 't ': vec[var] = h.Vector() # record the membrane potentials vec['v_pre '].record(soma(0.5)._ref_v) vec['v_post '].record(soma1(0.5)._ref_v)
# open library (channel distributions etc) with open(specs[cell_type]['lib'], 'rb') as f: model_sets = pickle.load(f, encoding="latin1") # simulate model(s) OUT = {} for cell_index in model_iterator: # initiate cell cell = build.MSN(params=specs[cell_type]['par'], morphology=specs[cell_type]['morph'], variables=model_sets[cell_index]['variables']) # set current injection rheobase = model_sets[cell_index]['rheobase'] Istim = h.IClamp(0.5, sec=cell.soma) Istim.delay = 100 Istim.dur = 1000 Istim.amp = (rheobase) * 1e-3 # record vectors tm = h.Vector() tm.record(h._ref_t) vm = h.Vector() vm.record(cell.soma(0.5)._ref_v) # run simulation h.finitialize(-80) # run simulation while h.t < 1000: