def return_eeg(cell, radii, sigmas, eeg_coords, morph_type): # compute current dipole moment cdm = LFPy.CurrentDipoleMoment(cell) P = cdm.get_transformation_matrix() @ cell.imem # set dipole position r_soma_syns = [cell.get_intersegment_vector(idx0=0, idx1=i) for i in cell.synidx] r_mid = np.average(r_soma_syns, axis=0) if morph_type == 'l5i': somapos = np.array([0., 0., radii[0]-1200]) else: somapos = np.array([0., 0., radii[0] - np.max(cell.z) - 50]) dipole_pos = r_mid + somapos cell.set_pos(x=somapos[0], y=somapos[1], z=somapos[2]) # multi_dipoles, dipole_locs = cell.get_multi_current_dipole_moments() # t_point = 800 # P_from_multi_dipoles = np.sum(multi_dipoles[:,t_point,:],axis=0) # print('single dipole:', P[t_point]) # print('sum of multi-dipoles', P_from_multi_dipoles) # compute eeg with 4S model fs_eeg = LFPy.FourSphereVolumeConductor(eeg_coords, radii=radii, sigmas=sigmas) eeg = fs_eeg.get_transformation_matrix(dipole_pos) @ P eeg_multidip = fs_eeg.get_dipole_potential_from_multi_dipoles(cell) eeg_avg = np.average(eeg, axis=0) eeg_multidip_avg = np.average(eeg_multidip, axis=0) # convert from mV to pV: eeg_avg = eeg_avg * 1e9 eeg_multidip_avg = eeg_multidip_avg * 1e9 return eeg_avg, eeg_multidip_avg
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) cdm = LFPy.CurrentDipoleMoment(cell) 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(probes=[electrode, cdm], rec_vmem=True) return cell, electrode, cdm
def cell_w_synapse_from_sections(morphology, rec_current_dipole_moment=False): ''' 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.])) if rec_current_dipole_moment: probes = [LFPy.CurrentDipoleMoment(cell)] else: probes = [] cell.simulate(probes=probes, rec_vmem=True) if rec_current_dipole_moment: cell.current_dipole_moment = probes[0].data return cell
def make_data(morphology, cell_model, rot, rz, radii, sigmas, electrode_locs, syn_idcs, spiking, syn_input_time): # set cell and synapse parameters cell_parameters, synapse_parameters = set_parameters( morphology, cell_model, spiking) [xrot, yrot, zrot] = rot # create four-sphere class instance fs = LFPy.FourSphereVolumeConductor(electrode_locs, radii=radii, sigmas=sigmas) # lists for storing data: p_list = [] t_max_list = [] p_loc_list = [] lfp_single_dip_list = [] lfp_multi_dip_list = [] RE_list = [] synlocs = [] pz_traces = [] # get data from num_syns simulations num_syns = len(syn_idcs) for j in range(num_syns): cell = create_cell(cell_parameters, active=spiking, x_rot=xrot, y_rot=yrot, z_rot=zrot) ## if you know synidx: syn_idx = syn_idcs[j] # if you only know synapse location: # syn_loc = syn_idcs[j] # syn_idx = cell.get_closest_idx(x=syn_loc[0], y=syn_loc[1], z=syn_loc[2]) # print('syn_idx:', syn_idx) cell, synapse = simulate(cell, synapse_parameters, [syn_idx], syn_input_time) # print('cell simulated') cell.set_pos(x=rz[0], y=rz[1], z=rz[2]) syn_loc = (cell.x[syn_idx].mean(), cell.y[syn_idx].mean(), cell.z[syn_idx].mean()) synlocs.append((syn_loc[0], syn_loc[1], syn_loc[2])) # compute current dipole moment and subtract DC-component cdm = LFPy.CurrentDipoleMoment(cell) dipoles = cdm.get_transformation_matrix() @ cell.imem input_idx_before_input = np.argmin( np.abs(cell.tvec - syn_input_time)) - 1 p_dc = dipoles[:, input_idx_before_input] dipoles -= p_dc[:, None] pz_traces.append(dipoles[2, :]) # compute timepoint with biggest dipole timemax = [np.argmax(np.linalg.norm(np.abs(dipoles), axis=0))] t_max_list.append(timemax) p = dipoles[:, timemax] # compute LFP with single dipole # dip_loc = get_mass_center(cell, timemax) dip_loc = get_dipole_loc(rz, syn_loc) lfp_single_dip = fs.get_transformation_matrix(dip_loc) @ p # print('pot from single dip computed') # compute LFP with multi-dipole # subtract DC-component multi_p_319, multi_p_locs = cell.get_multi_current_dipole_moments( [input_idx_before_input]) multi_p_dc = multi_p_319 multi_p, multi_p_locs = cell.get_multi_current_dipole_moments(timemax) multi_p -= multi_p_dc Ni, Nd, Nt = multi_p.shape lfp_multi_dip = np.zeros((len(electrode_locs), Nt)) for num in range(Ni): pot = fs.get_transformation_matrix( multi_p_locs[num]) @ multi_p[num] # fs.calc_potential(multi_p[num], multi_p_locs[num]) lfp_multi_dip += pot # print('pot from multi dip computed') # compute relative errors RE = np.abs((lfp_single_dip - lfp_multi_dip) / lfp_multi_dip) print('syn number: {}; syn dist from soma: {}; RE_EEG: {}'.format( syn_idx, syn_loc[2] - rz[2], RE[-1])) #add data to lists for storage p_list.append(p) p_loc_list.append(dip_loc) lfp_single_dip_list.append(lfp_single_dip) lfp_multi_dip_list.append(lfp_multi_dip) RE_list.append(RE) # Do this for only one cell for plotting zips = [] for x, z in cell.get_idx_polygons(): zips.append(list(zip(x, z))) zmax = np.max(cell.z) soma_vmem = cell.vmem[0] tvec = cell.tvec return (p_list, pz_traces, lfp_multi_dip_list, lfp_single_dip_list, synlocs, zips, zmax, tvec, soma_vmem)
'syntype': 'ExpSyn', # exponential synapse 'tau': 5., # synapse time constant 'weight': 0.001, # 0.001, # synapse weight 'record_current': True # record synapse current } # create cell with parameters in dictionary cell = LFPy.Cell(**cell_params) pos = syn_loc synapse_params['idx'] = cell.get_closest_idx(x=pos[0], y=pos[1], z=pos[2]) synapse = LFPy.Synapse(cell, **synapse_params) synapse.set_spike_times(np.array([5.])) cell.simulate(rec_imem=True) # compute dipole cdm = LFPy.CurrentDipoleMoment(cell) P = cdm.get_transformation_matrix() @ cell.imem somapos = np.array([0., 0., 77500]) r_soma_syns = [ cell.get_intersegment_vector(idx0=0, idx1=i) for i in cell.synidx ] r_mid = np.average(r_soma_syns, axis=0) r_mid = somapos + r_mid / 2. eeg_coords_top = np.array([[0., 0., radii[3] - rad_tol]]) four_sphere_top = LFPy.FourSphereVolumeConductor(eeg_coords_top, radii, sigmas) pot_db_4s_top = four_sphere_top.get_dipole_potential(P, r_mid) eeg_top = np.array(pot_db_4s_top) * 1e9
########################################################################## # Set up extracellular electrodes and devices ########################################################################## probes = [] if PSET.COMPUTE_LFP: electrode = LFPy.RecExtElectrode(cell=None, **PSET.electrodeParams) probes.append(electrode) if PSET.COMPUTE_ECOG: ecog_electrode = LFPy.RecMEAElectrode(cell=None, **PSET.ecogParameters) probes.append(ecog_electrode) if PSET.COMPUTE_P: current_dipole_moment = LFPy.CurrentDipoleMoment(cell=None) probes.append(current_dipole_moment) ########################################################################## # Recording of additional variables ########################################################################## if RANK == 0: network.t = neuron.h.Vector() network.t.record(neuron.h._ref_t) else: network.t = None ########################################################################## # run simulation, gather results across all RANKs ########################################################################## # Assert that connect routines has finished across RANKS before starting
def test_Network_01(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=False, dt=2**-3, tstop=100, delete_sections=False, ) 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=4, name='test', ) networkParameters = dict(dt=2**-3, tstart=0., tstop=100., v_init=-65., celsius=6.3, OUTPUTPATH='tmp_testNetworkPopulation') # set up network = LFPy.Network(**networkParameters) network.create_population(**populationParameters) connectivity = network.get_connectivity_rand(pre='test', post='test', connprob=0.5) # connect network.connect(pre='test', post='test', connectivity=connectivity) # create CurrentDipoleMoment object for probing probes = [LFPy.CurrentDipoleMoment(cell=None)] # run simutation, record using probe, resolve into populations SPIKES, LFP = network.simulate(probes=probes, rec_pop_contributions=True) # current dipole momemnt P = probes[0].data # test output for population in network.populations.values(): for cell in population.cells: self.assertTrue(np.all(cell.somav == network.v_init)) self.assertTrue(np.all(P['test'] == 0.)) self.assertTrue(P.shape[1] == cell.somav.size) network.pc.gid_clear() os.system('rm -r tmp_testNetworkPopulation') for population in network.populations.values(): for cell in population.cells: cell.strip_hoc_objects() neuron.h('forall delete_section()')
def run_cell_simulation(make_ca_spike, dt, cell_name, grid_elec_params, elec_params): T = 100 if cell_name == 'almog': model_folder = join('cell_models', 'almog') neuron.load_mechanisms(model_folder) os.chdir(model_folder) cell_parameters = { 'morphology': join('A140612.hoc'), 'v_init': -62, 'passive': False, 'nsegs_method': None, 'dt': dt, # [ms] Should be a power of 2 'tstart': -200, # [ms] Simulation start time 'tstop': T, # [ms] Simulation end time 'custom_code': [join('cell_model.hoc')] # Loads model specific code } cell = LFPy.Cell(**cell_parameters) os.chdir(join('..', '..')) cell.set_rotation(x=np.pi / 2, y=0.1) elif cell_name == 'hay': model_folder = join('cell_models', 'hay', 'L5bPCmodelsEH') neuron.load_mechanisms(join(model_folder, "mod")) ##define cell parameters used as input to cell-class cellParameters = { 'morphology': join(model_folder, "morphologies", "cell1.asc"), 'templatefile': [ join(model_folder, "models", "L5PCbiophys3.hoc"), join(model_folder, "models", "L5PCtemplate.hoc") ], 'templatename': 'L5PCtemplate', 'templateargs': join(model_folder, "morphologies", "cell1.asc"), 'passive': False, 'nsegs_method': None, 'dt': dt, 'tstart': -200, 'tstop': T, 'v_init': -60, 'celsius': 34, 'pt3d': True, } cell = LFPy.TemplateCell(**cellParameters) cell.set_rotation(x=np.pi / 2, y=0.1) plot_idxs = [cell.somaidx[0], cell.get_closest_idx(z=500)] idx_clr = {idx: ['b', 'orange'][num] for num, idx in enumerate(plot_idxs)} if cell_name == 'hay': weights = [0.07, 0.15] elif cell_name == 'almog': weights = [0.05, 0.15] delay = 30 synapse_s = LFPy.Synapse(cell, idx=cell.get_closest_idx(z=0), syntype='Exp2Syn', weight=weights[0], tau1=0.1, tau2=1.) synapse_s.set_spike_times(np.array([delay])) synapse_a = None if make_ca_spike: synapse_a = LFPy.Synapse(cell, idx=cell.get_closest_idx(z=400), syntype='Exp2Syn', weight=weights[1], tau1=0.1, tau2=10.) synapse_a.set_spike_times(np.array([delay])) cell.simulate(rec_imem=True, rec_vmem=True) print("MAX |I_mem(soma, apic)|: ", np.max(np.abs(cell.imem[plot_idxs]), axis=1)) elec = LFPy.RecExtElectrode(cell, **elec_params) elec_LFP = 1e3 * elec.get_transformation_matrix() @ cell.imem elec_LFP -= elec_LFP[:, 0, None] grid_electrode = LFPy.RecExtElectrode(cell, **grid_elec_params) grid_LFP = 1e3 * grid_electrode.get_transformation_matrix() @ cell.imem grid_LFP -= grid_LFP[:, 0, None] cdm = LFPy.CurrentDipoleMoment(cell) cdm = cdm.get_transformation_matrix() @ cell.imem cdm -= cdm[:, 0, None] cell_data_dict = { "vmem": cell.vmem.copy(), "tvec": cell.tvec.copy(), "elec_LFP": elec_LFP.copy(), "grid_LFP": grid_LFP.copy(), "cdm": cdm.copy(), "cell_x": cell.x.copy(), "cell_z": cell.z.copy(), } synapse_s = None synapse_a = None cell.__del__() return cell_data_dict, idx_clr, plot_idxs
def make_data(morphology, syninds, dip_loc=None, cell_model=None, x_rot=0, y_rot=0, z_rot=0, active=False): sigma = 0.3 #extracellular conductivity k = 1e6 # convert from mV to nV # compute LFP close to neuron # set up electrodes close to neuron X, Z = np.meshgrid(np.linspace(-550, 550, 101), np.linspace(-250, 850, 101)) Y = np.zeros(X.shape) # simulate cell (cell_parameters, synapse_parameters, grid_electrode_parameters) = set_parameters(morphology, X, Y, Z, sigma=sigma, cell_model=cell_model) cell, synapse, grid_electrode_LFP = simulate(cell_parameters, synapse_parameters, grid_electrode_parameters, syninds, x_rot=x_rot, y_rot=y_rot, z_rot=z_rot, active=active) # multicompartment modeling of LFP close to cell cb_LFP_close = grid_electrode_LFP * k # multi-dipole modeling of LFP close to cell multi_dips, multi_dip_locs = cell.get_multi_current_dipole_moments() inf_vol = LFPy.InfiniteVolumeConductor(sigma) gridpoints_close = np.array([X.flatten(), Y.flatten(), Z.flatten()]).T multi_dip_LFP_close = inf_vol.get_multi_dipole_potential( cell, gridpoints_close) * k # single-dipole modeling of LFP close to cell cdm = LFPy.CurrentDipoleMoment(cell) single_dip = cdm.get_transformation_matrix() @ cell.imem syninds = cell.synidx if dip_loc is not None: r_mid = dip_loc else: r_soma_syns = [ cell.get_intersegment_vector(idx0=0, idx1=i) for i in syninds ] r_mid = np.average(r_soma_syns, axis=0) r_mid = r_mid / 2. + cell.somapos db_LFP_close = inf_vol.get_dipole_potential(single_dip, gridpoints_close - r_mid) * k # compute LFP far from neuron # set up electrodes X_f, Z_f = np.meshgrid(np.linspace(-15000, 15001, 101), np.linspace(-15000, 15000, 101)) Y_f = np.zeros(X.shape) grid_electrode_parameters = { 'x': X_f.flatten(), 'y': Y_f.flatten(), 'z': Z_f.flatten() } # simulate cell cell, synapse, grid_electrode_far_LFP = simulate(cell_parameters, synapse_parameters, grid_electrode_parameters, syninds, x_rot=x_rot, y_rot=y_rot, z_rot=z_rot, active=active) # multicompartment modeling of LFP far from cell cb_LFP_far = grid_electrode_far_LFP * k # multi-dipole modeling of LFP far from cell gridpoints_far = np.array([X_f.flatten(), Y_f.flatten(), Z_f.flatten()]).T multi_dip_LFP_far = inf_vol.get_multi_dipole_potential( cell, gridpoints_far) * k # single-dipole modeling of LFP far from cell db_LFP_far = inf_vol.get_dipole_potential(single_dip, gridpoints_far - r_mid) * k cdm = LFPy.CurrentDipoleMoment(cell) single_dip = cdm.get_transformation_matrix() @ cell.imem time_max = np.argmax(np.abs(np.linalg.norm(single_dip, axis=0))) LFP_max = 100. #nV #np.round(np.max(np.abs(grid_electrode_LFP[:, time_max]))) return (cell, cb_LFP_close, cb_LFP_far, multi_dip_LFP_close, multi_dip_LFP_far, db_LFP_close, db_LFP_far, LFP_max, time_max, multi_dips, multi_dip_locs, single_dip, r_mid, X, Z, X_f, Z_f)