def make_syaptic_stimuli(cell, input_idx): # Define synapse parameters synapse_parameters = { 'idx': input_idx, 'e': 0., # reversal potential 'syntype': 'ExpSyn', # synapse type 'tau': 10., # syn. time constant 'weight': 0.0001, # syn. weight 'record_current': True, } synapse = LFPy.Synapse(cell, **synapse_parameters) synapse.set_spike_times(np.array([80.])) # Define synapse parameters synapse_parameters = { 'idx': input_idx, 'e': -100., # reversal potential 'syntype': 'ExpSyn', # synapse type 'tau': 10., # syn. time constant 'weight': 0.0001, # syn. weight 'record_current': True, } synapse = LFPy.Synapse(cell, **synapse_parameters) synapse.set_spike_times(np.array([5.])) return cell, synapse
def test_Synapse_01(self): cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test', 'ball_and_sticks.hoc')) syn0 = LFPy.Synapse(cell=cell, idx=0, syntype='ExpSynI', weight=1., tau=5., record_current=True, record_potential=True) syn0.set_spike_times(np.array([10.])) syn1 = LFPy.Synapse(cell=cell, idx=1, syntype='ExpSynI', weight=1., tau=5., record_current=True, record_potential=False) syn1.set_spike_times(np.array([20.])) syn2 = LFPy.Synapse(cell=cell, idx=2, syntype='ExpSynI', weight=1., tau=5., record_current=False, record_potential=True) syn2.set_spike_times(np.array([30.])) syn3 = LFPy.Synapse(cell=cell, idx=3, syntype='ExpSynI', weight=1., tau=5., record_current=False, record_potential=False) syn3.set_spike_times(np.array([40.])) cell.simulate() i = np.zeros(cell.tvec.size) i[cell.tvec > 10.] = -np.exp(-np.arange( (cell.tvec > 10.).sum()) * cell.dt / 5.) np.testing.assert_allclose(i, syn0.i, rtol=1E-1) np.testing.assert_equal(cell.somav, syn0.v) self.assertTrue(hasattr(syn1, 'i')) i = np.zeros(cell.tvec.size) i[cell.tvec > 20.] = -np.exp(-np.arange( (cell.tvec > 20.).sum()) * cell.dt / 5.) self.assertFalse(hasattr(syn1, 'v')) np.testing.assert_allclose(i, syn1.i, rtol=1E-1) self.assertFalse(hasattr(syn2, 'i')) self.assertTrue(hasattr(syn2, 'v')) self.assertFalse(hasattr(syn3, 'i')) self.assertFalse(hasattr(syn3, 'v'))
def createSynapse(self, cell, location, distal, spikes): if (distal == True): syn = LFPy.Synapse(cell, idx=location, **self.DISTAL_SYN) else: syn = LFPy.Synapse(cell, idx=location, **self.PROXIMAL_SYN) syn.set_spike_times(spikes) cell._loadspikes() return syn
def createSynapse(self, cell, location, locked, spikes, delay=1.0): if (locked == True): syn = LFPy.Synapse(cell, idx=location, **self.LOCKED_SYN) syn.set_spike_times(spikes + delay) else: syn = LFPy.Synapse(cell, idx=location, **self.RGC_SYN) syn.set_spike_times(spikes) cell._loadspikes() return syn
def test_cell_simulate_current_dipole_moment_02(self): stickParams = { 'morphology': os.path.join(LFPy.__path__[0], 'test', 'stick.hoc'), 'cm': 1, 'Ra': 150, 'v_init': -65, 'passive': True, 'passive_parameters': { 'g_pas': 1. / 30000, 'e_pas': -65 }, 'tstart': -100, 'tstop': 100, 'dt': 2**-4, 'nsegs_method': 'lambda_f', 'lambda_f': 100, } stimParams = { 'e': 0, # reversal potential 'syntype': 'Exp2Syn', # synapse type 'tau1': 0.1, # syn. time constant 'tau2': 2., # syn. time constant 'weight': 0.01, } for idx in range(31): #31 segments if idx != 15: # no net dipole moment because of stick symmetry stick = LFPy.Cell(**stickParams) synapse = LFPy.Synapse(stick, idx=idx, **stimParams) synapse.set_spike_times(np.array([10., 20., 30., 40., 50.])) stick.simulate(rec_imem=True, rec_current_dipole_moment=True) p = np.dot(stick.imem.T, np.c_[stick.xmid, stick.ymid, stick.zmid]) np.testing.assert_allclose(p, stick.current_dipole_moment)
def insert_synapses(synparams, section, n, heights, cell): soma_h = heights['soma'] if section == 'bas': sec = 'dend' maxim = heights['basal_max'] minim = heights['min'] if section == 'apic': sec = 'apic' maxim = heights['max'] minim = heights['apical_min'] if section == 'allsec': sec = 'allsec' maxim = heights['max'] minim = heights['min'] if section == 'soma': sec = 'soma' maxim = 0 minim = 0 '''find n compartments to insert synapses onto''' idx = cell.get_rand_idx_area_norm(section=sec, nidx=n, z_min=soma_h + minim, z_max=soma_h + maxim) # Insert synapses in an iterative fashion for i in idx: synparams.update({'idx': int(i)}) # # Create synapse(s) and setting times using the Synapse class in LFPy s = LFPy.Synapse(cell, **synparams) s.set_spike_times(np.array([np.random.normal(loc=25, scale=1)]))
def test_Network_04(self): cellParameters = dict( morphology=os.path.join(LFPy.__path__[0], 'test', 'ball_and_sticks_w_lists.hoc'), templatefile=os.path.join(LFPy.__path__[0], 'test', 'ball_and_stick_template.hoc'), templatename='ball_and_stick_template', templateargs=None, passive=True, dt=2**-3, tstop=100, delete_sections=False, ) synapseParameters = dict(idx=0, syntype='Exp2Syn', weight=0.002, tau1=0.1, tau2=0.1, e=0) populationParameters = dict( CWD=None, CELLPATH=None, Cell=LFPy.NetworkCell, cell_args=cellParameters, pop_args=dict(radius=100, loc=0., scale=20.), rotation_args=dict(x=0, y=0), POP_SIZE=1, name='test', ) networkParameters = dict(dt=2**-3, tstart=0., tstop=100., v_init=-70., celsius=6.3, OUTPUTPATH='tmp_testNetworkPopulation') # set up network = LFPy.Network(**networkParameters) network.create_population(**populationParameters) cell = network.populations['test'].cells[0] # create synapses synlist = [] numsynapses = 2 for i in range(numsynapses): synlist.append(LFPy.Synapse(cell=cell, **synapseParameters)) synlist[-1].set_spike_times(np.array([10 + (i * 10)])) network.simulate() # test that the input results in the correct amount of PSPs np.testing.assert_equal( ss.argrelextrema(cell.somav, np.greater)[0].size, numsynapses) # clean up network.pc.gid_clear() os.system('rm -r tmp_testNetworkPopulation') neuron.h('forall delete_section()')
def simulate(cell_parameters, synapse_parameters, grid_electrode_parameters, syninds, x_rot=0, y_rot=0, z_rot=0, active=False): """set synapse location. simulate cell, synapse and electrodes for input synapse location""" # create cell with parameters in dictionary if not active: cell = LFPy.Cell(**cell_parameters) else: cell = LFPy.TemplateCell(**cell_parameters) # rotate cell cell.set_rotation(x=x_rot) cell.set_rotation(y=y_rot) cell.set_rotation(z=z_rot) # insert synapses if type(syninds) == int: syninds = [syninds] for idx in syninds: synapse_parameters['idx'] = idx synapse = LFPy.Synapse(cell, **synapse_parameters) synapse.set_spike_times(np.array([20.])) # simulate cell cell.simulate(rec_imem = True, rec_vmem = True, rec_current_dipole_moment=True) #create grid electrodes grid_electrode = LFPy.RecExtElectrode(cell, **grid_electrode_parameters) grid_electrode.calc_lfp() return cell, synapse, grid_electrode
def cell_thread(task_queue, done_queue): '''thread function for simulation of single neuron process''' for n in iter(task_queue.get, 'STOP'): print 'Cell number %s out of %d.' % (n, pop_params['n'] - 1) cell = LFPy.Cell(**cellparams) cell.set_pos(**soma_pos[withsyn_i[n]]) cell.set_rotation(**rotation[withsyn_i[n]]) cell.color = 'g' #synapses e_synparams = e_synparams_init.copy() for idx in allidx_e[n]: e_synparams = e_synparams_init.copy() e_synparams.update({'idx': int(idx), 'color': 'r'}) e_spiketimes = [pl.array([spiketime])] s_e = LFPy.Synapse(cell, **e_synparams) s_e.set_spike_times(e_spiketimes[0]) cell.simulate(**simparams) cell.strip_hoc_objects() done_queue.put([e_synparams, cell])
def cell_w_synapse_from_sections(morphology): ''' Make cell and synapse objects, set spike, simulate and return cell ''' cellParams = { 'morphology': morphology, 'cm': 1, 'Ra': 150, 'v_init': -65, 'passive': True, 'passive_parameters': { 'g_pas': 1. / 30000, 'e_pas': -65 }, 'dt': 2**-6, 'tstart': -50, 'tstop': 50, 'delete_sections': False } synapse_parameters = { 'e': 0., 'syntype': 'ExpSyn', 'tau': 5., 'weight': .001, 'record_current': True, 'idx': 1 } cell = LFPy.Cell(**cellParams) synapse = LFPy.Synapse(cell, **synapse_parameters) synapse.set_spike_times(np.array([1.])) cell.simulate(rec_current_dipole_moment=True, rec_vmem=True) return cell
def cosine_current_injection(self, tstop=850): pre_syn_sptimes = self.stationary_poisson(nsyn=self.n_pre_syn, lambd=2, tstart=0, tstop=400) l = np.arange(self.n_pre_syn) pre_syn_pick = np.random.permutation(l)[0:self.n_synapses] self.synapse_parameters['weight'] = 0.05 pars = {} for i_syn in range(self.n_synapses): syn_idx = int(self.cell.get_rand_idx_area_norm()) spike_times = pre_syn_sptimes[pre_syn_pick[i_syn]] if syn_idx in pars: pars[syn_idx].extend(list(spike_times)) else: pars[syn_idx] = list(spike_times) for syn_idx in pars: self.synapse_parameters.update({'idx': syn_idx}) synapse = LFPy.Synapse(self.cell, **self.synapse_parameters) synapse.set_spike_times(np.array(pars[syn_idx])) self.point_process['dur'] = 1 TimesStim = np.arange(tstop) stim = np.array(3.6e-1 * np.sin(2. * 3.141 * 6.5 * TimesStim / 1000.)) for istim in range(tstop): self.point_process['amp'] = stim[istim] self.point_process['delay'] = istim stimulus = LFPy.StimIntElectrode(self.cell, **self.point_process)
def distal_cosine_current_injection(self, tstop=850): pre_syn_sptimes = self.stationary_poisson(nsyn=self.n_pre_syn, lambd=2, tstart=0, tstop=400) l = np.arange(self.n_pre_syn) pre_syn_pick = np.random.permutation(l)[0:self.n_synapses] pars = {} for i_syn in range(self.n_synapses): syn_idx = int(self.cell.get_rand_idx_area_norm()) spike_times = pre_syn_sptimes[pre_syn_pick[i_syn]] if syn_idx in pars: pars[syn_idx].extend(list(spike_times)) else: pars[syn_idx] = list(spike_times) for syn_idx in pars: self.synapse_parameters.update({'idx': syn_idx}) synapse = LFPy.Synapse(self.cell, **self.synapse_parameters) synapse.set_spike_times(np.array(pars[syn_idx])) TimesStim = np.arange(850) stim = np.array(3.6*np.sin(2.*3.141*6.5*TimesStim/1000.)) all_idxs = self.cell.get_idx() for istim in range(tstop): pointprocess = { 'idx' : max(all_idxs), 'pptype': 'IClamp', 'record_current' : True, 'amp': stim[istim], 'dur' : 1., 'delay': istim, } stimulus = LFPy.StimIntElectrode(self.cell, **pointprocess)
def return_cell(): neuron.load_mechanisms("HallermannEtAl2012") # Define cell parameters cell_parameters = { # various cell parameters, 'morphology' : 'unmyelinated_axon_Hallermann.hoc', # Mainen&Sejnowski, 1996 'v_init' : -80., # initial crossmembrane potential 'passive' : False, # switch off passive mechs 'nsegs_method' : 'lambda_f', 'lambda_f' : 1000., 'dt' : 2.**-7, # [ms] dt's should be in powers of 2 'tstart' : -200., # start time of simulation, recorders start at t=0 'tstop' : 2., # stop simulation at 2 ms. } cell = LFPy.Cell(**cell_parameters) cell.set_pos(x=-np.max(cell.xmid) / 2, z=2.5) # To induce a spike: synapseParameters = { 'idx' : 0, # insert synapse on index "0", the soma 'e' : 0., # reversal potential of synapse 'syntype' : 'Exp2Syn', # conductance based double-exponential synapse 'tau1' : 0.1, # Time constant, decay 'tau2' : 0.1, # Time constant, decay 'weight' : 0.004, # Synaptic weight 'record_current' : False, # Will enable synapse current recording } # attach synapse with parameters and input time synapse = LFPy.Synapse(cell, **synapseParameters) synapse.set_spike_times(np.array([0.1])) cell.simulate(rec_vmem=True, rec_imem=True) return cell
def insert_synapses(synparams, section, n, spTimesFun, args): '''find n compartments to insert synapses onto''' spk_times_save = [] idx = cell.get_rand_idx_area_norm(section=section, nidx=n) mu_wgt = synparams['weight'] #Insert synapses in an iterative fashion for i in idx: # make synaptic weights vary around the mean rand_wgt = numpy.random.normal(mu_wgt, mu_wgt / 10) synparams['weight'] = rand_wgt wgts.append(synparams['weight']) synparams.update({'idx': int(i)}) # Some input spike train using the function call [spiketimes] = spTimesFun(**args) # Create synapse(s) and setting times using the Synapse class in LFPy s = LFPy.Synapse(cell, **synparams) s.set_spike_times(spiketimes) spk_times_save.append(spiketimes) return spk_times_save
def cell_thread_PSC(task_queue, done_queue): '''thread function for simulation of single neuron process''' for n in iter(task_queue.get, 'STOP'): print 'Cell number %s out of %d.' % (n, pop_params['n'] - 1) cell = LFPy.Cell(**cellparams) e_synparams = e_synparams_init.copy() for idx in allidx_e[n]: e_synparams = e_synparams_init.copy() e_synparams.update({'idx': int(idx), 'color': (0.8, 0.8, 0.8)}) e_spiketimes = [pl.array([spiketime])] s_e = LFPy.Synapse(cell, **e_synparams) s_e.set_spike_times(e_spiketimes[0]) e_synparams = e_synparams_init.copy() LFPy.StimIntElectrode(cell, **pointprocparams) cell.simulate(**simparams2) cell.tvec = pl.arange( -1, cellparams['timeres_python'] * len(cell.tvec) - 1, cellparams['timeres_python']) cell.strip_hoc_objects() done_queue.put(cell)
def set_input_spiketrain(self, cell, cell_input_idxs, spike_trains, synapse_params): synapse_list = [] for number, comp_idx in enumerate(cell_input_idxs): synapse_params.update({'idx': int(comp_idx)}) s = LFPy.Synapse(cell, **synapse_params) s.set_spike_times(spike_trains[number]) synapse_list.append(s) return synapse_list
def test_Synapse_05(self): cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test', 'ball_and_sticks.hoc')) t0 = 10. t1 = 30. tau = 5. syn0 = LFPy.Synapse(cell=cell, idx=0, syntype='ExpSynI', weight=1., tau=tau, record_current=True, record_potential=True) syn1 = LFPy.Synapse(cell=cell, idx=0, syntype='ExpSynI', weight=1., tau=tau, record_current=True, record_potential=True) syn1.set_spike_times(np.array([t1])) syn0.set_spike_times_w_netstim(noise=0., start=t0 - 1, number=1) # -1 to acct for delay cell.simulate() i0 = np.zeros(cell.tvec.size) i0[cell.tvec > t0] = -np.exp(-np.arange( (cell.tvec > t0).sum()) * cell.dt / tau) i1 = np.zeros(cell.tvec.size) i1[cell.tvec > t1] = -np.exp(-np.arange( (cell.tvec > t1).sum()) * cell.dt / tau) np.testing.assert_allclose(i0, syn0.i, rtol=1E-1) np.testing.assert_equal(cell.somav, syn0.v) np.testing.assert_allclose(i1, syn1.i, rtol=1E-1) np.testing.assert_equal(cell.somav, syn1.v) cell.__del__() '''for attr in cell.__dict__.keys():
def y_shaped_symmetric_input(self): self.synapse_parameters['idx'] = 0 pre_syn_sptimes = [np.array([5., 25., 60.]), np.array([5., 45., 60.])] syn_no = [65, 33] for i, i_syn in enumerate(syn_no): new_pars = self.synapse_parameters.copy() new_pars['idx'] = i_syn synapse = LFPy.Synapse(self.cell, **new_pars) synapse.set_spike_times(pre_syn_sptimes[i])
def insert_synapses(synparams, section, n, netstimParameters): '''find n compartments to insert synapses onto''' idx = cell.get_rand_idx_area_norm(section=section, nidx=n) #Insert synapses in an iterative fashion for i in idx: synparams.update({'idx' : int(i)}) # Create synapse(s) and setting times using the Synapse class in LFPy s = LFPy.Synapse(cell, **synparams) s.set_spike_times_w_netstim(**netstimParameters)
def insert_synapses(synparams, cell, section, n, spTimesFun, args): ''' find n compartments to insert synapses onto ''' idx = cell.get_rand_idx_area_norm(section=section, nidx=n) #Insert synapses in an iterative fashion for i in idx: synparams.update({'idx': int(i)}) # Some input spike train using the function call spiketimes = spTimesFun(args[0], args[1], args[2], args[3], args[4]) # Create synapse(s) and setting times using the Synapse class in LFPy s = LFPy.Synapse(cell, **synparams) s.set_spike_times(spiketimes)
def simulate_cell(index,morphologyPath,folderPath): # simulation parameters neuron.h.celsius = 24 # Celsius, experiment temperature upsideDown = True inputSign = 0 # 0 for excitatory input, -90 for inhibitory soma_z = 150 passiveMechanism = True cell = make_cell(morphologyPath,soma_z,upsideDown) cell = set_membrane_mechanism(cell, isPassive = passiveMechanism) elec_x, elec_y, elec_z = make_MEA(xStart=-600,xEnd=600,xResolution=30, yStart=-600,yEnd=600,yResolution=30, zStart=120,zEnd=150,zResolution=10) elec_params = {'slice_thickness': soma_z+np.max(cell.zend), # keep cell contact with the saline layer on the top 'elec_radius': 1., 'elec_x': elec_x, 'elec_y': elec_y, 'elec_z': elec_z, } MEA = Electrode(**elec_params) ext_sim_dict = {'use_line_source': False, 'n_elecs': MEA.num_elecs, #'n_avrg_points': 100, #'elec_radius': MEA.elec_radius, 'moi_steps': 20, 'elec_x': MEA.elec_x, 'elec_y': MEA.elec_y, 'elec_z': MEA.elec_z, 'slice_thickness': MEA.slice_thickness, 'include_elec': False, 'neural_input': '.', } # insert the synapse synPos = get_syn_pos(cell) synIdx = cell.get_closest_idx(x=synPos[index,0], y=synPos[index,1], z=synPos[index,2],section='dend') synapse_parameters = { 'idx': synIdx, 'e': inputSign, # Change to -90 for inhibitory input, and 0 for excitatory 'syntype': 'Exp2Syn', 'tau1': 1., 'tau2': 1., 'weight': 0.005, # 0.005 for passive membrane 'record_current': True, } synapse = LFPy.Synapse(cell, **synapse_parameters) synapse.set_spike_times(np.array([10.])) # Set time(s) of synaptic input #print "Simulating cell" cell.simulate(rec_imem=True, rec_vmem=True, rec_isyn=True) phi = make_mapping(cell, MEA, ext_sim_dict) phiProfile = average_phi_radically(phi,MEA,[synPos[index,0],synPos[index,1]],folderPath,rResolution=30) np.save(join(folderPath, 'phiProfile'+str(index)+'.npy'),phiProfile)
def random_synaptic_input(self, lambd=2, tstart=0, tstop=70): self.synapse_parameters['idx'] = 0 pre_syn_sptimes = self.stationary_poisson(self.n_pre_syn, lambd, tstart, tstop) l = np.arange(self.n_pre_syn) self.pre_syn_pick = np.random.permutation(l)[0:self.n_synapses] for i_syn in range(self.n_synapses): syn_idx = int(self.cell.get_rand_idx_area_norm()) self.synapse_parameters.update({'idx': syn_idx}) synapse = LFPy.Synapse(self.cell, **self.synapse_parameters) synapse.set_spike_times(pre_syn_sptimes[self.pre_syn_pick[i_syn]])
def make_synapse(cell, weight, input_idx): input_spike_train = np.array([10.]) synapse_parameters = { 'idx': input_idx, 'e': 0., 'syntype': 'ExpSyn', 'tau': 10., 'weight': weight, 'record_current': True, } synapse = LFPy.Synapse(cell, **synapse_parameters) synapse.set_spike_times(input_spike_train) return cell, synapse
def make_synapse(cell, weight, input_idx, input_spike_train, e=0., syntype='Exp2Syn'): synapse_parameters = { 'idx': input_idx, 'e': e, 'syntype': syntype, 'tau1': 1., #Time constant, rise 'tau2': 3., #5 #Time constant, decay 'weight': weight, 'record_current': False, } synapse = LFPy.Synapse(cell, **synapse_parameters) synapse.set_spike_times(np.array([input_spike_train])) return cell, synapse
def simulate(cell, synapse_parameters, synidx, input_time=20.): """set synapse location. simulate cell, synapse and electrodes for input synapse location""" for idx in synidx: synapse_parameters['idx'] = idx # # create synapse with parameters in dictionary synapse = LFPy.Synapse(cell, **synapse_parameters) synapse.set_spike_times(np.array([input_time])) cell.simulate(rec_imem=True, rec_vmem=True, rec_current_dipole_moment=True) #create grid electrodes electrode_array = LFPy.RecExtElectrode(cell, **electrodeParams) electrode_array.calc_lfp() return cell, synapse, electrode_array
def cell_w_synapse_from_sections_w_electrode(morphology, electrode_locs): ''' Make cell and synapse objects, set spike, simulate and return cell ''' cellParams = { 'morphology': morphology, 'cm': 1, 'Ra': 150, 'v_init': -65, 'passive': True, 'passive_parameters': { 'g_pas': 1. / 30000, 'e_pas': -65 }, 'dt': 2**-6, 'tstart': -50, 'tstop': 50, 'delete_sections': False } electrodeParams = { 'sigma': 0.3, 'x': electrode_locs[:, 0], 'y': electrode_locs[:, 1], 'z': electrode_locs[:, 2], } cell = LFPy.Cell(**cellParams) electrode = LFPy.RecExtElectrode(cell, **electrodeParams) synapse_parameters = { 'e': 0., 'syntype': 'ExpSyn', 'tau': 5., 'weight': .1, 'record_current': True, 'idx': cell.totnsegs - 1 } synapse = LFPy.Synapse(cell, **synapse_parameters) synapse.set_spike_times(np.array([1.])) cell.simulate(electrode=[electrode], rec_current_dipole_moment=True, rec_vmem=True) return cell, electrode
def insert_synapses(cell, synparams, section, n, spTimesFun, args, z_min=-1e9, z_max=1e9): '''find n compartments to insert synapses onto''' idx = cell.get_rand_idx_area_norm(section=section, nidx=n, z_min=z_min, z_max=z_max) # idx = cell.get_rand_idx_area_and_distribution_norm(section=section, # funargs=dict(loc=500, scale=150), # nidx=n, z_min=z_min, z_max=z_max) synapses = [] #Insert synapses in an iterative fashion for i in idx: synparams.update({'idx' : int(i)}) # Some input spike train using the function call [spiketimes] = spTimesFun(**args) # Create synapse(s) and setting times using the Synapse class in LFPy s = LFPy.Synapse(cell, **synparams) s.set_spike_times(np.array([spiketimes])) synapses.append(s) return synapses
def test_Synapse_00(self): cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test', 'ball_and_sticks.hoc')) syn = LFPy.Synapse(cell=cell, idx=0, syntype='ExpSynI', weight=1., tau=5., record_current=True, record_potential=True) syn.set_spike_times(np.array([10.])) cell.simulate() i = np.zeros(cell.tvec.size) i[cell.tvec > 10.] = -np.exp(-np.arange( (cell.tvec > 10.).sum()) * cell.dt / 5.) np.testing.assert_allclose(i, syn.i, rtol=1E-1) np.testing.assert_equal(cell.somav, syn.v)
def insert_synapses(centerpos, radius, dryrun, synparams, section, n, spTimesFun, args): if section is None: idx = cell.get_rand_idx_area_norm(nidx=n) else: idx = cell.get_rand_idx_area_norm(nidx=n, section=section) inserted = 0 for i in idx: if (cell.xmid[i] - centerpos[0])**2 + (cell.ymid[i] - centerpos[1])**2 + ( cell.zmid[i] - centerpos[2])**2 <= radius**2: inserted += 1 if not dryrun: synparams.update({'idx': int(i)}) spiketimes = spTimesFun(args[0], args[1], args[2], args[3], args[4]) s = LFPy.Synapse(cell, **synparams) s.set_spike_times(spiketimes) return inserted
def run_sim(morphology='patdemo/cells/j4a.hoc', cell_rotation=dict(x=4.99, y=-4.33, z=3.14), closest_idx=dict(x=-200., y=0., z=800.)): '''set up simple cell simulation with LFPs in the plane''' # Create cell cell = LFPy.Cell(morphology=morphology, **cell_parameters) # Align cell cell.set_rotation(**cell_rotation) # Define synapse parameters synapse_parameters = { 'idx' : cell.get_closest_idx(**closest_idx), 'e' : 0., # reversal potential 'syntype' : 'ExpSynI', # synapse type 'tau' : 0.5, # synaptic time constant 'weight' : 0.0878, # synaptic weight 'record_current' : True, # record synapse current } # Create synapse and set time of synaptic input synapse = LFPy.Synapse(cell, **synapse_parameters) synapse.set_spike_times(np.array([1.])) # Create electrode object # Run simulation, electrode object argument in cell.simulate print "running simulation..." cell.simulate(rec_imem=True,rec_isyn=True) grid_electrode = LFPy.RecExtElectrode(cell,**grid_electrode_parameters) point_electrode = LFPy.RecExtElectrode(cell,**point_electrode_parameters) grid_electrode.calc_lfp() point_electrode.calc_lfp() print "done" return cell, synapse, grid_electrode, point_electrode