def simulate_example(load=True): global SNR_INJECTED_CURRENT global NEURON_MODELS global N_GPE global N_MSN_BURST global N_MSN global GPE_BASE_RATE global FILE_NAME global OUTPUT_PATH global SYNAPSE_MODELS_TESTED global SEL_ONSET #n_exp =200 # number of experiments n_exp = 20 # number of experiments # Path were raw data is saved. For example the spike trains. save_result_at = OUTPUT_PATH + '/' + FILE_NAME + '-simulate_example.pkl' save_header_at = OUTPUT_PATH + '/' + FILE_NAME + '-simulate_example_header' burst_time = 500. sim_time = burst_time + SEL_ONSET + 1000. MODEL_LIST = models() my_nest.ResetKernel() my_nest.MyLoadModels(MODEL_LIST, NEURON_MODELS) my_nest.MyLoadModels(MODEL_LIST, SYNAPSE_MODELS_TESTED) my_nest.MyLoadModels(MODEL_LIST, SYNAPSE_MODELS_BACKGROUND) SNR_list = [] # List with SNR groups for synapse. if not load: MSN_base = MyPoissonInput(n=N_MSN_BASE * n_exp, sd=True) MSN_burst = MyPoissonInput(n=N_MSN_BURST * n_exp, sd=True) GPE = MyPoissonInput(n=N_GPE * n_exp, sd=True) # Set spike times MSN and GPe # Non bursting MSNs for id in MSN_base[:]: seed = numpy.random.random_integers(0, 1000000.0) MSN_base.set_spike_times(id=id, rates=[MSN_BASE_RATE], times=[1], t_stop=sim_time, seed=seed) # Background GPe for id in GPE[:]: seed = numpy.random.random_integers(0, 1000000.0) GPE.set_spike_times(id=id, rates=[GPE_BASE_RATE], times=[1], t_stop=sim_time, seed=seed) # Bursting MSNs for id in MSN_burst[:]: rates = [MSN_BASE_RATE, MSN_BURST_RATE, MSN_BASE_RATE] times = [1, SEL_ONSET, burst_time + SEL_ONSET] t_stop = sim_time seed = numpy.random.random_integers(0, 1000000.0) MSN_burst.set_spike_times(id=id, rates=rates, times=times, t_stop=t_stop, seed=seed) for i_syn in range(len(SYNAPSE_MODELS_TESTED)): params = [] I_e = my_nest.GetDefaults( NEURON_MODELS[0])['I_e'] + SNR_INJECTED_CURRENT for i in range(n_exp): #params.append({'I_e':numpy.random.normal(I_e, # 0.1*I_e)}) params.append({'I_e': I_e}) #{'I_e':SNR_INJECTED_CURRENT} SNR = MyGroup(NEURON_MODELS[0], n=n_exp, sd=True, params=params, mm_dt=.1, record_from=['']) SNR_list.append(SNR) # Connect, experiment specific sources_MSN_SNR_base = numpy.arange(0, n_exp * N_MSN_BASE) sources_MSN_SNR_burst = numpy.arange(0, n_exp * N_MSN_BURST) targets_MSN_SNR_base = numpy.mgrid[0:n_exp, 0:N_MSN_BASE][0].reshape( 1, N_MSN_BASE * n_exp)[0] targets_MSN_SNR_burst = numpy.mgrid[0:n_exp, 0:N_MSN_BURST][0].reshape( 1, N_MSN_BURST * n_exp)[0] sources_GPE_SNR = numpy.arange(0, n_exp * N_GPE) targets_GPE_SNR = numpy.mgrid[0:n_exp, 0:N_GPE][0].reshape(1, N_GPE * n_exp)[0] for i_syn, syn in enumerate(SYNAPSE_MODELS_TESTED): syn = SYNAPSE_MODELS_TESTED[i_syn] SNR = SNR_list[i_syn] my_nest.Connect(MSN_base[sources_MSN_SNR_base], SNR[targets_MSN_SNR_base], model=syn) my_nest.Connect(MSN_burst[sources_MSN_SNR_burst], SNR[targets_MSN_SNR_burst], model=syn) my_nest.Connect(GPE[sources_GPE_SNR], SNR[targets_GPE_SNR], model=SYNAPSE_MODELS_BACKGROUND[0]) my_nest.MySimulate(sim_time) MSN_base.get_signal('s', start=0, stop=sim_time) MSN_burst.get_signal('s', start=0, stop=sim_time) for SNR in SNR_list: SNR.get_signal('s', start=0, stop=sim_time) # Get firing rates of MSNs MSN_firing_rates = [] MSN_all = copy.deepcopy(MSN_base) MSN_all.merge(MSN_burst) time_bin = 20. groups = [MSN_base, MSN_burst, MSN_all] for group in groups: timeAxis, firingRates = group.signals['spikes'].my_firing_rate( bin=time_bin, display=False) MSN_firing_rates.append([timeAxis, firingRates]) # Pick out spikes for burst, base and all to use in scatter plot MSN_spikes_and_ids = [] g1 = MSN_burst.slice(MSN_burst[0:N_MSN_BURST]) g2 = MSN_base.slice(MSN_base[0:N_MSN_BASE]) ids_MSN_burst = range(450, 450 + N_MSN_BURST) ids_MSN_base = [id for id in range(N_MSN) if id not in IDS_MSN_BURST] # Rename ids for plotting purpose g1_dict = dict([[id1, id2] for id1, id2 in zip(g1.ids, ids_MSN_burst)]) g2_dict = dict([[id1, id2] for id1, id2 in zip(g2.ids, ids_MSN_base)]) groups = [g1, g2] dics = [g1_dict, g2_dict] for group, dic in zip(groups, dics): raw_data = group.signals['spikes'].raw_data() for i in range(raw_data.shape[0]): raw_data[i, 1] = dic[raw_data[i, 1]] MSN_spikes_and_ids.append(raw_data) #times, binned_data=MSN_base.signals['spikes'].binned_raw_data(0, sim_time, res=1, clip=0) #filtered_binned_data=misc.time_resolved_rate(binned_data, 100, kernel_type='triangle', res=1) pre_ref_1 = str(SNR_list[0].signals['spikes'].mean_rate( SEL_ONSET - 500, SEL_ONSET)) pre_ref_2 = str(SNR_list[1].signals['spikes'].mean_rate( SEL_ONSET - 500, SEL_ONSET)) pre_dyn = str(SNR_list[2].signals['spikes'].mean_rate( SEL_ONSET - 500, SEL_ONSET)) s = '\n' s = s + 'Simulate example:\n' s = s + '%s %5s %3s \n' % ('N experiments:', str(n_exp), '#') s = s + '%s %5s %3s \n' % ('Bin size MSN hz:', str(time_bin), 'ms') s = s + '%s %5s %3s \n' % ('MSN base rate:', str(MSN_BASE_RATE), 'Hz') s = s + '%s %5s %3s \n' % ('MSN burst rate:', str(MSN_BURST_RATE), 'Hz') s = s + '%s %5s %3s \n' % ('GPe rate:', str(GPE_BASE_RATE), 'Hz') s = s + '%s %5s %3s \n' % ('Burst time:', str(burst_time), 'ms') s = s + '%s %5s %3s \n' % ('Pre sel rate Ref:', pre_ref_1[0:4], 'Hz') s = s + '%s %5s %3s \n' % ('Pre sel rate Ref:', pre_ref_2[0:4], 'Hz') s = s + '%s %5s %3s \n' % ('Pre sel rate Dyn:', pre_dyn[0:4], 'Hz') header = HEADER_SIMULATION_SETUP + s misc.pickle_save([MSN_firing_rates, MSN_spikes_and_ids, SNR_list, s], save_result_at) misc.text_save(header, save_header_at) else: MSN_firing_rates, MSN_spikes_and_ids, SNR_list, s = misc.pickle_load( save_result_at) return MSN_firing_rates, MSN_spikes_and_ids, SNR_list, s
def simulate_example(hz=0, load=True): global SNR_INJECTED_CURRENT global NEURON_MODELS global N_GPE global N_SEL global N_MSN global N_STN global MSN_RATE_BASE global STN_BASE_RATE global SNAME global SPATH global SYNAPSE_MODELS global SEL_ONSET global GPE_BASE_RATE #n_exp = 20 n_exp = 200 RATE_SELE = hz # Selection rate save_at = SPATH + '/' + NEURON_MODELS[0] + '-example.pkl' sim_time = SEL_TIME + SEL_ONSET + 500. SNAME_NB = hz + 1000 experiments = range(n_exp) MODEL_LIST = models() my_nest.ResetKernel() my_nest.MyLoadModels(MODEL_LIST, NEURON_MODELS) my_nest.MyLoadModels(MODEL_LIST, SYNAPSE_MODELS_TESTED) my_nest.MyLoadModels(MODEL_LIST, SYNAPSE_MODELS_BACKGROUND) GPE_list = [] # GPE input for each experiment for i_exp in experiments: GPE = MyPoissonInput(n=N_GPE, sd=True, spath=SPATH, sname_nb=SNAME_NB + i_exp) GPE_list.append(GPE) MSN_list = [] # MSN input for each experiment for i_exp in experiments: MSN = MyPoissonInput(n=N_MSN, sd=False) MSN_list.append(MSN) STN_list = [] # MSN input for each experiment for i_exp in experiments: STN = MyPoissonInput(n=N_STN, sd=False) STN_list.append(STN) SNR_list = [] # SNR groups for each synapse I_e = my_nest.GetDefaults(NEURON_MODELS[0])['I_e'] + SNR_INJECTED_CURRENT for i_syn in range(len(SYNAPSE_MODELS_TESTED)): SNR = MyGroup(NEURON_MODELS[0], n=n_exp, params={'I_e': I_e}, sd=True) SNR_list.append(SNR) if not load: for i_exp in experiments: GPE = GPE_list[i_exp] MSN = MSN_list[i_exp] STN = STN_list[i_exp] # Set spike times # Base rate MSN for id in MSN[:]: MSN.set_spike_times(id=id, rates=[MSN_RATE_BASE], times=[1], t_stop=sim_time, seed=int(numpy.random.random() * 10000.0)) # Base rate STN for id in STN[:]: STN.set_spike_times(id=id, rates=[STN_BASE_RATE], times=[1], t_stop=sim_time, seed=int(numpy.random.random() * 10000.0)) # Set spike times # Base rate for id in GPE[0:N_GPE - N_SEL]: GPE.set_spike_times(id=id, rates=[GPE_BASE_RATE], times=[1], t_stop=sim_time, seed=int(numpy.random.random() * 10000.0)) # Selection for id in GPE[N_GPE - N_SEL:N_GPE]: rates = [GPE_BASE_RATE, RATE_SELE, GPE_BASE_RATE] times = [1, SEL_ONSET, SEL_TIME + SEL_ONSET] t_stop = sim_time GPE.set_spike_times(id=id, rates=rates, times=times, t_stop=t_stop, seed=int(numpy.random.random() * 10000.0)) # Connect for i_syn, syn in enumerate(SYNAPSE_MODELS_TESTED): target = SNR_list[i_syn][i_exp] my_nest.ConvergentConnect(GPE[:], [target], model=syn) my_nest.ConvergentConnect(MSN[:], [target], model=SYNAPSE_MODELS_BACKGROUND[0]) my_nest.ConvergentConnect(STN[:], [target], model=SYNAPSE_MODELS_BACKGROUND[1]) my_nest.MySimulate(sim_time) for GPE in GPE_list: GPE.get_signal('s') for SNR in SNR_list: SNR.get_signal('s') misc.pickle_save([GPE_list, SNR_list], save_at) elif load: GPE_list, SNR_list = misc.pickle_load(save_at) pre_ref = str(SNR_list[0].signals['spikes'].mean_rate( SEL_ONSET - 5000, SEL_ONSET)) pre_dyn = str(SNR_list[1].signals['spikes'].mean_rate( SEL_ONSET - 500, SEL_ONSET)) statusSynapes = [] for syn in SYNAPSE_MODELS_TESTED: statusSynapes.append(my_nest.GetDefaults(syn)) s = '\n' s = s + 'Example:\n' s = s + ' %s %5s %3s \n' % ('N experiments:', str(len(experiments)), '#') s = s + ' %s %5s %3s \n' % ('N GPEs:', str(N_GPE), '#') s = s + ' %s %5s %3s \n' % ('Base rate:', str(GPE_BASE_RATE), 'spikes/s') s = s + ' %s %5s %3s \n' % ('Selection rate:', str(RATE_SELE), 'spikes/s') s = s + ' %s %5s %3s \n' % ('Selection time:', str(SEL_TIME), 'ms') s = s + ' %s %5s %3s \n' % ('Pre sel rate Ref:', pre_ref[0:4], 'spikes/s') s = s + ' %s %5s %3s \n' % ('Pre sel rate Dyn:', pre_dyn[0:4], 'spikes/s') for ss in statusSynapes: s = s + '\n' s = s + ' %s %10s\n' % ('Synapse', ss['synapsemodel']) s = s + ' %s %5s %3s\n' % ('Weight', str(round(ss['weight'], 1)), 'nS') return GPE_list, SNR_list, s
def simulate_example(MSN_hz=20, GPE_hz=0, load=True, n_gpe_sel=3, sel_time_GPE=500): global GPE_BASE_RATE global STN_BASE_RATE global MSN_BASE_RATE global MSN_BURST_TIME global NEURON_MODELS global N_GPE global N_STN global N_MSN global N_MSN_BURST global SNAME global SPATH global SYNAPSE_MODELS global SEL_ONSET global SNR_INJECTED_CURRENT n_exp = 200 msn_rate_sel = MSN_hz # Selection rate gpe_sel_rate = GPE_hz # Selection rate sel_time_MSN = MSN_BURST_TIME sim_time = sel_time_MSN+SEL_ONSET+500. EXPERIMENTS=range(n_exp) MODEL_LIST=models() my_nest.ResetKernel() my_nest.MyLoadModels( MODEL_LIST, NEURON_MODELS ) my_nest.MyLoadModels( MODEL_LIST, SYNAPSE_MODELS) my_nest.MyLoadModels( MODEL_LIST, SYNAPSE_MODELS_BACKGROUND) MSN_list=[] # MSN input for each experiment for i_exp in EXPERIMENTS: MSN = MyPoissonInput( n=N_MSN+N_MSN_BURST, sd=True) MSN_list.append(MSN) GPE_list=[] # GPE input for each experiment for i_exp in EXPERIMENTS: GPE = MyPoissonInput( n=N_GPE+n_gpe_sel, sd=True) GPE_list.append(GPE) STN_list=[] # GPE input for each experiment for i_exp in EXPERIMENTS: STN = MyPoissonInput( n=N_STN, sd=True) STN_list.append(GPE) SNR_list=[] # SNR groups for each synapse for i, SNR_i_c in enumerate(SNR_INJECTED_CURRENT): I_e=my_nest.GetDefaults(NEURON_MODELS[0])['I_e']+SNR_i_c SNR = MyGroup( NEURON_MODELS[0], n=n_exp, params={'I_e':I_e}, sd=True, mm=False, mm_dt=.1, record_from=['']) SNR_list.append(SNR) if not load: for i_exp in EXPERIMENTS: # MSN MSN = MSN_list[i_exp] # Set spike times # Base rate for id in MSN[0:N_MSN]: MSN.set_spike_times(id=id, rates=[MSN_BASE_RATE], times=[1], t_stop=sim_time, seed=int(numpy.random.random()*10000.0)) # Selection MSN for id in MSN[N_MSN:N_MSN+N_MSN_BURST]: rates = [MSN_BASE_RATE, msn_rate_sel, MSN_BASE_RATE] times = [1, SEL_ONSET, sel_time_MSN + SEL_ONSET] t_stop = sim_time MSN.set_spike_times(id=id, rates=rates, times=times, t_stop=t_stop, seed=int(numpy.random.random()*10000.0)) # GPE GPE = GPE_list[i_exp] # Set spike times # Base rate for id in GPE[:]: GPE.set_spike_times(id=id, rates=[GPE_BASE_RATE], times=[1], t_stop=sim_time, seed=int(numpy.random.random()*10000.0)) # Selection GPE for id in GPE[N_GPE:N_GPE+n_gpe_sel]: rates = [GPE_BASE_RATE, gpe_sel_rate, GPE_BASE_RATE] # If GPe excited smaller selection time times = [1, SEL_ONSET, sel_time_GPE + SEL_ONSET] t_stop = sim_time GPE.set_spike_times(id=id, rates=rates, times=times, t_stop=t_stop, seed=int(numpy.random.random()*100000.0)) # Base rate STN for id in STN[:]: STN.set_spike_times(id=id, rates=[STN_BASE_RATE], times=[1], t_stop=sim_time, seed=int(numpy.random.random()*10000.0)) idx_MSN_s=range(0,N_MSN-N_MSN_BURST) idx_MSN_s.extend(range(N_MSN,N_MSN+N_MSN_BURST)) idx_GPE_s=range(0,N_GPE-n_gpe_sel) idx_GPE_s.extend(range(N_GPE,N_GPE+n_gpe_sel)) # Connect with MSN burst target=SNR_list[0][i_exp] my_nest.ConvergentConnect(MSN[idx_MSN_s], [target], model=SYNAPSE_MODELS[0]) my_nest.ConvergentConnect(GPE[0:N_GPE], [target], model=SYNAPSE_MODELS[1]) my_nest.ConvergentConnect(STN[:], [target], model=SYNAPSE_MODELS_BACKGROUND[0]) # With GPe pause target=SNR_list[1][i_exp] my_nest.ConvergentConnect(MSN[0:N_MSN], [target], model=SYNAPSE_MODELS[0]) my_nest.ConvergentConnect(GPE[idx_GPE_s], [target], model=SYNAPSE_MODELS[1]) my_nest.ConvergentConnect(STN[:], [target], model=SYNAPSE_MODELS_BACKGROUND[0]) # With MSN burst and GPe pause target=SNR_list[2][i_exp] my_nest.ConvergentConnect(MSN[idx_MSN_s], [target], model=SYNAPSE_MODELS[0]) my_nest.ConvergentConnect(GPE[idx_GPE_s], [target], model=SYNAPSE_MODELS[1]) my_nest.ConvergentConnect(STN[:], [target], model=SYNAPSE_MODELS_BACKGROUND[0]) my_nest.MySimulate( sim_time ) for MSN in MSN_list: MSN.get_signal( 's' ) for GPE in GPE_list: GPE.get_signal( 's' ) for SNR in SNR_list: SNR.get_signal( 's' ) misc.pickle_save([MSN_list, GPE_list,SNR_list] , save_at) if load: MSN_list, GPE_list, SNR_list=misc.pickle_load(save_at) pre_dyn_MSN=str(SNR_list[0].signals['spikes'].mean_rate(SEL_ONSET-500, SEL_ONSET)) pre_dyn_GPE=str(SNR_list[1].signals['spikes'].mean_rate(SEL_ONSET-500, SEL_ONSET)) s='\n' s=s+'Example:\n' s = s + ' %s %5s %3s \n' % ( 'N experiments:', str ( len(EXPERIMENTS) ), '#' ) s = s + ' %s %5s %3s \n' % ( 'N MSN:', str ( N_MSN ), '#' ) s = s + ' %s %5s %3s \n' % ( 'N GPE:', str ( N_GPE ), '#' ) s='\n' s = s + ' %s %5s %3s \n' % ( 'Base rate MSN:', str ( MSN_BASE_RATE),'spikes/s' ) s = s + ' %s %5s %3s \n' % ( 'Sel rate MSN:', str ( msn_rate_sel ), 'spikes/s' ) s = s + ' %s %5s %3s \n' % ( 'Sel time MSN:', str ( sel_time_MSN ), 'ms' ) s='\n' s = s + ' %s %5s %3s \n' % ( 'Base rate GPe:', str ( GPE_BASE_RATE),'spikes/s' ) s = s + ' %s %5s %3s \n' % ( 'Sel rate GPe:', str ( gpe_sel_rate ), 'spikes/s' ) s = s + ' %s %5s %3s \n' % ( 'Sel time GPe:', str ( sel_time_GPE ), 'ms' ) s = s + ' %s %5s %3s \n' % ( 'Pre sel rate Dyn MSN:', pre_dyn_MSN[0:4], 'spikes/s' ) s = s + ' %s %5s %3s \n' % ( 'Pre sel rate Dyn GPe:', pre_dyn_GPE[0:4], 'spikes/s' ) return MSN_list, GPE_list, SNR_list, s info_string=s return MSN_hzs, GPE_hzs, data, info_string
def simulate_example(hz_1=0., hz_2=100., load=True): global I_E global NEURON_MODELS global N_GPE global N_SEL global N_MSN global N_STN global MSN_RATE_BASE global STN_RATE_BASE global SNAME global SPATH global SYNAPSE_MODELS global SEL_ONSET N_EXP = 200 RATE_BASE = 25 # Base rate RATE_SELE_1 = hz_1 RATE_SELE_2 = hz_2 # Selection rate SAVE_AT = SPATH + '/' + NEURON_MODELS[0] + '-example.pkl' SEL_TIME_1 = 500. SEL_TIME_2 = 200. sim_time = SEL_TIME_1 + SEL_TIME_2 + SEL_ONSET + 500. SNAME_NB = hz_1 + hz_2 + 1000 EXPERIMENTS = range(N_EXP) MODEL_LIST = models() my_nest.ResetKernel() my_nest.MyLoadModels(MODEL_LIST, NEURON_MODELS) my_nest.MyLoadModels(MODEL_LIST, SYNAPSE_MODELS_TESTED) my_nest.MyLoadModels(MODEL_LIST, SYNAPSE_MODELS_BACKGROUND) GPE_list = [] # GPE input for each experiment for i_exp in EXPERIMENTS: GPE = MyPoissonInput(n=N_GPE, sd=True) GPE_list.append(GPE) MSN_list = [] # MSN input for each experiment for i_exp in EXPERIMENTS: MSN = MyPoissonInput(n=N_MSN, sd=True) MSN_list.append(MSN) STN_list = [] # MSN input for each experiment for i_exp in EXPERIMENTS: STN = MyPoissonInput(n=N_STN, sd=True) STN_list.append(STN) SNR_list = [] # SNR groups for each synapse for i_syn in SYNAPSE_MODELS_TESTED: I_e = my_nest.GetDefaults(NEURON_MODELS[0])['I_e'] + I_E SNR = MyGroup(NEURON_MODELS[0], n=N_EXP, params={'I_e': I_e}, sd=True, mm=False, mm_dt=.1, record_from=['']) SNR_list.append(SNR) if not load: for i_exp in EXPERIMENTS: GPE = GPE_list[i_exp] MSN = MSN_list[i_exp] STN = STN_list[i_exp] # Set spike times # Base rate MSN for id in MSN[:]: MSN.set_spike_times(id=id, rates=[MSN_RATE_BASE], times=[1], t_stop=sim_time, seed=int(numpy.random.random() * 10000.0)) # Base rate for id in GPE[0:N_GPE - N_SEL]: GPE.set_spike_times(id=id, rates=[RATE_BASE], times=[1], t_stop=sim_time, seed=int(numpy.random.random() * 10000.0)) # Base rate STN for id in STN[:]: STN.set_spike_times(id=id, rates=[STN_RATE_BASE], times=[1], t_stop=sim_time, seed=int(numpy.random.random() * 10000.0)) # Selection for id in GPE[N_GPE - N_SEL:N_GPE]: rates = [RATE_BASE, RATE_SELE_1, RATE_SELE_2, RATE_BASE] times = [ 1, SEL_ONSET, SEL_ONSET + SEL_TIME_1, SEL_ONSET + SEL_TIME_1 + SEL_TIME_2 ] t_stop = sim_time GPE.set_spike_times(id=id, rates=rates, times=times, t_stop=t_stop, seed=int(numpy.random.random() * 10000.0)) # Connect for i, syn in enumerate(SYNAPSE_MODELS_TESTED): target = SNR_list[i][i_exp] my_nest.ConvergentConnect(GPE[:], [target], model=syn) my_nest.ConvergentConnect(MSN[:], [target], model=SYNAPSE_MODELS_BACKGROUND[0]) my_nest.ConvergentConnect(STN[:], [target], model=SYNAPSE_MODELS_BACKGROUND[1]) my_nest.MySimulate(sim_time) for GPE in GPE_list: GPE.get_signal('s') for SNR in SNR_list: SNR.get_signal('s') misc.pickle_save([GPE_list, SNR_list], SAVE_AT) elif load: GPE_list, SNR_list = misc.pickle_load(SAVE_AT) pre_ref = str(SNR_list[0].signals['spikes'].mean_rate( SEL_ONSET - 500, SEL_ONSET)) pre_dyn = str(SNR_list[1].signals['spikes'].mean_rate( SEL_ONSET - 500, SEL_ONSET)) statusSynapes = [] for syn in SYNAPSE_MODELS_TESTED: statusSynapes.append(my_nest.GetDefaults(syn)) s = '\n' s = s + 'Example:\n' s = s + ' %s %5s %3s \n' % ('N experiments:', str(len(EXPERIMENTS)), '#') s = s + ' %s %5s %3s \n' % ('N GPEs:', str(N_GPE), '#') s = s + ' %s %5s %3s \n' % ('Base rate:', str(RATE_BASE), 'spikes/s') s = s + ' %s %5s %3s \n' % ('Selection rate:', str(RATE_SELE_1), 'spikes/s') s = s + ' %s %5s %3s \n' % ('Selection time:', str(SEL_TIME_1), 'ms') s = s + ' %s %5s %3s \n' % ('Selection rate:', str(RATE_SELE_2), 'spikes/s') s = s + ' %s %5s %3s \n' % ('Selection time:', str(SEL_TIME_2), 'ms') s = s + ' %s %5s %3s \n' % ('Pre sel rate Ref:', pre_ref[0:4], 'spikes/s') s = s + ' %s %5s %3s \n' % ('Pre sel rate Dyn:', pre_dyn[0:4], 'spikes/s') for ss in statusSynapes: s = s + '\n' s = s + ' %s %10s\n' % ('Synapse', ss['synapsemodel']) s = s + ' %s %5s %3s\n' % ('Weight', str(round(ss['weight'], 1)), 'nS') return GPE_list, SNR_list, s
def simulate_example(hz=0, load=True): global NEURON_MODELS global SNAME global SPATH global SYNAPSE_MODELS global SEL_ONSET global I_E N_EXP = 200 N_GPE = 50 N_SEL = 30 # Number of selected GPE N_INH = 0 # Number of inhibited GPE RATE_BASE = 15 # Base rate RATE_SELE = hz # Selection rate RATE_INHI = 0 SAVE_AT = SPATH + '/' + NEURON_MODELS[0] + '-example.pkl' SEL_TIME = 20. sim_time = SEL_TIME + SEL_ONSET + 800. SNAME_NB = hz + 1000 EXPERIMENTS = range(N_EXP) MODEL_LIST = models() my_nest.ResetKernel() my_nest.MyLoadModels(MODEL_LIST, NEURON_MODELS) my_nest.MyLoadModels(MODEL_LIST, SYNAPSE_MODELS) GPE_list = [] # GPE input for each experiment for i_exp in EXPERIMENTS: GPE = MyPoissonInput(n=N_GPE, sd=True, spath=SPATH, sname_nb=SNAME_NB + i_exp) GPE_list.append(GPE) SNR_list = [] # SNR groups for each synapse for i_syn, syn in enumerate(SYNAPSE_MODELS): SNR = MyGroup(NEURON_MODELS[0], n=N_EXP, params={'I_e': I_E}, sd=True, mm=False, mm_dt=.1, record_from=[''], spath=SPATH, sname_nb=SNAME_NB + i_syn) SNR_list.append(SNR) if not load: for i_exp in EXPERIMENTS: GPE = GPE_list[i_exp] # Set spike times # Base rate for id in GPE[:]: GPE.set_spike_times(id=id, rates=[RATE_BASE], times=[1], t_stop=sim_time) # Selection for id in GPE[N_GPE - N_SEL:N_GPE + 1]: rates = [RATE_BASE, RATE_SELE, RATE_BASE] times = [1, SEL_ONSET, SEL_TIME + SEL_ONSET] t_stop = sim_time GPE.set_spike_times(id=id, rates=rates, times=times, t_stop=t_stop) # Inhibition for id in GPE[N_GPE - N_SEL - N_INH:N_GPE + 1 - N_SEL]: rates = [RATE_BASE, RATE_INHI, RATE_BASE] times = [1, SEL_ONSET, SEL_TIME + SEL_ONSET] t_stop = sim_time GPE.set_spike_times(id=id, rates=rates, times=times, t_stop=t_stop) # Connect for i_syn, syn in enumerate(SYNAPSE_MODELS): target = SNR_list[i_syn][i_exp] my_nest.ConvergentConnect(GPE[:], [target], model=syn) my_nest.MySimulate(sim_time) for GPE in GPE_list: GPE.get_signal('s') for SNR in SNR_list: SNR.get_signal('s') misc.pickle_save([GPE_list, SNR_list], SAVE_AT) if load: GPE_list, SNR_list = misc.pickle_load(SAVE_AT) pre_ref = str(SNR_list[0].signals['spikes'].mean_rate( SEL_ONSET - 500, SEL_ONSET)) pre_dyn = str(SNR_list[2].signals['spikes'].mean_rate( SEL_ONSET - 500, SEL_ONSET)) s = '\n' s = s + 'Example:\n' s = s + ' %s %5s %3s \n' % ('N experiments:', str(len(EXPERIMENTS)), '#') s = s + ' %s %5s %3s \n' % ('Base rate:', str(RATE_BASE), 'Hz') s = s + ' %s %5s %3s \n' % ('Selection rate:', str(RATE_SELE), 'Hz') s = s + ' %s %5s %3s \n' % ('Selection time:', str(SEL_TIME), 'ms') s = s + ' %s %5s %3s \n' % ('Pre sel rate Ref:', pre_ref[0:4], 'Hz') s = s + ' %s %5s %3s \n' % ('Pre sel rate Dyn:', pre_dyn[0:4], 'Hz') return GPE_list, SNR_list, s