def run(self, temp=34.0, dt=0.025, seed=575982035, simulator=None): preCell = cells.DummySGC(cf=4000, sr=2) postCell = cells.Bushy.create() synapse = preCell.connect(postCell) self.pre_cell = preCell self.post_cell = postCell self.synapse = synapse self.stim = sound.TonePip(rate=100e3, duration=0.1, f0=4000, dbspl=80, ramp_duration=2.5e-3, pip_duration=0.04, pip_start=[0.02]) preCell.set_sound_stim(self.stim, seed=seed, simulator=simulator) self['vm'] = postCell.soma(0.5)._ref_v #self['prevm'] = preCell.soma(0.5)._ref_v for i in range(30): self['xmtr%d' % i] = synapse.terminal.relsite._ref_XMTR[i] synapse.terminal.relsite.Dep_Flag = False self['t'] = h._ref_t h.tstop = 100.0 # duration of a run h.celsius = temp h.dt = dt custom_init() h.run()
def init_model(cell, mode='iclamp', vinit=-65., restore_from_file=False, filename=None, electrode_site=None, reinit=False): """ Model initialization procedure to set RMP to the resting RMP of the model cell. Does not instantiate recording or stimulating. Params ------ cell : cell, including hoc_reader file object (as .hr) mode : str (default: iclamp) mode string ('iclamp', 'vc', 'vclamp'). vinit : float initial voltage to start initialization, in mV. Default -65 mV restore_from_file : boolean flag to cause model to be restored from previously saved state file. The state file must be from the same model construction that exists at the time of the call to init_model. filename : str (default: None) Name of a state file to restore the initial conditions from electrode_site : NEURON section object (default: None) Site for the recording electrode to be located reinit : boolean (default: False) If restoring from file, setting reinit to True will also force a reinitialization. Returns ------- boolean : Success of initialization. Always True, just to indicate we were called. Errors result in exceptions. """ print('initmodel') if mode in ['vc', 'vclamp']: cell.hr.h.finitialize(vinit) # this is sufficient for initialization in voltage clamp print('vclamp') return True if mode not in ['iclamp']: raise ValueError('Mode must be "vc", "vclamp" or "iclamp"; got %s' % mode) # otherwise we are in current clamp # get state if one is specified if restore_from_file: print('restore: ', filename) restore_initial_conditions_state(cell, electrode_site=electrode_site, filename=filename, reinit=reinit) try: print('init?: ') cell.hr.h.frecord_init() # try an intialization except: raise ValueError('Unable to restore initial state') print('init OK') return True # much easier here... print('custom init') CU.custom_init(v_init=vinit) if electrode_site is not None: vm = electrode_site.v else: vm = 0. print('Initialized with finitialize, starting at %8.2f, ending %8.2f ' % (vinit, vm)) return True
print( 'build vectors') res = {} res['v_soma'] = h.Vector() res['v_soma'].record(soma(0.5)._ref_v) res['i_inj'] = h.Vector() res['i_inj'].record(vstim._ref_i) res['time'] = h.Vector() res['time'].record(h._ref_t) res['delec'] = h.Vector() res['delec'].record(dends[-1](0.5)._ref_v) print( 'init') h.dt = 0.025 custom_init(v_init=-65) h.finitialize() h.tstop = np.max(stimtimes) + tipi h.t = 0. while h.t < h.tstop: h.fadvance() # h.batch_save() # save nothing # h.batch_run(h.tstop, h.dt, "dend.dat") fig, ax = mpl.subplots(4, 1, figsize=(5, 10)) ax = ax.ravel() ax[0].plot(res['time'], res['i_inj']) for i in range(nsyn): it0 = np.argmin(np.fabs(np.array(res['time']) - (5+i*tipi))) it1 = np.argmin(np.fabs(np.array(res['time']) - (5+i*tipi + tipi/2.))) print( it0, it1)
def run(self, pre_sec, post_sec, n_synapses, temp=34.0, dt=0.025, vclamp=40.0, iterations=1, tstop=240.0, stim_params=None, synapsetype='multisite', **kwds): """ Basic synapse test. Connects sections of two cells with *n_synapses*. The cells are allowed to negotiate the details of the connecting synapse. The presynaptic soma is then driven with a pulse train followed by a recovery pulse of varying delay. *stim_params* is an optional dictionary with keys 'NP', 'Sfreq', 'delay', 'dur', 'amp'. Analyses: * Distribution of PSG amplitude, kinetics, and latency * Synaptic depression / facilitation and recovery timecourses """ Protocol.run(self, **kwds) pre_cell = cells.cell_from_section(pre_sec) post_cell = cells.cell_from_section(post_sec) synapses = [] for i in range(n_synapses): synapses.append(pre_cell.connect(post_cell, type=synapsetype)) self.synapses = synapses self.pre_sec = synapses[0].terminal.section self.post_sec = synapses[0].psd.section self.pre_cell = pre_cell self.post_cell = post_cell self.plots={} # store plot information here # # voltage clamp the target cell # clampV = vclamp vccontrol = h.VClamp(0.5, sec=post_cell.soma) vccontrol.dur[0] = 10.0 vccontrol.amp[0] = clampV vccontrol.dur[1] = 100.0 vccontrol.amp[1] = clampV vccontrol.dur[2] = 20.0 vccontrol.amp[2] = clampV # # set up stimulation of the presynaptic axon/terminal # istim = h.iStim(0.5, sec=pre_cell.soma) stim = { 'NP': 10, 'Sfreq': 100.0, 'delay': 10.0, 'dur': 0.5, 'amp': 10.0, 'PT': 0.0, 'dt': dt, } if stim_params is not None: stim.update(stim_params) (secmd, maxt, tstims) = util.make_pulse(stim) self.stim = stim if tstop is None: tstop = len(secmd) * dt istim.delay = 0 istim.dur = 1e9 # these actually do not matter... istim.iMax = 0.0 # istim current pulse train i_stim_vec = h.Vector(secmd) i_stim_vec.play(istim._ref_i, dt, 0) # create hoc vectors for each parameter we wish to monitor and display synapse = synapses[0] self.all_psd = [] if isinstance(synapses[0].psd, GlyPSD) or isinstance(synapses[0].psd, GluPSD): for syn in synapses: self.all_psd.extend(syn.psd.all_psd) elif isinstance(synapses[0].psd, Exp2PSD): for syn in synapses: self.all_psd.append(syn) #for i, cleft in enumerate(synapse.psd.clefts): #self['cleft_xmtr%d' % i] = cleft._ref_CXmtr #self['cleft_pre%d' % i] = cleft._ref_pre #self['cleft_xv%d' % i] = cleft._ref_XV #self['cleft_xc%d' % i] = cleft._ref_XC #self['cleft_xu%d' % i] = cleft._ref_XU # # Run simulation # h.tstop = tstop # duration of a run h.celsius = temp h.dt = dt self.temp = temp self.dt = dt self.isoma = [] self.currents = {'ampa': [], 'nmda': []} self.all_releases = [] self.all_release_events = [] start_time = timeit.default_timer() for nrep in xrange(iterations): # could do multiple runs.... self.reset() self['v_pre'] = pre_cell.soma(0.5)._ref_v self['t'] = h._ref_t self['v_soma'] = pre_cell.soma(0.5)._ref_v if not isinstance(synapse.psd, Exp2PSD): self['relsite_xmtr'] = synapse.terminal.relsite._ref_XMTR[0] if isinstance(synapse.psd, GluPSD): # make a synapse monitor for each release zone self.all_nmda = [] self.all_ampa = [] for syn in synapses: # collect all PSDs across all synapses self.all_ampa.extend(syn.psd.ampa_psd) self.all_nmda.extend(syn.psd.nmda_psd) # Record current through all PSDs individually syn.psd.record('i', 'g', 'Open') #for k,p in enumerate(self.all_nmda): #self['iNMDA%03d' % k] = p._ref_i #self['opNMDA%03d' % k] = p._ref_Open #for k,p in enumerate(self.all_ampa): #self['iAMPA%03d' % k] = p._ref_i #self['opAMPA%03d' % k] = p._ref_Open elif isinstance(synapse.psd, GlyPSD): # Record current through all PSDs individually for k,p in enumerate(self.all_psd): self['iGLY%03d' % k] = p._ref_i self['opGLY%03d' % k] = p._ref_Open psd = self.all_psd if synapse.psd.psdType == 'glyslow': nstate = 7 self['C0'] = psd[0]._ref_C0 self['C1'] = psd[0]._ref_C1 self['C2'] = psd[0]._ref_C2 self['O1'] = psd[0]._ref_O1 self['O2'] = psd[0]._ref_O2 self['D1'] = psd[0]._ref_D1 #self['D3'] = psd[0]._ref_D3 #self['O1'] = psd[0]._ref_O1 elif synapse.psd.psdType == 'glyfast': nstate = 7 self['C0'] = psd[0]._ref_C0 self['C1'] = psd[0]._ref_C1 self['C2'] = psd[0]._ref_C2 self['C3'] = psd[0]._ref_C3 self['O1'] = psd[0]._ref_O1 self['O2'] = psd[0]._ref_O2 elif isinstance(synapse.psd, Exp2PSD): self['iPSD'] = self.all_psd[0].psd.syn._ref_i if not isinstance(synapse.psd, Exp2PSD): for i, s in enumerate(synapses): s.terminal.relsite.rseed = util.random_seed.current_seed() + nrep util.custom_init() h.run() # add up psd current across all runs if isinstance(synapse.psd, GluPSD): iampa = np.zeros_like(synapse.psd.get_vector('ampa', 'i')) inmda = iampa.copy() for syn in self.synapses: for i in range(syn.psd.n_psd): iampa += syn.psd.get_vector('ampa', 'i', i) inmda += syn.psd.get_vector('nmda', 'i', i) isoma = iampa + inmda self.currents['ampa'].append(iampa) self.currents['nmda'].append(inmda) elif isinstance(synapse.psd, GlyPSD): isoma = np.zeros_like(self['iGLY000']) for k in range(len(self.all_psd)): isoma += self['iGLY%03d'%k] elif isinstance(synapse.psd, Exp2PSD): isoma = self['iPSD'] self.isoma.append(isoma) self.all_releases.append(self.release_timings()) self.all_release_events.append(self.release_events()) elapsed = timeit.default_timer() - start_time print 'Elapsed time for %d Repetions: %f' % (iterations, elapsed)
def run_one(self, istim, stim, initflag=True, sites=None): """ Perform one run in current-clamp for the selected cell and add the data to the traces Monitor the presyanptic cell body and axon, as well as the current in a voltage-clamped target cell Parameters ---------- istim : Stimulus electrode instance stim : waveform information initflag : boolean (default: True) If true, force initialziation of the cell and computation of point Rin, tau and Vm sites : list of sections to monitor in addition to the soma """ h.dt = self.dt # establish this before we do any play/record setup # print('iv_curve:run_one') (secmd, maxt, tstims) = cnmodel.util.stim.make_pulse(stim) # print('maxt, dt*lencmd: ', maxt, len(secmd)*self.dt)# secmd = np.append(secmd, [0.]) # print('stim: ', stim, self.tend) # connect current command vector playvector = h.Vector(secmd) # sets up to "play" the array in secmd to # the stimulating electrode in the cell # Python-> neuron call to set up the stimulus playvector.play(istim._ref_i, h.dt, 0, sec=self.cell.soma) self.r = {} # results stored in a dict # Connect recording vectors self.r['v_soma'] = h.Vector() # neuron arrays are "Vector" # set up an electrode to record from the cell that is directly stimulated self.r['v_soma'].record(self.cell.soma(0.5)._ref_v, sec=self.cell.soma) # self['q10'] = self.cell.soma(0.5).ihpyr_adj._ref_q10 # self['ih_ntau'] = self.cell.soma(0.5).ihpyr_adj._ref_kh_n_tau # also record the current injection. self.r['i_inj'] = h.Vector() self.r['i_inj'].record(istim._ref_i, sec=self.cell.soma) self.r['time'] = h.Vector() self.r['time'].record(h._ref_t) # possibly record from all the axon nodes in the cell # sites is set up in the main initialization routine if sites is not None: recvec = [h.Vector() for x in sites] for i, r in enumerate(recvec): r.record(sites[i](0.5)._ref_v, h.dt, 0, sec=sites[i]) # for fun, monitor the presynaptic calcium concentration self.r['calyxca'] = h.Vector() self.r['calyxca'].record(sites[-1](1)._ref_cai, h.dt, 0, sec=sites[-1]) h.celsius = self.cell.status['temperature'] # print("iv_curve:run_one:calling cell_initialize") # set up an electrode in the postaynaptic cell. # This is a voltage clamp electrode, but we are just holding # the voltage constant. The parameters are required to be # set for this to work. clampV = -65. vccontrol = h.SEClamp(0.5, sec=self.post_cell.soma) vccontrol.dur1 = 10.0 vccontrol.amp1 = clampV vccontrol.dur2 = 100.0 vccontrol.amp2 = clampV vccontrol.dur3 = 25.0 vccontrol.amp3 = clampV vccontrol.rs = 1e-9 # close to perfect - no series resistance # record the current through the postsynaptic cell membrane # this is the synaptic current self.r['i_post'] = h.Vector() self.r['i_post'].record(vccontrol._ref_i, sec=self.post_cell.soma) # print("iv_curve:run_one:calling custom_init") CU.custom_init() # using our own initialization # now we can actually set up the run h.t = 0. h.tstop = np.sum(self.default_durs) print('stop: ', h.tstop, ' dt: ', h.dt) # and here it goes... while h.t < h.tstop: h.fadvance() # done! so now save the data from this run print('stop: ', h.tstop) # store the results in lists self.sgc_voltage_traces.append(self.r['v_soma']) self.current_traces.append(self.r['i_inj']) self.calyx_ca.append(self.r['calyxca']) self.post_cell_current_traces.append(self.r['i_post']) print('sgc trace len: ', len(self.sgc_voltage_traces)) print('post trace len: ', len(self.post_cell_current_traces)) self.time_values = np.array(self.r['time']) if sites is not None: # for i, r in enumerate(recvec): # print('r2: ', np.array(recvec[i])) self.axon_voltage_traces.append(np.array(recvec.copy()))
def run(self, pre_sec, post_sec, temp=34.0, dt=0.025, vclamp=-65.0, iterations=1, tstop=200.0, stim_params=None, **kwds): """ """ Protocol.run(self, **kwds) pre_cell = cells.cell_from_section(pre_sec) post_cell = cells.cell_from_section(post_sec) synapse = pre_cell.connect(post_cell, type='simple') self.synapse = synapse self.pre_sec = synapse.terminal.section self.post_sec = synapse.psd.section self.pre_cell = pre_cell self.post_cell = post_cell # # voltage clamp the target cell # vccontrol = h.VClamp(0.5, sec=post_cell.soma) vccontrol.dur[0] = tstop vccontrol.amp[0] = vclamp #vccontrol.dur[1] = 100.0 #vccontrol.amp[1] = clampV #vccontrol.dur[2] = 20.0 #vccontrol.amp[2] = clampV # # set up stimulation of the presynaptic axon/terminal # istim = h.iStim(0.5, sec=pre_cell.soma) stim = { 'NP': 10, 'Sfreq': 100.0, 'delay': 10.0, 'dur': 0.5, 'amp': 10.0, 'PT': 0.0, 'dt': dt, } if stim_params is not None: stim.update(stim_params) (secmd, maxt, tstims) = util.make_pulse(stim) self.stim = stim if tstop is None: tstop = len(secmd) * dt istim.delay = 0 istim.dur = 1e9 # these actually do not matter... istim.iMax = 0.0 # istim current pulse train i_stim_vec = h.Vector(secmd) i_stim_vec.play(istim._ref_i, dt, 0) # # Run simulation # h.tstop = tstop # duration of a run h.celsius = temp h.dt = dt self.temp = temp self.dt = dt for nrep in xrange(iterations): # could do multiple runs.... self.reset() self['v_pre'] = pre_cell.soma(0.5)._ref_v self['t'] = h._ref_t self['v_soma'] = post_cell.soma(0.5)._ref_v self['i_soma'] = vccontrol._ref_i util.custom_init() h.run()
def run(self, temp=38.0, dt=0.025, seed=575982035, simulator=None): ears = {'left': [500., 502, 498], 'right': [500., 502., 498]} self.beatfreq = 0. self.f0 = 500. f0 = {'left': self.f0, 'right': self.f0+self.beatfreq} nsgc = len(ears.keys()) sgcCell = {} bushyCell = {} msoCell = {} synapse = {} self.stim = {} self.ears = ears self.stimdur = 0.2 self.stimdelay = 0.02 self.rundur = self.stimdelay + self.stimdur + 0.02 for i, ear in enumerate(ears.keys()): nsgc = len(ears[ear]) # how many sgcs are specified for this ear sgcCell[ear] = [cells.DummySGC(cf=ears[ear][k], sr=2) for k in range(nsgc)] bushyCell[ear] = [cells.Bushy.create(temperature=temp)] synapse[ear] = [sgcCell[ear][k].connect(bushyCell[ear][0]) for k in range(nsgc)] self.stim[ear] = [sound.TonePip(rate=100e3, duration=self.stimdur+0.1, f0=f0[ear], dbspl=80, ramp_duration=2.5e-3, pip_duration=self.stimdur, pip_start=[self.stimdelay]) for k in range(nsgc)] for k in range(len(self.stim[ear])): sgcCell[ear][k].set_sound_stim(self.stim[ear][k], seed=seed + i*seed + k, simulator=simulator) self['vm_bu_%s' % ear] = bushyCell[ear][0].soma(0.5)._ref_v for k in range(30): self['xmtr%d_%s'%(k, ear)] = synapse[ear][0].terminal.relsite._ref_XMTR[k] for k in range(len(synapse[ear])): synapse[ear][k].terminal.relsite.Dep_Flag = False # turn off depression msoCell = cells.MSO.create(temperature=temp) # one target MSO cell msosyn = {} for ear in ears: msosyn[ear] = bushyCell[ear][0].connect(msoCell) self.sgc_cells = sgcCell self.bushy_cells = bushyCell self.synapses = synapse self.msyns = msosyn self.msoCell = msoCell self.all_cells = [] # hold all "real" cells (DummySGC does not have mechanisms) for ear in ears.keys(): self.all_cells.append([c for c in self.bushy_cells[ear]]) self.all_cells.append([self.msoCell]) self['vm_mso'] = self.msoCell.soma(0.5)._ref_v for k, ear in enumerate(ears.keys()): for i in range(30): self['mso_xmtr%d_%s'%(i, ear)] = msosyn[ear].terminal.relsite._ref_XMTR[i] msosyn[ear].terminal.relsite.Dep_Flag = False # turn off depression self['t'] = h._ref_t h.tstop = self.rundur*1e3 # duration of a run h.celsius = temp h.dt = dt custom_init() # confirm that all cells are ok for cg in self.all_cells: for c in cg: c.check_all_mechs() while h.t < h.tstop: h.fadvance()