def _ap_counters(self): """ Create action potential counters, esp. useful for threshold calculation """ self.apcs = [] self.apc_times = [] if h.number_of_apc > 0: try: sec = h.node[h.axonnodes.__int__()-2] except AttributeError: print "No node compartments!" return 0 apc = h.APCount(0.5, sec=sec) apc.thresh = 0 # mV apc_time = h.Vector() apc.record(apc_time) self.apcs.append(apc) self.apc_times.append(apc_time) if h.number_of_apc == 2: sec = h.node[1] apc = h.APCount(0.5, sec=sec) apc.thresh = 0 # mV apc_time = h.Vector() apc.record(apc_time) self.apcs.append(apc) self.apc_times.append(apc_time) else: if h.number_of_apc>2: raise ValueError,"Too many apc counters; only 1 or 2 allowed"
def simulatepar(delay, dur, Ra, 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, 50, 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(Ra).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(Ra) + 'Ra' + str( freq) + 'freq' + str(std) + 'std' + str(seed) + 'seed' + str( loop) + 'loop.txt' writetofile(filename, counts) return 0
def _AP_counter(self, thr=0): """Action Potential counter at the soma of GenNeuron or a subclass. Parameters ---------- thr - numeric the threshold value for action potential detection Returns ------- time_vec - h.Vector the current clamp point process ap - h.APCount the ap counter object that counts number and records time stamps Use Cases --------- >>> myNeuron = GenNeuron() >>> myNeuron.mk_soma() >>> myNeuron._AP_counter """ ap = h.APCount(self.soma(0.5)) self.ap = ap self.ap.thresh = thr self.time_vec = h.Vector() self.ap.record(self.time_vec) return self.time_vec, self.ap
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 _ap_counters(self): """ Create action potential counters, esp. useful for threshold calculation """ self.apc = h.APCount(0.5, sec=self.root) self.apc.thresh = -20.0 #mV, threshold voltage for AP detection self.apc_times = h.Vector() self.apc.record(self.apc_times)
def plot_histogram(cell, T, I0, S, I1, F): #F = 60 # Hz #T = 200000. # ms #I0 = 500. # pA #S = 300. # pA #I1 = 80. # pA tau = 5. # ms delay = 0 dt = 0.05 mu = 0 loc = 0.5 seed = random.randint(0, 1000) F = F / 1000. stim = attach_noise_sin_clamp(cell, delay, T, I0, I1, F, dt, tau, S, mu, loc, seed) counts = h.Vector() apc = h.APCount(cell.soma[0](0.5)) apc.thresh = 0 apc.record(counts) run_model(dt, T) N = len(counts) tsp = np.array(counts.to_python()) x = np.cos(6.28318530718 * tsp * F) / N y = np.sin(6.28318530718 * tsp * F) / N R0 = 1000. * N / T # spikes/s R1 = 2 * R0 * np.absolute(np.complex(np.sum(x), np.sum(y))) PHI = np.angle(np.complex(np.sum(x), np.sum(y)), deg=False) tsp = np.remainder(tsp, 2 / F) C = np.floor_divide(T, 2 / F) fig = plt.figure(figsize=(14, 4)) hist, bins = np.histogram(tsp, bins=40) hist = 1000. * hist / ((bins[3] - bins[2]) * C) # Hz # R1 = (np.max(hist) - np.min(hist))/2 W = (2. / F) / 40. plt.bar(bins[:-1], hist, width=W, color='black') y = R0 + R1 * np.cos(6.28318530718 * bins * F - PHI) z = R0 + R1 * np.cos(6.28318530718 * bins * F) plt.plot(bins, y, 'r', linewidth=1) plt.plot(bins, z, 'g--', linewidth=1) ax = fig.add_subplot(111) ax.set_xlim((0, 2. / F - (bins[3] - bins[2]))) # Set the horizontal limits # ax.set_ylim( (0, 2*R0) ) # Set the horizontal limits ax.set_xlabel( 'time within two periods [ms]') # Label for the horizontal axis ax.set_ylabel( 'Instantaneous firing rate [spikes/s]') # Label for the vertical axis #ax.grid() # "Grid" on plt.show()
def plot_transferfunction(cell, T, I0, S, I1, FRange): tau = 5 delay = 0 dt = 0.05 mu = 0 loc = 0.5 myfile = "spikes.x" transfervec = np.zeros( (len(FRange), 1)) # Create vector to store all transfer factor phasevec = np.zeros( (len(FRange), 1)) # Create vector to store all the phase delay values counter = 0 for freq in FRange: seed = random.randint(0, 1000) stim = attach_noise_sin_clamp(cell, delay, T, I0, I1, freq / 1000., dt, tau, S, mu, loc, seed) counts = h.Vector() apc = h.APCount(cell.soma[0](0.5)) apc.thresh = 0 apc.record(counts) run_model(dt, T) N = len(counts) tsp = np.array(counts.to_python()) x = np.cos(6.28318530718 * tsp * freq / 1000.) / N y = np.sin(6.28318530718 * tsp * freq / 1000.) / N R0 = 1000. * N / T # spikes/s transfervec[counter] = np.absolute(np.complex(np.sum(x), np.sum(y))) phasevec[counter] = -np.angle(np.complex(np.sum(x), np.sum(y)), deg=False) counter += 1 phasevec = phase_unwrap(phasevec) try: calc_cof(FRange, transfervec) except: print("Couldn't find a crossing between transfer curve and 70% line.") fig = plt.figure(figsize=(14, 4)) ax1 = plt.subplot(2, 1, 1) plt.grid('on') plt.loglog(FRange, transfervec, 'o-', linewidth=3) plt.loglog(FRange, transfervec[0] * 0.707 * np.ones((FRange.size)), linewidth=2, color='black') plt.xlabel('Frequency [Hz]') plt.ylabel('Transfer factor') ax2 = plt.subplot(2, 1, 2, sharex=ax1) plt.semilogx(FRange, phasevec, 'o-', linewidth=3) plt.xlabel('Frequency [Hz]') plt.ylabel('Phase delay [Rad]') plt.grid('on') plt.subplots_adjust(hspace=0) plt.show()
def rhoebase_counter(cell): #Not working in some cases due to the low current required, in the very small somato dendritic trees #What is the minimum current in these area? Via article or Yaki Results apc = h.APCount(cell.soma(0.5)) apc.thresh = -10 step = 0.00005 min = 0.00005 max = 0.02 current_lst = np.arange(min, max, step)
def record(self, cells='all'): """Adds spike recorders.""" log.info('Adding spike recorders.') if cells=='all': self.rec_cells = range(len(self.cells)) else: self.rec_cells = cells self.apc = [(h.Vector(), h.APCount(0.5, sec=self.cells[i].soma)) for i in self.rec_cells] for tspike, apc in self.apc: apc.thresh = -10 apc.record(tspike)
def rhoebase_counter(cell, min_current = min_current, max_current = max_current, rheobase_step = rheobase_step): apc = h.APCount(cell.soma(0.5)) apc.thresh = -30 #Changed from -10 current_lst = np.arange(min_current, max_current, rheobase_step) for new_current in current_lst: stim.amp = new_current h.run() if (apc.n>0): print(apc.n) list_of_elem = [list_id[0],list_id[1],list_id[2],1/cell.dend.g_pas, cell.dend.Ra, cell.dend.cm, cell.dend.L, cell.spacer.L, 1/cell.spacer.g_pas, cell.spacer.Ra, cell.spacer.cm , 1/cell.AIS.g_pas, new_current] append_list_as_row(file_name, list_of_elem) return new_current
def _my_ap_counters(self): self.apCounterDict = dict() self.apTimesDict = dict() for sec in self.get_secs(): if ('node' in sec.name()): name = sec.name() self.apCounterDict[name] = h.APCount(0.5, sec=sec) self.apCounterDict[name].thresh = -30 self.apCounterDict[name + '_times'] = h.Vector() self.apTimesDict[sec.name()] = h.Vector() self.apCounterDict[name].record(self.apCounterDict[name + '_times']) self.apCounterDict[name].record(self.apTimesDict[sec.name()])
def run_exp(HCell, config): Vsoma = h.Vector() Vsoma.record(HCell.soma[0](.5)._ref_v) tvec = h.Vector() tvec.record(h._ref_t) apc = h.APCount(0.5, sec=HCell.soma[0]) apc.thresh = 0 apc.time = 10000000. h.init(h.v_init) h.run() np_t = np.array(tvec) np_v = np.array(Vsoma) max_v = np.max(np_v[np.where(np_t > config.Spike_time)[0][0]:]) return apc.n, max_v
def special_run(stim, cell, simdur, dt, init, cel): soma_v_vec = h.Vector() t_vec = h.Vector() soma_v_vec.record(cell.soma[0](0.5)._ref_v) t_vec.record(h._ref_t) apc = h.APCount(cell.soma[0](0.5)) ##### spikes = h.Vector() ######## apc.thresh = 0 #### apc.record(spikes) ###### h.dt = dt h.tstop = simdur h.v_init = init h.celsius = cel h.run() # soma_v_vec.resize(0) # t_vec.resize(0) # spikes.resize(0) # h.continuerun(10001.) return soma_v_vec; #spikes;
def __init__(self,v): self.soma = h.Section() self.soma.L = 200. self.soma.diam = 20./np.pi self.soma.nseg = 1 self.soma.insert('hh') self.soma(0.5).el_hh = -30.3 self.soma(0.5).v = v self.isyn = h.Exp2Syn(0.5, sec=self.soma) self.isyn.e = -75.0 self.isyn.tau1 = 0.99 self.isyn.tau2 = 1.0 self.esyn = h.ExpSyn(0.5, sec=self.soma) self.esyn.e = 0.0 self.esyn.tau = 0.8 self.spks = h.Vector() self.sptr = h.APCount(.5, sec=self.soma) self.sptr.thresh = 25 self.sptr.record(self.spks)
def record_spikes(self, threshold=-30, pos=.5): """ Records the spikes of this section. Note: Values are updated after each NEURON h.run(). :param: pos: Indicates the position on the Section at which is recorded (number between 0 and 1). :type: pos: float :param: threshold: Only spikes above this threshold are counted as spikes. :type: threshold: float :return: vec: Contains the times where spikes occurred :rtype: vec: h.Vector """ vec = h.Vector() self.spike_count = h.APCount( pos, sec=self) # spike_count assigned to self to keep NEURON reference self.spike_count.thresh = threshold self.spike_count.record(vec) return vec
def plot_FI(cell, T, I0range, Srange): delay = 0 dt = 0.05 mu = 0 loc = 0.5 m = np.size(I0range) n = np.size(Srange) F = np.zeros((m, n)) I1 = 0. F0 = 0. tau = 5. for j in range(n): for i in range(m): seed = random.randint(0, 1000) I0 = I0range[i] S = Srange[j] stim = attach_noise_sin_clamp(cell, delay, T, I0, I1, F0, dt, tau, S, mu, loc, seed) counts = h.Vector() apc = h.APCount(cell.soma[0](0.5)) apc.thresh = 0 apc.record(counts) run_model(dt, T) N = len(counts) F[i, j] = 1000. * N / T fig = plt.figure() ax = fig.add_subplot(111) ax.plot(I0range, F, 'o-', linewidth=3.0) ax.set_xlim( (np.min(I0range), np.max(I0range))) # Set the horizontal limits #ax.set_ylim( (0,40) ) # Set the vertical limits ax.set_xlabel('Mean input current [pA]') # Label for the horizontal axis ax.set_ylabel('Mean Firing Rate [Hz]') # Label for the vertical axis ax.grid() # "Grid" on plt.show()
def fig_rheobase_check(cell): #Not working in some cases due to the low current required, in the very small somato dendritic trees #What is the minimum current in these area? Via article or Yaki Results apc = h.APCount(cell.soma(0.5)) apc.thresh = 0 current_lst = np.arange(min_current, max_current, rheobase_step) soma_v_vec, AIS_v_vec, t_vec = set_recording_vectors(cell) for new_current in current_lst: stim.amp = new_current h.run() if apc.n>0: print(apc) pyplot.plot(t_vec, soma_v_vec, label=str(new_current) + ', Rheobase = {}'.format(new_current)) pyplot.suptitle('Spike Graph', fontsize=14, fontweight='bold') # pyplot.text(0.1, 2.8, "The number of action potentials is {}".format(apc.n)) pyplot.xlabel('time (ms)') pyplot.ylabel('mV') pyplot.legend() pyplot.show() return new_current
def spike_fig(cell): #Setup recording soma_v_vec, AIS_v_vec, t_vec = set_recording_vectors(cell) apc = h.APCount(cell.soma(0.5)) apc.thresh = 0 #Setup Graphs: pyplot.figure(figsize=(20, 8)) step = 0.02 num_steps = 2 for new_current in np.linspace(step, step * num_steps, num_steps): stim.amp = new_current h.run() pyplot.plot(t_vec, soma_v_vec, label=str(new_current)+', Spike Number = {}'.format(apc.n)) #Design Graph pyplot.suptitle('Spike Graph', fontsize=14, fontweight='bold') # pyplot.text(0.1, 2.8, "The number of action potentials is {}".format(apc.n)) pyplot.xlabel('time (ms)') pyplot.ylabel('mV') pyplot.legend() pyplot.show()
def simulatepar(delay, dur, std, offset, amp, freq, dt, tau, mu, loc, simdur, init, cel, seed, loop): init_simulation() cell = rn.create_cell(False) h.psection() counts = h.Vector() apc = h.APCount(cell.soma[0](0.5)) apc.thresh = -15 apc.record(counts) stim = attach_noise_sin_clamp(cell, delay, dur, offset, amp, freq, dt, tau, std, mu, loc, seed) h.dt = dt h.tstop = simdur h.v_init = init h.celsius = cel h.run() filename = './OUTPUT/spiketrain5Hzmfr' + str(freq) + 'freq' + str( std) + 'std' + str(seed) + 'seed' + str(loop) + 'loop.txt' writetofile(filename, counts) return 0
def fig_rheobase_check(cell): apc = h.APCount(cell.soma(0.5)) apc.thresh = 0 current_lst = np.arange(min_current, max_current, rheobase_step) soma_v_vec, AIS_v_vec, t_vec = set_recording_vectors(cell) for new_current in current_lst: stim.amp = new_current h.run() if apc.n > 0: print(apc) pyplot.plot(t_vec, soma_v_vec, label=str(new_current) + ', Rheobase = {}'.format(new_current)) pyplot.suptitle('Spike Graph', fontsize=14, fontweight='bold') # pyplot.text(0.1, 2.8, "The number of action potentials is {}".format(apc.n)) pyplot.xlabel('time (ms)') pyplot.ylabel('mV') pyplot.legend() pyplot.show() return new_current
def record_spikes(self, threshold=-30): """ Record the number of spikes produced in this section, which is the number of time a voltage is crossed in the middle of a section Parameters ---------- threshold: a float voltage determining the presence or not of a spike Returns ------- nothing, but change the self.spikecount """ self.spiketimes = h.Vector() self.spikecount = h.APCount(0.5, sec=self) self.spikecount.thresh = threshold self.spikecount.record(self.spiketimes)
def main(): init_simulation() cell = create_cell(False) std = 0. currRange = numpy.arange(0.038, .04, 0.001) #looks like it may be in [mA] instead of [nA] dt = 0.005 tau = 10. #22.5 # [ms] # 10. mu = 0. totalcount = [] stepi = [] for i in currRange: curr = i counts = h.Vector() apc = h.APCount(cell.soma[0](0.5)) apc.thresh = 10 apc.record(counts) delay = 0 dur = 100 stim = attach_noise_sin_clamp(cell, delay, dur, curr, 0., 0., dt, tau, std, mu, 0.5) soma_vec, axon_vec, i_inj_vec, t_vec = set_recording_vectors( stim, cell) simulate(dur, dt, -70, 37) if len(counts) > 1: deltat = counts[-1] - counts[0] totalcount.append(((len(counts)) / deltat) * 1000) stepi.append(curr) else: totalcount.append(0) stepi.append(curr) pyplot.figure() pyplot.plot(t_vec, soma_vec) filename = 'FIVal' + str(0) + 'bis.txt' writetofile(filename, stepi, totalcount) pyplot.figure() pyplot.plot(stepi, totalcount)
def spike_record(self, gid, thresh=0): self.spikes[gid] = (h.APCount(self.gid2cell[gid].soma(0.5)), h.Vector()) self.spikes[gid][0].thresh = thresh self.spikes[gid][0].record(self.spikes[gid][1])
distRange = numpy.arange(0, 0.9, 0.3) con = 1 stdcounts = numpy.zeros(shape=(num_steps, len(distRange) + 1)) for distSAIS in distRange: std = 0.03 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(distSAIS).gbar_na = 8000 * 15 totalcount = [] stepi = [] counter = 0 for i in range(0, num_steps): counts = h.Vector() apc = h.APCount(soma(0.5)) apc.thresh = 0 apc.record(counts) offset = startcur + (step * i) # stim = Mcm.attach_current_clamp(soma, 1, 1000, startcur + (step * i), 0.5) stim = Mcm.attach_noise_sin_clamp(soma, delay, dur, offset, amp, freq, dt, tau, std, mu, loc, seed) soma_vec, axon_vec, i_inj_vec, i_cap_vec, t_vec = Mcm.set_recording_vectors( stim, soma, axon) icap = h.Vector() icap.record(soma(.5)._ref_i_cap) Mcm.simulate(T, 0.005, -70, 37) # dvdt_vec = Mcm.calc_dvdt(soma_vec, t_vec) # fig = pyplot.figure() # ax1 = fig.add_subplot(2, 1, 1) # ax2 = fig.add_subplot(2, 1, 2)
def record_spikes(self, threshold=-30): self.spiketimes = h.Vector() self.spikecount = h.APCount(0.5, sec=self) self.spikecount.thresh = threshold self.spikecount.record(self.spiketimes)
def plot_FI_and_modulation(cell, T, I0range, S, M, M1, FF): m = np.size(I0range) F = np.zeros((m, 1)) I1 = 0. F0 = 0. tau = 5. FF = FF / 1000 delay = 0 dt = 0.05 mu = 0 loc = 0.5 for i in range(m): I0 = I0range[i] seed = random.randint(0, 1000) I0 = I0range[i] stim = attach_noise_sin_clamp(cell, delay, T, I0, I1, F0, dt, tau, S, mu, loc, seed) counts = h.Vector() apc = h.APCount(cell.soma[0](0.5)) apc.thresh = 0 apc.record(counts) run_model(dt, T) N = len(counts) F[i, 0] = 1000. * N / T I1 = 0. F0 = 0. seed = random.randint(0, 1000) stim = attach_noise_sin_clamp(cell, delay, T, M, I1, F0, dt, tau, S, mu, loc, seed) counts = h.Vector() apc = h.APCount(cell.soma[0](0.5)) apc.thresh = 0 apc.record(counts) run_model(dt, T) N = len(counts) stim = attach_noise_sin_clamp(cell, delay, T, M * 1.1, I1, F0, dt, tau, S, mu, loc, seed) counts = h.Vector() apc = h.APCount(cell.soma[0](0.5)) apc.thresh = 0 apc.record(counts) run_model(dt, T) N1 = len(counts) I1 = M1 F0 = FF seed = random.randint(0, 1000) stim = attach_noise_sin_clamp(cell, delay, T, M, I1, F0, dt, tau, S, mu, loc, seed) counts = h.Vector() apc = h.APCount(cell.soma[0](0.5)) apc.thresh = 0 apc.record(counts) somav = h.Vector() somav.record(cell.soma[0](0.5)._ref_v) timevec = h.Vector() timevec.record(h._ref_t) iinj = h.Vector() iinj.record(stim._ref_i) run_model(dt, T) fig = plt.figure(figsize=(14, 4)) ax1 = fig.add_subplot(121) ax1.plot(I0range, F, 'o-', linewidth=3.0) ax1.set_xlim( (np.min(I0range), np.max(I0range))) # Set the horizontal limits #ax1.set_ylim( (0,40) ) # Set the vertical limits ax1.set_xlabel('Mean input current [pA]') # Label for the horizontal axis ax1.set_ylabel('Mean Firing Rate [Hz]') # Label for the vertical axis ax1.grid() # "Grid" on p = [M, 1000. * N / T] indthres = np.nonzero(I0range > M) crossind = indthres[0] rico = (F[crossind[0]] - F[crossind[0] - 1]) / (I0range[crossind[0]] - I0range[crossind[0] - 1]) p[1] = rico * (M - I0range[crossind[0] - 1]) + F[crossind[0] - 1] p1amp = rico * (M + M1 - I0range[crossind[0] - 1]) + F[crossind[0] - 1] - p[1] xmin, xmax = ax1.get_xbound() ymin, ymax = ax1.get_ybound() l1 = mlines.Line2D([p[0], p[0]], [ymin, p[1]]) l2 = mlines.Line2D([xmin, p[0]], [p[1], p[1]]) ax1.add_line(l1) ax1.add_line(l2) t = np.arange(ymin, p[1], (p[1] - ymin) * 0.005) i = M + M1 * np.cos(6.28 * t * 5. / (p[1] - ymin)) ax1.plot(i, t) t = np.arange(xmin, p[0], (p[0] - xmin) * 0.005) f = p[1] + p1amp * np.cos(6.28 * t * 5. / (p[0] - xmin)) ax1.plot(t, f) ax2 = fig.add_subplot(122) ax2.plot(timevec, somav) # Make the actual plot versus time timevecpyt = np.arange(0., T, dt) tmp1 = -60 + 10 * np.cos(6.28 * FF * timevecpyt) ax2.plot(timevecpyt, tmp1) ax2.set_xlim((0, 400)) # Set the horizontal limits ax2.set_ylim((-80, 50)) # Set the vertical limits ax2.set_xlabel('time [ms]') # Label for the horizontal axis ax2.set_ylabel( 'u - membrane potential [mV]') # Label for the vertical axis ax2.grid() # "Grid" on plt.show()
for sec in bc.all_secs: sec.ek = sec.ek + 0 for sec in hc.all_secs: sec.ek = sec.ek + 0 gc_stim = gc._current_clamp_soma(x, 500, 50) mc_stim = mc._current_clamp_soma(x, 500, 50) bc_stim = bc._current_clamp_soma(x, 500, 50) hc_stim = hc._current_clamp_soma(x, 500, 50) gc_rec = gc._voltage_recording() mc_rec = mc._voltage_recording() bc_rec = bc._voltage_recording() hc_rec = hc._voltage_recording() gc_apc_curr = h.APCount(gc.soma(0.5)) mc_apc_curr = h.APCount(mc.soma(0.5)) bc_apc_curr = h.APCount(bc.soma(0.5)) hc_apc_curr = h.APCount(hc.soma(0.5)) time_vec = h.Vector() time_vec.record(h._ref_t) h.cvode.active(0) dt = 0.1 h.steps_per_ms = 1.0 / dt h.tstop = 1500 h.finitialize(-60) h.t = -2000 h.secondorder = 0 h.dt = 10
def Constructing_the_ball_and_tree(params, cables, spiking_mech=False, nmda_on=False, Ca_spikes_on=False, HH_on=False): # list of excitatory stuff exc_synapses, exc_netcons, exc_spike_trains, exc_Ks = [], [], [], [] # list of inhibitory stuff inh_synapses, inh_netcons, inh_spike_trains, inh_Ks = [], [], [], [] # area list area_lists = [] area_tot = 0 ## --- CREATING THE NEURON for level in range(len(cables)): # list of excitatory stuff per level exc_synapse, exc_netcon, exc_spike_train, exc_K = [], [], [], [] # list of inhibitory stuff per level inh_synapse, inh_netcon, inh_spike_train, inh_K = [], [], [], [] area_list = [] for comp in range(max(1,2**(level-1))): nrn('create cable_'+str(int(level))+'_'+\ str(int(comp))) exec('section = nrn.cable_'+str(level)+'_'+str(comp)) ## --- geometric properties section.L = cables[level]['L']*1e6 section.diam = cables[level]['D']*1e6 section.nseg = cables[level]['NSEG'] ## --- passive properties section.Ra = params['Ra']*1e2 section.cm = params['cm']*1e2 section.insert('pas') section.g_pas = params['g_pas']*1e-4 section.e_pas = params['El']*1e3 if comp==0 and HH_on: section.insert('hh3Larkum2009') if (comp==1 or comp==2) and Ca_spikes_on: section.insert('scaLarkum2009') section.gbar_scaLarkum2009=10 # section.insert('kdrLarkum2009') # section.insert('kcaLarkum2009') # section.gbar_kcaLarkum2009=30 section.insert('cad2Larkum2009') section.insert('it2Larkum2009') # section.gcabar_it2Larkum2009=0.000 # section.insert('hh3Larkum2009') # section.gkbar_hh3Larkum2009=0 # section.gkbar2_hh3Larkum2009=0.0001 # section.gnabar_hh3Larkum2009=0.01 # section.insert('kapLarkum2009') # section.gkabar_kapLarkum2009=0.003 # section.insert('kmLarkum2009') # section.gbar_kmLarkum2009=0 # section.gbar_kdrLarkum2009=0 if level>=1: # if not soma # in NEURON : connect daughter, mother branch nrn('connect cable_'+str(int(level))+'_'+\ str(int(comp))+'(0), '+\ 'cable_'+str(int(level-1))+\ '_'+str(int(comp/2.))+'(1)') ## --- SPREADING THE SYNAPSES (bis) for seg in section: tree_fraction = np.max([0,float(seg.x)/(len(cables)-1)+float(level-1)/(len(cables)-1)]) if tree_fraction>params['fraction_for_L_prox']: # print 'strengthen synapse !' Ftau = 1. # removed params ! Fq = params['factor_for_distal_synapses_weight'] else: Ftau = 1. Fq = 1. # in each segment, we insert an excitatory synapse if nmda_on: syn = nrn.my_glutamate(seg.x, sec=section) syn.tau_ampa, syn.e = Ftau*params['Te']*1e3, params['Ee']*1e3 syn.gmax = 1e9*params['Qe'] # nS in my_glutamate.mod else: syn = nrn.ExpSyn(seg.x, sec=section) syn.tau, syn.e = Ftau*params['Te']*1e3, params['Ee']*1e3 exc_synapse.append(syn) netcon = nrn.NetCon(nrn.nil, syn) netcon.weight[0] = Fq*params['Qe']*1e6 exc_netcon.append(netcon) exc_K.append(cables[level]['Ke_per_seg']) exc_spike_train.append([]) syn = nrn.ExpSyn(seg.x, sec=section) syn.tau, syn.e = Ftau*params['Ti']*1e3, params['Ei']*1e3 inh_synapse.append(syn) inh_K.append(cables[level]['Ki_per_seg']) inh_spike_train.append([]) netcon = nrn.NetCon(nrn.nil, syn) netcon.weight[0] = Fq*params['Qi']*1e6 inh_netcon.append(netcon) # then just the area to check area_tot+=nrn.area(seg.x, sec=section) area_list.append(nrn.area(seg.x, sec=section)) exc_synapses.append(exc_synapse) exc_netcons.append(exc_netcon) exc_Ks.append(exc_K) exc_spike_trains.append(exc_spike_train) inh_synapses.append(inh_synapse) inh_netcons.append(inh_netcon) inh_Ks.append(inh_K) inh_spike_trains.append(inh_spike_train) area_lists.append(area_list) # ## --- spiking properties if spiking_mech: # only at soma if we want it ! nrn('cable_0_0 insert hh') # + spikes recording ! counter = nrn.APCount(0.5, sec=nrn.cable_0_0) spkout = nrn.Vector() counter.thresh = -30 counter.record(spkout) else: spkout = np.zeros(0) print("=======================================") print(" --- checking if the neuron is created ") nrn.topology() print(("with the total surface : ", area_tot)) print("=======================================") return exc_synapses, exc_netcons, exc_Ks, exc_spike_trains,\ inh_synapses, inh_netcons, inh_Ks, inh_spike_trains, area_lists, spkout
# record the membrane potentials and # synaptic currents #vec[ 'v_apic16'].record ( post (0.5)._ref_v ) vec['v_apic16'].record(pyramidal.apic[16](1)._ref_v) #vec[ 'i_syn'].record ( syn._ref_i ) vec['v_soma'].record(pyramidal.soma(0.5)._ref_v) vec['v_apic12'].record(pyramidal.apic[12](0.5)._ref_v) #record current of different synapses: #vec[ 'i_syn'].record ( syn_exp._ref_i ) vec['i_syn'].record(syn._ref_i) vec['i_syn2'].record(syn2._ref_i) vec['i_syn3'].record(syn3._ref_i) vec['t'].record(h._ref_t) # run the simulation apcount = h.APCount(pyramidal.soma(0.5)) apcount.thresh = 1 h.load_file("stdrun.hoc") h.init() h.tstop = 1000.0 h.run() print "number of spikes = ", apcount.n # plot the results #import pylab import matplotlib.pyplot as plt from matplotlib.pyplot import cm import numpy as np import matplotlib.patches as mpatches
def rhoebase_counter(cell, min_current = min_current, max_current = max_current, rheobase_step = rheobase_step): apc = h.APCount(cell.soma(0.5)) apc.thresh = -30 #Changed from -10 current_lst = np.arange(min_current, max_current, rheobase_step)