def __init__(self, post_cell, info): """ info is a dict """ pre_cells = [] synapses = [] j = 0 xmtr = {} for nsgc, sgc in enumerate(range(info['n_sgc'])): pre_cells.append(cells.DummySGC(cf=info['cf'], sr=info['sr'])) if synapseType == 'simple': synapses.append(pre_cells[-1].connect(post_cell, type=synapseType)) synapses[-1].terminal.netcon.weight[0] =info['gmax']*2.0 elif synapseType == 'multisite': synapses.append(pre_cells[-1].connect(post_cell, post_opts={'AMPAScale': 2.0, 'NMDAScale': 2.0}, type=synapseType)) for i in range(synapses[-1].terminal.n_rzones): xmtr['xmtr%04d'%j] = h.Vector() xmtr['xmtr%04d'%j].record(synapses[-1].terminal.relsite._ref_XMTR[i]) j = j + 1 synapses[-1].terminal.relsite.Dep_Flag = False # no depression in these simulations pre_cells[-1].set_sound_stim(info['stim'], seed = info['seed'] + nsgc, simulator=info['simulator']) Vm = h.Vector() Vm.record(post_cell.soma(0.5)._ref_v) rtime = h.Vector() rtime.record(h._ref_t) h.tstop = 1e3*info['run_duration'] # duration of a run h.celsius = info['temp'] h.dt = info['dt'] post_cell.cell_initialize() info['init']() h.t = 0. h.run() return {'time': np.array(rtime), 'vm': Vm.to_python(), 'xmtr': xmtr, 'pre_cells': pre_cells, 'post_cell': post_cell, 'synapses': synapses}
def getfi(amp, simiter): h.tstop = 500 # to match synaptic input runs h.tsamp = h.tstop / h.dt + 1 tsamp = int(h.tsamp) # 'background' injection npy.random.seed(int(simiter + h.luckyoffset)) icr = h.IClamp(0.5, sec=h.soma) icr.dur = h.tstop if numbranches == 2: icmean = .75 if numbranches == 8: icmean = 0 icstd = 1 icvals = icmean + icstd * npy.random.randn(tsamp) icrand = h.Vector(tsamp) for i in xrange(tsamp): icrand.x[i] = icvals[i] icrand.play(icr._ref_amp, h.dt) # do current injection run ic = h.IClamp(0.5, sec=h.soma) ap = h.APCount(0.5, sec=h.soma) ic.delay = 0 ic.dur = h.tstop ic.amp = amp h.run() return ap.n * 1000. / h.tstop
def gabaInit(excmin): oldtstop = h.tstop h.tstop = 5000 # Simulation time print "Setting initial glutamatergic synapse..." # Set excitatory conductances with minimal tone topo.excGset(BPsyn, gmax=excmin, gmin=excmin, synapse_type=synapse_type, tau=BPsyn_tau) if is_spatiotemporal: topo.apply_spatiotemporal_synaptic_input(BPsyn, dend_input_segments, BPtau1, BPtau2) stim.set_stimulus(BPsyn, stimulus_type, t_es, synapse_type, **stim_param) print "Setting gabaergic synapse parameters..." topo.gabaGset(gabasyn, synM, gabaGmax, gabaGmin, k1, k2, th1, th2) param_log() print "Parameters OK. Steady-state simulation started..." nrn_init(v_init) print "RUN, Neuron...RUN!" h.run() print "Saving steady-state outputs..." initsc1 = [syn.sc1 for syn in gabasyn] initsc2 = [syn.sc2 for syn in gabasyn] print "Steady-state simulation finished!" h.tstop = oldtstop return initsc1, initsc2
def RunSim(self): num_iters = 60 recovered_thresh = -40 # Prepare simulation record_loc_idx = int(self.n_exc/2) record_loc = self.exc_locs[record_loc_idx] # Prepare recording vectors t = h.Vector(); t.record(h._ref_t) shaft_v = h.Vector(); shaft_v.record(self.dend(record_loc)._ref_v) if self.soma: soma_v = h.Vector(); soma_v.record(self.soma(0.5)._ref_v) else: soma_v = [] # Reset soma_v between simulations if self.spine_heads: spine_v = h.Vector(); spine_v.record(self.spine_heads[record_loc_idx](1)._ref_v) else: spine_v = [] # Reset spine_v between simulations # Run simulation (hoc interpreter commands) h.finitialize() # Initialize gating mechanisms h.run() # Run simulation # Plot traces self.vectors['t'] = t self.vectors['shaft_v'] = shaft_v self.vectors['soma_v'] = soma_v self.vectors['spine_v'] = spine_v
def run(tstop=1000, dt=0, V=-65): h.load_file('stdrun.hoc') #h.finitialize(V) if dt > 0: h.dt = dt h.tstop = tstop h.run()
def run_and_save_simulation(shaft_ref, x_shaft, on_spine=False, PLOT_RES=1): V_Shaft = h.Vector() V_Soma = h.Vector() tvec = h.Vector() V_Soma.record(HCell.soma[0](0.5)._ref_v) V_Shaft.record(shaft_ref.sec(x_shaft)._ref_v) tvec.record(h._ref_t) if on_spine: V_Spine = h.Vector() V_Spine.record(HCell.spine[1](1)._ref_v) h.v_init = V_INIT h.init(h.v_init) h.run() if (PLOT_RES > 0): if on_spine: plt.close('all') plt.plot(np.array(tvec), np.array(V_Soma), c=c_soma) plt.plot(np.array(tvec), np.array(V_Shaft), c=c_shaft) if on_spine: plt.plot(np.array(tvec), np.array(V_Spine), c=c_spine) plt.xlim(0, 50) M = np.array([ np.array(tvec), np.array(V_Soma), np.array(V_Shaft), np.array(V_Spine) ]).T np.savetxt("example_stimulation of_a_spine_connected_to_dend_62.txt", M)
def simulatepar(delay, dur, length, std, offset, amp, freq, dt, tau, mu, loc, simdur, init, cel, seed, loop): soma, axon = Mcm.create_sec('soma', 'axon') Mcm.define_geometry(soma, 30, 20, 1) Mcm.define_geometry(axon, length, 1, 11) Mcm.build_topology_axso(axon, soma, 0) Mcm.define_biophysics(2, soma, 250, 400, 0.3e-3, .75, 150, -65, 55, -70, -25., 6., -35., 6., -15., 4.) Mcm.define_biophysics(2, axon, 0, 500, 0.3e-3, .75 * 0.75, 150, -65, 55, -70, -25., 6., -35., 6., -15., 4.) axon(0.9).gbar_na = 1000 * 15 counts = h.Vector() apc = h.APCount(soma(0.5)) apc.thresh = -15 apc.record(counts) stim = attach_noise_sin_clamp(soma, delay, dur, offset, amp, freq, dt, tau, std, mu, loc, seed) # soma_vec, axon_vec, i_inj_vec, t_vec = set_recording_vectors(stim, soma, axon) h.dt = dt h.tstop = simdur h.v_init = init h.celsius = cel h.run() filename = './OUTPUT/spiketrain5Hzmfr' + str(length) + 'length' + str( freq) + 'freq' + str(std) + 'std' + str(seed) + 'seed' + str( loop) + 'loop.txt' writetofile(filename, counts) return 0
def test_spikes(): ref_spikes = np.array([1.05]) h('''create soma''') h.load_file("stdrun.hoc") h.soma.L = 5.6419 h.soma.diam = 5.6419 h.soma.insert("hh") ic = h.IClamp(h.soma(0.5)) ic.delay = 0.5 ic.dur = 0.1 ic.amp = 0.3 v = h.Vector() v.record(h.soma(0.5)._ref_v, sec=h.soma) tv = h.Vector() tv.record(h._ref_t, sec=h.soma) nc = h.NetCon(h.soma(0.5)._ref_v, None, sec=h.soma) spikestime = h.Vector() nc.record(spikestime) h.run() simulation_spikes = spikestime.to_python() assert np.allclose(simulation_spikes, ref_spikes)
def run(self): """Run the simulation: if beginning from a blank state, then will use h.run(), if continuing from the saved state, then will use h.continuerun() """ for mod in self._sim_mods: mod.initialize(self) self.start_time = h.startsw() s_time = time.time() pc.timeout(0) pc.barrier() # wait for all hosts to get to this point io.log_info( 'Running simulation for {:.3f} ms with the time step {:.3f} ms'. format(self.tstop, self.dt)) io.log_info('Starting timestep: {} at t_sim: {:.3f} ms'.format( self.tstep, h.t)) io.log_info('Block save every {} steps'.format(self.nsteps_block)) if self._start_from_state: h.continuerun(h.tstop) else: h.run(h.tstop) # <- runs simuation: works in parallel pc.barrier() for mod in self._sim_mods: mod.finalize(self) pc.barrier() end_time = time.time() sim_time = self.__elapsed_time(end_time - s_time) io.log_info('Simulation completed in {} '.format(sim_time))
def main(): soma = h.Section() soma.insert('pas') soma.L = 100 soma.diam = 100 weight_min = 0.005 weight_max = 0.05 mu = (np.log(weight_min)+np.log(weight_max))/2 sigma = (np.log(weight_max)-mu)/3 weights = np.sort(np.exp(np.random.normal(mu,sigma,size=200))) synapses = [AMPASynapse(soma, 0.5, 0, w) for w in weights] for i,syn in enumerate(synapses): syn.set_presynaptic_spike_times([10+i*50]) rec = {} for lbl in 't','v','g': rec[lbl] = h.Vector() rec['t'].record(h._ref_t) rec['v'].record(soma(0.5)._ref_v) rec['g'].record(syn.syn._ref_g) h.load_file('stdrun.hoc') h.v_init = -70 h.celsius = 37 h.tstop = len(weights)*50 + 100 h.run() import pylab as p p.subplot(2,1,1) p.plot(rec['t'],rec['v'],'k') p.ylabel('Voltage (mV)') p.subplot(2,1,2) p.plot(rec['t'],rec['g'],'r') p.xlabel('Time (ms)') p.ylabel('Conductance (uS)') p.show()
def test_simple_synaptic_input(): soma = h.Section() soma.insert("hh") soma.insert("pas") tl = TargetLocation(soma, 0.5) proc = h.ExpSyn ac = ArtificialCell() fire_times = np.linspace(0,50,10) firetimes = h.Vector(fire_times) ac.setFireTimes(firetimes) ic = InputConnection(ac, tl, proc) v = h.Vector() v.record(soma(0.5)._ref_v) h.tstop = 100 h.run() test_result = np.array(v) correct = np.load("test_simple_synaptic_input_data.npy") print sum(abs(test_result - correct)) #pyl.plot(test_result) #pyl.plot(correct) #pyl.show() assert np.all(test_result == correct)
def simulate(self, tstop=100.0, dendrite_to_record=False, pandas=False): if dendrite_to_record: for section in self.dendrites: if section.name() == dendrite_to_record: self.dendrite = section if self.dend_to_patch: print 'havent overwritten the simulate rdend argument - use it!' h.load_file('stdrun.hoc') self.rec = {} for label in 't', 'v', 'vdend': self.rec[label] = h.Vector() self.rec['t'].record(h._ref_t) self.rec['vdend'].record(self.dendrite(0.5)._ref_v) self.rec['v'].record(self.root(0.5)._ref_v) h.tstop = tstop h.v_init = self.leak_reversal h.celsius = 32.0 h.dt = 0.01 h.run() v_dend = self.rec['vdend'].to_python() v_soma = self.rec['v'].to_python() t = self.rec['t'].to_python() results = pd.DataFrame(np.array([t, v_soma, v_dend]).T, columns=['time', 'v_soma', 'v_dend']) if pandas: return results else: if dendrite_to_record: return np.array(v_soma), np.array(t), np.array(v_dend) else: return np.array(v_soma), np.array(t)
def passive_soma(quad, show=False): """ Creates the model with basic pyramidal passive properties. """ # Load the hoc into neuron h('xopen(%s)' %quad.hocfile) h.load_file('stdrun.hoc') seclist = list(h.allsec()) for sec in seclist: sec.insert('pas') sec.Ra = 200. # Current injection into soma or tip soma_sec = return_soma_seg(quad, h) stim_loc = 0. stim = h.IClamp(stim_loc, sec=soma_sec) stim.delay = 1 # ms stim.dur = 1 # ms stim.amp = 20 # nA # Run sim and record data (v, labels) = ez_record(h) # PyNeuron to record all compartments t, I = h.Vector(), h.Vector() t.record(h._ref_t) I.record(stim._ref_i) h.init() h.tstop = 10 # s? h.run() v = ez_convert(v) # Convert v to numpy 2D array # If show, plot, else just return v if show:
def run_cclamp_somatic_feature(self, section_rec, loc_rec): exec("self.sect_loc=h." + str(section_rec) + "(" + str(loc_rec) + ")") print "- running model", self.name rec_t = h.Vector() rec_t.record(h._ref_t) rec_v = h.Vector() rec_v.record(self.sect_loc._ref_v) h.stdinit() dt = 0.025 h.dt = dt h.steps_per_ms = 1 / dt h.v_init = -65 h.celsius = 34 h.init() h.tstop = 1600 h.run() t = numpy.array(rec_t) v = numpy.array(rec_v) return t, v
def getRMP(self, parameters, debug=False): if not self.stop: # Simulation parameters h.load_file('stdrun.hoc') h.load_file('negative_init.hoc') tstop = 100 dt = 0.025 h.stdinit() h.celsius = 37.0 h.tstop = tstop h.v_init = -65 # Instantiate and parameterize cells testCell = cell.Cell(0, (0, 0), self.synvars, 'granulecell', 'output0_updated.swc') self.parameterizeCell(testCell, parameters) # Instrument cells self.RMPv = h.Vector() self.RMPv.record(testCell.c.soma[0](0.5)._ref_v) # Run simulation h.run() # Get RMP self.RMP = self.RMPv[-1] if debug: return [np.array([self.RMP]), np.array([self.RMPv])] else: return np.array([self.RMP]) else: return 1e9
def simulate(tstop=25): """Initialize and run a simulation. :param tstop: Duration of the simulation. """ h.tstop = tstop h.run()
def p(nm, pm=None): global name, vviv, params, vvset import izhi2007Figs as iz07fig if pm is None: pm = choices[izhtype][2][nm] name, params = nm, pm if newmodel(): izh.C, izh.k, izh.vr, izh.vt, izh.vpeak, izh.a, izh.b, izh.c, izh.d, izh.celltype = params h.tstop = 1000 else: izh.a, izh.b, izh.c, izh.d, vviv, h.tstop = params g.size(0, h.tstop, -100, 50) try: if newmodel(): graphx() # interviews graphics iz07fig.recorder( cell07, choices[izhtype][1]()) # vectors to draw under matplotlib iz07fig.test1(cell07, nm, izhtype) else: iz07fig.closeFig() graphx() playinit() h.run() except: print sys.exc_info()[0], ' :', sys.exc_info()[1]
def run_syn(self): # initiate recording rec_t = h.Vector() rec_t.record(h._ref_t) rec_v = h.Vector() rec_v.record(h.soma(0.5)._ref_v) rec_v_dend = h.Vector() rec_v_dend.record(h.dendrite[self.ndend](self.xloc)._ref_v) print "- running model", self.name # initialze and run #h.load_file("stdrun.hoc") h.stdinit() dt = 0.025 h.dt = dt h.steps_per_ms = 1 / dt h.v_init = -65 h.celsius = 34 h.init() h.tstop = 300 h.run() # get recordings t = numpy.array(rec_t) v = numpy.array(rec_v) v_dend = numpy.array(rec_v_dend) return t, v, v_dend
def test(infile='/data/rays3/ggn/olfactory_network/mb_net_UTC2018_09_19__00_49_12-PID4273-JID9673664.h5'): with h5.File(infile, 'r') as fd: pn_spikes = load_pn_spikes(fd) pns, spikes = zip(*pn_spikes) spikes[0] = np.array([1.0, 10.0, 20.0]) stimvecs, vecstims = create_pn_output(spikes) kcs = create_kcs(fd) kc_name_sec_dict = {kc.soma.name(): kc.soma for kc in kcs} ggn = create_ggn() ggn_name_sec_dict = {sec.name(): sec for sec in ggn.all} nc_pn_kc, syn_pn_kc = create_pn_kc_conn(fd, {pn: vecstim for pn, vecstim in zip(pns, vecstims)}, kc_name_sec_dict) for nc in nc_pn_kc: assert nc.valid() syn_ggn_kc = create_ggn_kc_conn(fd, kc_name_sec_dict, ggn_name_sec_dict) syn_kc_ggn, nc_kc_ggn = create_kc_ggn_conn(fd, kc_name_sec_dict, ggn_name_sec_dict, path=kc_ggn_alphaL_syn_path) # kc_st = {kc: np.random.random_sample(5) for kc in np.random.choice(kcs, size=5, replace=False)} # pn_st = {pn: np.random.random_sample(5) for pn in np.random.choice(pns, size=5, replace=False)} # ggn_vm = {sec: np.arange(10) for sec in np.random.choice(list(ggn_name_sec_dict.keys()), # size=5, replace=False)} # kc_vm = {kc: np.random.random_sample(5) for kc in np.random.choice(kcs, size=5, replace=False)} data = setup_recording(kcs, ggn, n_kc_vm=10, n_ggn_vm=10, t=0.25) h.tstop = 100 h.init() h.run() kc_st = {kc: st for kc, (nc, st) in data['kc_spikes'].items()} save(infile, 'test.h5', kc_st, pn_spikes, data['kc_vm'], data['ggn_output_vm'], data['ggn_alphaL_input_vm'], data['ggn_basal_vm'], None, data['time']) cfg.logger.info('finished')
def synapses_vs_weights(filename="distal", param_list=None): """Clump synapses and vary synapse numbers and synapse weights. param_list contains tuples of (exc_syn, inh_syn, exc_weight, inh_weight, clump) """ import itertools syn_list = param_list if not syn_list: syn_list = itertools.product([1, 10, 100], [1, 10, 100], # E, I synapse numbers [1, 5, 10], [1, 5, 10], # E, I synapse weights [1, 10, 100] # clumping ) syn_list = [(10, 10, 1, 1, 10), (10, 10, 5, 5, 10), (10, 10, 10, 20, 10), (10, 100, 18, 6, 10), (10, 10, 18, 60, 10), (10, 10*100, 18, 6, 10), (10, 10, 18, 6*100, 10)] load_file(filename) icl_rec_vec = h.Vector() icl_rec_vec.record(h.ldend(0.5)._ref_icl) h.tstop = 500 h("forall{cli=4.25}") h.hoc_stdout("synapses_vs_weights.txt") base_gmax = 0.00005 # uS inh_hz = 10 for gmax_weight in [False]: print("gmax_weight: {} ".format(gmax_weight)) for (i, (exc, inh, exc_weight, inh_weight, clump)) in enumerate(syn_list): h.newSynapses(exc, inh) h.clumpSynapses(clump) print("clumped") g_rec_vec_list = list() for g in range(int(h.ninh)): g_rec_vec = h.Vector() g_rec_vec.record(h.GABAa[g]._ref_g) g_rec_vec_list.append(g_rec_vec) h.exHz(10000, 1, exc_weight) if gmax_weight: h.inHz(inh_hz, 1, 1) h.gmax_GABAa = base_gmax*inh_weight else: h.inHz(inh_hz, 1, inh_weight) print(syn_list[i]) icl_mean = [] icl_stdev = [] spikes_mean = [] g_total_mean = [] for k in range(5): h.run() icl_mean.append(icl_rec_vec.mean()*1e6) icl_stdev.append(icl_rec_vec.stdev()*1e6) spikes_mean.append(h.apc.n) total_g = 0 for g_rec_vec in g_rec_vec_list: total_g += g_rec_vec.mean() g_total_mean.append(total_g) print("icl_mean: \tmean:\t {} \tstd:\t {}".format(np.mean(icl_mean), np.std(icl_mean))) print("icl_stdev: \tmean:\t {} \tstd:\t {}".format(np.mean(icl_stdev), np.std(icl_stdev))) print("g total: \tmean:\t {} \tstd:\t {}".format(np.mean(g_total_mean), np.std(g_total_mean))) print("spikes: \tmean:\t {} \tstd:\t {}".format(np.mean(spikes_mean), np.std(spikes_mean)))
def simulatepar(delay, dur, Ra, std, offset, amp, freq, dt, tau, mu, loc, simdur, init, cel, seed): soma, axon = Mcm.create_sec('soma', 'axon') Mcm.define_geometry(soma, 30, 20, 5) Mcm.define_geometry(axon, 50, 1, 11) Mcm.build_topology_axso(axon, soma, 0) Mcm.define_biophysics(2, soma, 800, 320, 1 / 30000, 0.75, 150, -70, 60, -80) Mcm.define_biophysics(2, axon, 0, 1600, 1 / 30000, 0.75 * 0.75, 150, -70, 60, -80) axon(Ra).gbar_na = 8000 * 15 counts = h.Vector() apc = h.APCount(soma(0.5)) apc.thresh = 0 apc.record(counts) stim = attach_noise_sin_clamp(soma, delay, dur, offset, amp, freq, dt, tau, std, mu, loc, seed) # soma_vec, axon_vec, i_inj_vec, t_vec = set_recording_vectors(stim, soma, axon) h.dt = dt h.tstop = simdur h.v_init = init h.celsius = cel h.run() filename = './OUTPUT/spiketrain5Hzmfr' + str(Ra) + 'Ra' + str( freq) + 'freq' + str(std) + 'std' + str(seed) + 'seed.txt' writetofile(filename, counts) return 1
def scalar_bistable(rxdstr): if rxdstr == 'rxd': from neuron import rxd else: from neuron import crxd as rxd h.load_file('stdrun.hoc') s = h.Section(name='s') s.nseg = 101 cyt = rxd.Region(h.allsec()) c = rxd.Species(cyt, name='c', initial=lambda node: 1 if 0.4 < node.x < 0.6 else 0, d=1) r = rxd.Rate(c, -c * (1 - c) * (0.3 - c)) h.finitialize() h.run() #check the results result = h.Vector(c.nodes.concentration) cmpV = h.Vector(scalar_bistable_data[rxdstr]) cmpV.sub(result) cmpV.abs() if cmpV.sum() < 1e-6: sys.exit(0) sys.exit(-1)
def FiringOnset(leftI, rightI, precision, apc, stim, T, fr_set): import neuron from neuron import h from I_proc import stimulate while ((rightI - leftI) > precision * max([abs(rightI), abs(leftI)])): print("leftI is %f, rightI is %f" % (leftI, rightI)) print("rightI-leftI: %f , precision: %f \n" % ((rightI - leftI), precision)) h.finitialize() h.fcurrent() h.frecord_init() apc.n = 0 mean = (leftI + rightI) / 2 print('mean is %f' % (mean)) h.stim = stimulate([0, stim, mean]) h.tstop = T h.run() fr = apc.n / float(T / 1000) print('fr is %f' % (fr)) if (fr <= fr_set): leftI = mean # If the firing rate is too small, we will replace lowerbound with middle point else: rightI = mean # If the firing rate is too large, we will replace upperbound with middle point if fr_set > 0: return rightI else: return leftI
def run_cclamp(self): print "- running model", self.name rec_t = h.Vector() rec_t.record(h._ref_t) rec_v = h.Vector() rec_v.record(h.soma[0](0.5)._ref_v) h.stdinit() dt = 0.025 h.dt = dt h.steps_per_ms = 1 / dt h.v_init = -65 h.celsius = 34 h.init() h.tstop = 1600 h.run() t = numpy.array(rec_t) v = numpy.array(rec_v) return t, v
def simulation(tstop, with_time = False): """ runs the simulation and returns the current and time vectors as Numpy arrays """ h.load_file('stdrun.hoc') h.v_init = -70 h.tstop = tstop VC_patch.dur1 = tstop # define vectors current = h.Vector() current.record(VC_patch._ref_i) if with_time is True: time = h.Vector() time.record(h._ref_t) h.run() if with_time is True: return (time, np.array(current)*1000.) else: return np.array(current)*1000.
def get_passive_properties(soma): v_init = h.v_init = -60 stim = h.IClamp(soma(0.5)) stim.delay = 100.0 #ms stim.dur = 500.0 #ms tstop = h.tstop = 1000 #ms h.dt = 0.025 q = int(tstop / h.dt) t_i = int((stim.delay + stim.dur - 5) / h.dt) t_r = int((stim.delay - 1) / h.dt) stim.amp = -0.1 v0_vec = h.Vector() t_vec = h.Vector() v0_vec.record(soma(0.5)._ref_v) t_vec.record(h._ref_t) h.run() dt_V = v0_vec[t_i] - v0_vec[t_r] props = {} props["R_in"] = dt_V / stim.amp props["tau"] = soma.cm * props["R_in"] props["Vrest"] = v0_vec[30000] return props
def get_F_properties(soma, I_0): f_prop = {} v_init = h.v_init = -60 stim = h.IClamp(soma(0.5)) stim.delay = 100.0 #ms stim.dur = 500.0 #ms tstop = h.tstop = 1000 #ms h.dt = 0.025 freq = [] count = 0 for stim.amp in np.arange(I_0, I_0 + 0.41, 0.1): v0_vec = h.Vector() t_vec = h.Vector() v0_vec.record(soma(0.5)._ref_v) t_vec.record(h._ref_t) nc = h.NetCon(soma(0.5)._ref_v, None, sec=soma) nc.threshold = 0 spvec = h.Vector() nc.record(spvec) h.run() if len(spvec) > 1 and spvec.x[0] > 100: #freq.append(len(spvec)/stim.dur) f_prop["F" + str(count)] = len(spvec) / stim.dur count = count + 1 return f_prop
def test_direct_memory_transfer(): h('''create soma''') h.soma.L = 5.6419 h.soma.diam = 5.6419 h.soma.insert("hh") ic = h.IClamp(h.soma(.5)) ic.delay = .5 ic.dur = 0.1 ic.amp = 0.3 h.cvode.use_fast_imem(1) h.cvode.cache_efficient(1) v = h.Vector() v.record(h.soma(.5)._ref_v, sec=h.soma) i_mem = h.Vector() i_mem.record(h.soma(.5)._ref_i_membrane_, sec=h.soma) tv = h.Vector() tv.record(h._ref_t, sec=h.soma) h.run() vstd = v.cl() tvstd = tv.cl() i_memstd = i_mem.cl() pc = h.ParallelContext() h.stdinit() pc.nrncore_run("-e %g" % h.tstop, 0) assert (tv.eq(tvstd)) assert (v.cl().sub(vstd).abs().max() < 1e-10) assert (i_mem.cl().sub(i_memstd).abs().max() < 1e-10)
def corrected_experimental_protocol_with_linear_gpas_distr( Ra=157.3621, gpas_soma=0.000403860792, k=0.001, cm=3., dt=0.1): # -- Biophysics -- # Sec parameters and conductance for sec in h.allsec(): sec.Ra = Ra # Ra is a parameter to infer sec.cm = cm # parameter optimisation algorithm found this sec.v = 0 sec.insert('pas') sec.g_pas = gpas_soma # gpas is a parameter to infer for seg in sec: h('soma distance()') dist = (h.distance(seg.x)) gpas = gpas_soma * (1 + k * dist) if gpas < 0: seg.g_pas = 0 print("WARNING!!! 'gpas' is in negative! Corrected to zero.") else: seg.g_pas = gpas sec.e_pas = 0 # Print information #h.psection() # Stimulus stim1 = h.IClamp(h.soma(0.01)) stim1.delay = 199.9 stim1.amp = 0.5 stim1.dur = 3.1 stim2 = h.IClamp(h.soma(0.01)) stim2.delay = 503 stim2.amp = 0.01 stim2.dur = 599.9 # Run simulation -> # Set up recording Vectors v_vec = h.Vector() # Membrane potential vector t_vec = h.Vector() # Time stamp vector v_vec.record(h.soma(0.5)._ref_v) t_vec.record(h._ref_t) # Simulation duration and RUN h.tstop = (15000 - 1) * dt # Simulation end h.dt = dt # Time step (iteration) h.steps_per_ms = 1 / dt h.v_init = 0 h.finitialize(h.v_init) h.init() h.run() t = t_vec.to_python() v = v_vec.to_python() return t, v
def simulate(celsius=20, tstop=20, dt=0.001): #Initialize and run a simulation. # :param tstop: Duration of the simulation. # :param dt: time resolution (ms). h.celsius = celsius h.tstop = tstop h.dt = dt h.run()
def run_exp(HCell, h): h.init(h.v_init) Vvec = h.Vector() Vvec.record(HCell.soma[0](0.5)._ref_v) h.run() np_v = np.array(Vvec) np_v = np_v[1:] # remove the 0 timing that is not part of the EPSPs data return np_v
def runSimulation_v2(young_chem1_con1, young_elec1_con1, numNeurons, fileIndex, simTime, inhibInd, age, delay): """ This defintion will run the simulation. """ print 'Run simulation!!' #Create neurons in the networks. numSegs = 3 Neurons = [] for i in range(0, numNeurons): Neurons.append(h.Section()) #Set biophysics for the different neural structures. IAF will contain all data pertaining to the refractory period between spikes. for sec in Neurons: sec.insert('hh') sec.nseg = numSegs #Import connectivity between neurons. gapsYoung = constructConnections1(young_elec1_con1, numNeurons, Neurons) synYoung, ncYoung = constructConnections2(young_chem1_con1, numNeurons, Neurons, inhibInd, delay) #Create vectors for recording potentials, currents, etc in the neural network during the simulation. vec = recordData(numNeurons, Neurons) #Stimulate system with random noise. stims = [] for i in range(0, numNeurons): stims.append(makeStimulus(Neurons[i], simTime)) #Run the simulation. h.load_file("stdrun.hoc") h.init() h.tstop = simTime h.run() #Write results. if age == 1: file = open(path + 'spikesYoung_2_' + fileIndex + '.txt', "wb") elif age == 2: file = open(path + 'spikesOld1_2_' + fileIndex + '.txt', "wb") else: file = open(path + 'spikesOld2_2_' + fileIndex + '.txt', "wb") print "Writing results to..." print file for j in range(0, numNeurons): canFire = 1 var = str(j + 1) for i in range(0, len(vec['t '])): if (vec[var][i] > 0) & (canFire == 1): file.write(str(j + 1) + "\n") file.write(str(vec['t '][i]) + "\n") canFire = 0 if (vec[var][i] < 0): canFire = 1 file.close()
def runSimulation(young_chem1_con1, young_elec1_con1, numNeurons, fileIndex, simTime, inhibInd, age, delay, stimInterval, con): """ This defintion will run the simulation. """ print 'Run simulation!!' # Load file to make model regular spiking excitory cells. h.load_file ("sPY_template") # Load file to make model fast spiking inhibitory cells. h.load_file ("sIN_template") #Create neurons in the networks. numSegs = 3 Neurons = [] for i in range(0, numNeurons): if i < inhibInd: neuron = h.sPY() Neurons.append(neuron) else: neuron = h.sIN() Neurons.append(neuron) #Import connectivity between neurons. gapsYoung = constructConnections1( young_elec1_con1, numNeurons, Neurons) synYoung,ncYoung = constructConnections2( young_chem1_con1, numNeurons, Neurons, inhibInd, delay ) #Create vectors for recording potentials, currents, etc in the neural network during the simulation. vec = recordData( numNeurons, Neurons ) #Stimulate system with random noise. stims = [] for i in range(0,numNeurons): stims.append(makeStimulus(Neurons[i],simTime,int(stimInterval))) #Run the simulation. h.load_file("stdrun.hoc") h.init() h.tstop = simTime h.run() #Write results. file = open(path + 'spikes' + str(con) + '_' + str(age) + '_' + str(fileIndex) + '_' + str(stimInterval) + '.txt',"wb") print "Writing results to..." print file for j in range(0,numNeurons): canFire = 1 var = str(j+1) for i in range(0,len(vec ['t '])): if (vec[var][i] > 0) & (canFire == 1): file.write(str(j+1)+"\n") file.write(str(vec['t '][i])+"\n") canFire = 0 if (vec[var][i] < 0): canFire = 1 file.close()
def test(): from blenderneuron.quick import bn with Blender(keep=False): from neuron import h h.load_file(test_hoc_file) tc1 = h.TestCell() tc2 = h.TestCell() ic = h.IClamp(0.5, sec=tc1.soma) ic.delay = 1 ic.dur = 3 ic.amp = 0.5 bn.prepare_for_collection() bn.groups["all"]["3d_data"]["interaction_level"] = "Section" bn.groups["all"]["3d_data"]["color_level"] = "Cell" h.run() bn.to_blender() self.assertTrue( bn.run_command( "return_value = 'TestCell[0].soma' in bpy.data.objects" )) self.assertTrue( bn.run_command( "return_value = 'TestCell[1].soma' in bpy.data.objects" )) self.assertTrue( bn.run_command( "return_value = 'TestCell[0]' in bpy.data.materials")) self.assertTrue( bn.run_command( "return_value = 'TestCell[1]' in bpy.data.materials")) bn.run_command("bpy.data.scenes['Scene'].frame_current = 0") self.assertEqual( bn.run_command( "return_value = bpy.data.materials['TestCell[0]'].emit" ), 0.0) self.assertEqual( bn.run_command( "return_value = bpy.data.materials['TestCell[1]'].emit" ), 0.0) bn.run_command("bpy.data.scenes['Scene'].frame_current = 7") self.assertEqual( bn.run_command( "return_value = bpy.data.materials['TestCell[0]'].emit" ), 2.0) self.assertEqual( bn.run_command( "return_value = bpy.data.materials['TestCell[1]'].emit" ), 0.0)
def real_morphology_model_srsoma_rdend(stim, gpas=0.0001, Ra=100., cm=1., dt=0.1): # -- Biophysics -- # Sec parameters and conductance for sec in h.allsec(): sec.Ra = Ra # Ra is a parameter to infer sec.cm = cm # parameter optimisation algorithm found this sec.v = 0 sec.insert('pas') sec.g_pas = gpas # gpas is a parameter to infer sec.e_pas = 0 # Print information # h.psection() h.dt = dt # Time step (iteration) h.steps_per_ms = 1 / dt # Stimulus h.tstop = len(stim) * dt h.load_file("vplay.hoc") vec = h.Vector(stim) istim = h.IClamp(h.soma(0.5)) vec.play(istim._ref_amp, h.dt) istim.delay = 0 # Just for Neuron istim.dur = 1e9 # Just for Neuron # Run simulation -> # Set up recording Vectors vs_vec = h.Vector() # Membrane potential vector vd_vec = h.Vector() t_vec = h.Vector() # Time stamp vector vd_vec.record(h.apic[30](0.5)._ref_v) vs_vec.record(h.soma(0.5)._ref_v) t_vec.record(h._ref_t) # Simulation duration and RUN # h.tstop = 1200 # Simulation end h.v_init = 0 h.finitialize(h.v_init) h.init() h.run() t = t_vec.to_python() v_soma = vs_vec.to_python() v_dend = vd_vec.to_python() v_soma = np.array(v_soma) v_dend = np.array(v_dend) v = np.concatenate((v_soma, v_dend)) return t, v
def go(self): self.set_recording() h.dt = self.dt h.tstop = self.sim_time h.finitialize(-60)#self.v_init) h.init() h.run() self.rec_i = self.rec_ina.to_python()
def find_vrest(h, section_name): h.load_file("stdrun.hoc") tstop = 100 h.dt = dt = 0.1 soma, sec = fetch_soma_sec(section_name) h.init() h.cvode.re_init() t_vec, soma_vm, sec_vm = record(soma, sec) h.execute('tstop = 100') h.run() vrest = np.array(sec_vm)[-1] return vrest
def run(): """ Runs sim and plots figures, saves to outfig """ t_vec.record(h._ref_t) v_vec.record(dend(0.5)._ref_v) h.tstop = 20000 #stop sim at 20000 ms or 20 s h.run() # run sim outfig = "v" + date + ".png" pp.plot(t_vec, v_vec) # plot time versus voltage pp.savefig(outfig) # save figure using outfig
def get_vRest(myEPas): """ this functions returns the voltage in the given section as a function ePas. Example: >>> get_vRest(soma(0.5), myEPas=-68) """ mycell.soma.e_pas = myEPas h.run() return mycell.soma.v
def simulate_voltage(tstop, list_seg): """ runs a simulation and recall the voltage vectors defined in segments entered in **args return a list of HocVector objects """ myvector_list = list() for seg in list_seg: myvector_list.append(HocVector(seg)) h.tstop = tstop h.run() # return a list of HocVector objects return myvector_list
def custom_cable(length=526., tiprad=1.4, somarad=15.4, inj=1.2, tinj=1., injloc=1., Ra=35.4): """ Simulate a simple passive current injection. Length=um, rads=um, inj=nA, tinj=ms, injloc=1 (tip). Recorded from all 11 segments. """ # Set up model h.load_file('stdrun.hoc') cell = h.Section() cell.nseg = 11 # It is a good idea to have nseg be an odd number cell.Ra = 35.4 # Ohm*cm cell.insert('pas') # Create structure h.pt3dadd(0,0,0,somarad,sec=cell) h.pt3dadd(length,0,0,tiprad,sec=cell) stim = h.IClamp(injloc, sec=cell) stim.delay = 5 # ms stim.dur = tinj # ms stim.amp = inj # nA print("Stim: %.2f nA, %.2f ms, at location %.2f" %(stim.amp, stim.dur, injloc)) # Segment positions, equall spaced from 0 to 1 seg_positions = np.linspace(0,1,cell.nseg) # Use toolbox to record v # ez_record records v in all compartments by default (v,v_labels) = ez_record(h) # Manually record time and current t, I = h.Vector(), h.Vector() t.record(h._ref_t) I.record(stim._ref_i) # Run the simulation h.init() h.tstop = 30 h.run() # Use toolbox convert v into a numpy 2D array v = ez_convert(v) # Plotting options fig = plt.figure() for i in range(cell.nseg): t = [v[u][i] for u in range(len(v))] ax = fig.add_subplot(cell.nseg, 1, i+1) ax.plot(t) plt.show() return h, v
def main(args): global nseg, nchan, simulator, _args _args = args loadModel(args.swc_file, args) print("Done loading") h.init() print("[INFO] Running NEURON for %s sec" % args.sim_time) t1 = time.time() h.tstop = 1e3 * float(args.sim_time) h.run() t = time.time() - t1 print("Time taken by neuron: %s sec" % t) makePlots()
def passive_cable(stimloc=1., stimdur=5., show=False): """ This simulates a pulse injected into a simple passive cable. """ # Set up model h.load_file('stdrun.hoc') cell = h.Section() cell.nseg = 11 # It is a good idea to have nseg be an odd number cell.Ra = 35.4 # Ohm*cm cell.insert('pas') # create 3d structure h.pt3dadd(0,0,0,1.0,sec=cell) h.pt3dadd(1732,1732,1732,1.0,sec=cell) # Specify current injection stim = h.IClamp(stimloc,sec=cell) # Stim @ 1th end of segment stim.delay = 5 # ms stim.dur = stimdur # ms stim.amp = 0.2 # nA print("Stim: %.2f nA, %.2f ms, at location %.2f" %(stim.amp, stim.dur, stimloc)) # Segment positions, equall spaced from 0 to 1 seg_positions = np.linspace(0,1,cell.nseg) # Use toolbox to record v # ez_record records v in all compartments by default (v,v_labels) = ez_record(h) # Manually record time and current t, I = h.Vector(), h.Vector() t.record(h._ref_t) I.record(stim._ref_i) # Run the simulation h.init() h.tstop = 30 h.run() # Use toolbox convert v into a numpy 2D array v = ez_convert(v) # Plotting options if show: fig = plt.figure() for i in range(cell.nseg): t = [v[u][i] for u in range(len(v))] ax = fig.add_subplot(cell.nseg, 1, i+1) ax.plot(t) plt.show() return h, v
def iclamp(cell, sec, i_inj, v_init, tstop, dt, celsius=35, pos_i=0.5, pos_v=0.5): """ Runs a NEURON simulation of the cell for the given parameters. :param sec: List with 1st entry the name of the section and 2nd entry the index (or None in case of soma) :type sec: list[str, int] :param i_inj: Amplitude of the injected current for all times t. :type i_inj: array_like :param v_init: Initial membrane potential of the cell. :type v_init: float :param tstop: Duration of a whole run. :type tstop: float :param dt: Time step. :type dt: float :param celsius: Temperature during the simulation (affects ion channel kinetics). :type celsius: float :param pos_i: Position of the IClamp on the Section (number between 0 and 1). :type pos_i: float :param pos_v: Position of the recording electrode on the Section (number between 0 and 1). :type pos_v: float :return: Membrane potential of the cell and time recorded at each time step. :rtype: tuple of three ndarrays """ section = cell.substitute_section(sec[0], sec[1]) # time t = np.arange(0, tstop + dt, dt) # insert an IClamp with the current trace from the experiment stim, i_vec, t_vec = section.play_current(i_inj, t, pos_i) # record the membrane potential v = section.record('v', pos_v) t = h.Vector() t.record(h._ref_t) # run simulation h.celsius = celsius h.v_init = v_init h.tstop = tstop h.steps_per_ms = 1 / dt # change steps_per_ms before dt, otherwise dt not changed properly h.dt = dt h.run() return np.array(v), np.array(t)
def main(): fixedInput = {'probability': 0.5, 'spikeTimes': [100,215]} neurons = [KhaliqRaman(i) for i in range(2)] for n in neurons: n.addFixedInput(fixedInput['probability'], fixedInput['spikeTimes']) n.addPoissonInputs(clusterSize=5, stimulusProps={'frequency': 0.1, 'noise': 1.}) n.addSomaticVoltageRecorder() time = h.Vector() time.record(h._ref_t) h.load_file('stdrun.hoc') h.tstop = 400 h.run() for n in neurons: #print('Neuron [%d] emitted %d spikes.' % (n.ID, len(n.spikeTimes))) saveNeuron('neuron.h5', n)
def runsim (izhm): global Iin, ax1, recvecs h.dt = 0.025 f1 = [] ax1=None if fig1 is not None: plt.clf() for Iin in IinRange: izhm.Iin=Iin h.init() if burstMode: izhm.Iin=IinHyper h.init() h.continuerun(120) izhm.Iin=Iin h.run() else: h.run() plotall()
def vclamp(v, t, sec, celsius): # create SEClamp v_clamp = h.Vector() v_clamp.from_python(v) t_clamp = h.Vector() t_clamp.from_python(np.concatenate((np.array([0]), t))) # shifted because membrane potential lags behind vclamp clamp = h.SEClamp(0.5, sec=sec) clamp.rs = 1e-15 # series resistance should be as small as possible clamp.dur1 = 1e9 v_clamp.play(clamp._ref_amp1, t_clamp) # simulate h.celsius = celsius dt = t[1] - t[0] h.tstop = t[-1] h.steps_per_ms = 1 / dt h.dt = dt h.v_init = v[0] h.run()
def run_sim(h, section_name, v_peak, tau_raise, tau_fall, onset=100): tstop = 500 h.dt = dt = 0.1 h.load_file("stdrun.hoc") soma, sec = fetch_soma_sec(section_name) v_rest = -75.711 # find_vrest(h, section_name) h.init() h.cvode.re_init() s_v, a_v = fetch_soma_apic_pots() vv = voltage_clamp(tstop, dt, v_rest, v_peak, tau_raise, tau_fall, onset) vc = h.SEClamp(sec(0.5)) vc.rs = 0.001 vc.dur1 = tstop vamp = h.Vector(vv) vamp.play(vc._ref_amp1, h.dt) t_vec, soma_vm, sec_vm = record(soma, sec) h.execute('tstop = ' + str(tstop)) h.run() diff_v = np.array(a_v) - np.array(s_v) return t_vec, soma_vm, sec_vm, diff_v, vv
def simulate(tstop): """ simulate the somatic EPSC and returns the time (in ms) and current (in pA) """ # simulation details h.load_file('stdrun.hoc') h.v_init = -70 time, current = h.Vector(), h.Vector() time.record(h._ref_t) current.record(VC_patch._ref_i) h.tstop = tstop VC_patch.dur1 = tstop h.run() # note that current is in pA return (time, np.array(current)*1000.)
def main(): pkj = h.DSB94() h.dt = 0.02 Vrest = -74 h.celsius = 37 rec={} rec['v'] = h.Vector() rec['t'] = h.Vector() rec['v'].record(pkj.soma(0.5)._ref_v) rec['t'].record(h._ref_t) iclamp = h.IClamp(pkj.soma(0.5)) iclamp.amp = 0.300 iclamp.dur = 1000 iclamp.delay = 0 h.finitialize(Vrest) h.tstop = 700 h.run() plt.plot(rec['t'],rec['v']) plt.show() from ipdb import set_trace set_trace()
def p (nm, pm=None) : global name, vviv, params, vvset if pm is None : pm = choices[izhtype][2][nm] name, params = nm, pm if newmodel(): izh.C, izh.k, izh.vr, izh.vt, izh.vpeak, izh.a, izh.b, izh.c, izh.d, izh.celltype = params h.tstop=1000 else: izh.a, izh.b, izh.c, izh.d, vviv, h.tstop = params g.size(0,h.tstop,-100,50) try: if newmodel(): graphx() # interviews graphics iz07fig.recorder(cell07, choices[izhtype][1]()) # vectors to draw under matplotlib iz07fig.test1(cell07, nm, izhtype) else: iz07fig.closeFig() graphx() playinit() h.run() except: print sys.exc_info()[0],' :',sys.exc_info()[1]
def simulate(cell, tstop=1500, vinit=-55): ''' simulation control Parameters ---------- cell: NEURON cell cell for simulation tstop: int (ms) simulation time vinit: int (mV) initialized voltage ''' h.finitialize(vinit) balance(cell) if h.cvode.active(): h.cvode.active() else: h.fcurrent() h.frecord_init() h.tstop = tstop h.v_init = vinit h.run()
def main(): gid = 0 model = 'kr' cell_size = 120 N = 20 neurons = [KhaliqRaman(gid, {'diameter':cell_size,'length':cell_size, 'nSynapses':0,'channelNoise':False}) for gid in range(N)] baseline = [] pulse = [] for n,current in zip(neurons,np.linspace(0.04,0.07,N)): baseline.append(h.IClamp(n.soma(0.5))) baseline[-1].amp = -0.17 baseline[-1].dur = 2000 baseline[-1].delay = 0 pulse.append(h.IClamp(n.soma(0.5))) pulse[-1].amp = current pulse[-1].dur = 1000 pulse[-1].delay = 500 for i,n in enumerate(neurons): n.addSomaticVoltageRecorder() time = h.Vector() time.record(h._ref_t) h.load_file('stdrun.hoc') h.tstop = 2000 h.run() import pylab as plt fig = plt.figure() for i,n in enumerate(neurons): # fig.add_subplot(len(neurons),1,i) plt.plot(time,n.somaticVoltage()+(i-1)*5) plt.show() ipdb.set_trace() h.quit()
def scalar_bistable(rxdstr): if rxdstr == 'rxd': from neuron import rxd else: from neuron import crxd as rxd h.load_file('stdrun.hoc') s = h.Section(name='s') s.nseg = 101 cyt = rxd.Region(h.allsec()) c = rxd.Species(cyt, name='c', initial=lambda node: 1 if 0.4 < node.x < 0.6 else 0, d=1) r = rxd.Rate(c, -c * (1-c)*(0.3-c)) h.finitialize() h.run() #check the results result = h.Vector(c.nodes.concentration) cmpV = h.Vector(scalar_bistable_data[rxdstr]) cmpV.sub(result) cmpV.abs() if cmpV.sum() < 1e-6: sys.exit(0) sys.exit(-1)
def simple(): soma = h.Section() soma.insert('pas') soma.e_pas = -65 #soma.g_pas = 1./200e3 synapse = syn.AMPANMDASynapse(soma, 0.5, 0, 10000) synapse.set_presynaptic_spike_times([100]) h.nmdafactor_AmpaNmda = 0 rec = {} for lbl in 't','vsoma','vapical','vbasal','gampa','gnmda','iampa','inmda': rec[lbl] = h.Vector() rec['t'].record(h._ref_t) rec['vsoma'].record(soma(0.5)._ref_v) rec['gampa'].record(synapse.syn._ref_gampa) rec['gnmda'].record(synapse.syn._ref_gnmda) rec['iampa'].record(synapse.syn._ref_iampa) rec['inmda'].record(synapse.syn._ref_inmda) h.load_file('stdrun.hoc') h.celsius = 35 h.cvode_active(1) h.cvode.maxstep(10) h.tstop = 500 h.finitialize(soma.e_pas) h.run() p.subplot(3,1,1) p.plot(rec['t'],rec['vsoma'],'k',label='Soma') p.subplot(3,1,2) p.plot(rec['t'],np.array(rec['gampa'])*1e3,'k',label='AMPA') p.plot(rec['t'],np.array(rec['gnmda'])*1e3,'r',label='NMDA') p.legend(loc='best') p.ylabel('Conductance (nS)') p.subplot(3,1,3) p.plot(rec['t'],np.array(rec['iampa']),'k',label='AMPA') p.plot(rec['t'],np.array(rec['inmda']),'r',label='NMDA') p.legend(loc='best') p.xlabel('Time (ms)') p.ylabel('Current (nA)') p.show()
h.dt = 1/5. h.finitialize(-75) # cell with morphology and biophysics mycell = create_cell(CA3NeuronJonas) # stimulator stim = h.IClamp(0.5, sec= mycell.dend[141]) stim.amp = .7 stim.dur = 5 stim.delay = 10 # Load HocVectors soma_AP = HocVector(seg = mycell.soma(0.5)) dend_AP = HocVector(seg = mycell.dend[141](0.5)) # run simulation (stimulate in the dendrite) h.run() soma1 = soma_AP.voltage.copy() dend1 = dend_AP.voltage.copy() # plot resutls fig1 = figure() ax1 = fig1.add_subplot(111) ax1.plot(soma_AP.time, soma1, 'k') ax1.plot(soma_AP.time, dend1, 'r') show()
def test(): rall = 113 # axial resistance cap = 1.1 # membrane capacitance Rm = 45000.0 # membrane resistance ## INSERT ION CHANNELS: for sec in h.allsec(): sec.insert("pas") sec.e_pas = Epas sec.g_pas = 1/Rm sec.Ra = rall sec.cm = cap sec.insert("Cad") sec.insert("it2") sec.insert("hh2") sec.ena = 50 # Reversal potential for sodium sec.ek = -90 # Reversal potential for potassium ################################################################## # Channel densities gna = 0.04 # S/cm2 gkdr = 0.04 gcat = 0.0001 ################################################################### ## INSERT STIMULATION ELECTRODES stim = h.IClamp(h.soma(0.5)) # stim = h.IClamp(h.dend[99](0.5)) stim.delay = 1000 stim.dur = 10 stim.amp = 0#.25 #nA ################################################################### ## INSERT SYNAPSES syn = h.Exp2Syn(h.dend[99](1)) # Sum of exp's syn.tau1 = 0.5 # Rise (ms) syn.tau2 = 2 # Decay (ms) syn.e = 10 # Reversal # pot. s = h.NetStim(0.5) s.start = 1000 # start for distal synapses s.number = 1 s.noise = 0 nc = h.NetCon(s,syn,sec = sec) nc.weight[0] = 0.015 # syn1 = h.Exp2Syn(h.dend[83](1)) # Sum of exp's # syn1.tau1 = 0.5 # Rise (ms) # syn1.tau2 = 2 # Decay (ms) # syn1.e = 10 # Reversal # pot. # s1 = h.NetStim(0.5) # s1.start = 1100 # start for distal synapses # s1.number = 1 # s1.noise = 0 # nc1 = h.NetCon(s1,syn1,sec = sec) # nc1.weight[0] = 0.05 ################################################################# # Split the morphology up in a suitable number of segments freq = 50 h.geom_nseg(freq) tot = 0 for sec in h.allsec(): tot += sec.nseg h.distance() print "total # of segments (50Hz):", tot ################################################################## # INITIALIZE gcat_func = lambda dist : 0.1054*gcat*(1 + 0.04*dist) def initialize(): global Epas h.celsius = celsius for sec in h.soma: h.distance() for sec in h.allsec(): sec.v = Epas sec.e_pas = Epas sec.insert("pas") sec.e_pas = Epas sec.g_pas = 1/Rm sec.Ra = rall sec.cm = cap sec.gnabar_hh2 = 0 sec.gkbar_hh2 = 0 dist = h.distance(0.5) # sec.gcabar_it2 = gcat_func(dist) sec.gcabar_it2 = gcat for sec in h.soma: sec.gnabar_hh2 = gna sec.gkbar_hh2 = gkdr # sec.gcabar_it2 = 0.1054*gcat sec.gcabar_it2 = gcat h.finitialize() h.fcurrent() cvode.re_init() initialize() vec ={} for var in 't', 'd_sec', 'd_seg', 'diam_sec','gc','diam_seg','stim_curr': vec[var] = h.Vector() for var in 'V_sec', 'V_seg', 'CaConc_sec','CaConc_seg': vec[var] = h.List() def create_lists(vec): for sec in h.allsec(): vec['d_sec'].append(h.distance(1)) vec['diam_sec'].append(sec.diam) rec0 = h.Vector() rec0.record(sec(0.5)._ref_v) vec['V_sec'].append(rec0) rec_Ca = h.Vector() rec_Ca.record(sec(0.5)._ref_Cai) vec['CaConc_sec'].append(rec_Ca) for seg in sec: vec['d_seg'].append(h.distance(0) + sec.L * seg.x) vec['diam_seg'].append(seg.diam) vec['gc'].append(seg.gcabar_it2) rec = h.Vector() rec.record(seg._ref_v) vec['V_seg'].append(rec) rec1 = h.Vector() rec1.record(seg._ref_Cai) vec['CaConc_seg'].append(rec1) return vec ##################################### create_lists(vec) # run the simulation vec['t'].record(h._ref_t) # vec['current'].record(VC_patch._ref_i) vec['stim_curr'].record(stim._ref_i) h.load_file("stdrun.hoc") h.tstop = 2500 # Simulation time h.t = -500 h.run() return vec
# insert a current clamp with continuously fluctuating value # inject a continues current h.tstop = 1e3 h.dt = 0.025 AMP = 20 # scales amplitude of current clamp, 4.5 produces sub-threshold response, 20 causes soma spikes normally, # change values to see effect np.random.seed(21051982) noise = np.random.rand(h.tstop/h.dt+1)*AMP icc = h.IClamp(cell(0.5)) icc.delay=0 # start current clamp right away icc.dur=1e9 # this means the value is played into for simulation duration nvec = h.Vector( noise ) nvec.play(icc._ref_amp,h.dt)#updates icc's amplitude during the simulation using nvec's values h.v_init = -60 # this is initialization voltage used by h.run() -- calls finitialize h.run() # run simulation for duration in h.tstop # plot output subplot(1,2,1) plot(trec.as_numpy(),vrec.as_numpy()) # as_numpy is more efficient than converting/copying Vector to numpy format xlim((0,h.tstop)) xlabel('Time (ms)') ylabel('Vm (mV)') tight_layout() subplot(1,2,2) plot(trec.as_numpy(),nvec.as_numpy()) # display part of the noisy current-injection amplitude xlim((0,h.tstop)) xlabel('Time (ms)') ylabel('i (nA)') xlim((0,10))
def run_current_steps_protocol(cell, amplitudes, ttran, tstep, dt=0.025, temperature=37., use_cvode=False): h.load_file('stdrun.hoc') print(timestamp() + '>> Inserting the stimulus...') stim = h.IClamp(cell.soma[0](0.5)) stim.dur = tstep stim.delay = ttran print(timestamp() + '>> Setting up the recorders...') rec = {} for lbl in 't','vsoma','spikes': rec[lbl] = h.Vector() rec['t'].record(h._ref_t) rec['vsoma'].record(cell.soma[0](0.5)._ref_v) apc = h.APCount(cell.soma[0](0.5)) apc.record(rec['spikes']) h.celsius = temperature h.dt = dt if use_cvode: h.tstop = stim.delay + stim.dur + 500 h.cvode_active(1) h.cvode.atol(1e-6) h.cvode.rtol(1e-6) h.cvode.maxstep(dt) else: h.tstop = stim.delay - 20 print(timestamp() + '>> Evolving the model until %g ms...' % h.tstop) sys.stdout.flush() h.run() print(timestamp() + '>> Saving the state...') ss = h.SaveState() ss.save() t = [] V = [] spike_times = [] for i,amp in enumerate(amplitudes): sys.stdout.write('\r' + timestamp() + '>> Trial [%02d/%02d] ' % (i+1,len(amplitudes))) sys.stdout.flush() if not use_cvode: ss.restore() stim.amp = amp apc.n = 0 rec['t'].resize(0) rec['vsoma'].resize(0) rec['spikes'].resize(0) if use_cvode: h.t = 0 h.run() else: h.continuerun(stim.delay + stim.dur + 500.) t.append(np.array(rec['t'])) V.append(np.array(rec['vsoma'])) spike_times.append(np.array(rec['spikes'])) sys.stdout.write('\n') if use_cvode: return np.array(t), np.array(V), np.array(spike_times) else: return np.array(V), np.array(spike_times)