def plot_steady_state_freq(ax, freq_, relative_fac): colors = ['b', 'g', 'm'] linestyles = ['--', '--', '-'] labels = [ r'$ref_{init}^{MSN_{D1}}$', r'$ref_{max}^{MSN_{D1}}$', r'$fac^{MSN_{D1}}$' ] coords = [[0.1, 0.22], [0.2, 0.74], [0.65, 0.45]] syn_static = ['MSN_SNR_gaba_s_min', 'MSN_SNR_gaba_s_max'] ax.plot(freq_, relative_fac[0, :], **{'color': colors[2]}) ytext = ax.set_ylabel(r'$p_{ss}$/$p_1$') #pylab.setp(ytext, fontsize=14.) ax.set_xlabel('Firing rate (spikes/s)') ax.my_set_no_ticks(yticks=5, xticks=5) my_nest.ResetKernel() model_list, model_dict = models() syns = [SYNAPSE_MODELS[0]] syns.extend(syn_static) my_nest.MyLoadModels(model_list, syns) xdata = ax.lines[0].get_xdata() ss = my_nest.GetDefaults(SYNAPSE_MODELS[0]) synapticEficacy = ss['weight'] * ss['U'] for syn, color, ls in zip(syn_static, colors[0:2], linestyles[0:2]): sw = my_nest.GetDefaults(syn) ax.plot( [min(xdata), 48], [sw['weight'] / synapticEficacy, sw['weight'] / synapticEficacy], **{ 'color': color, 'linestyle': ls }) for coord, label, color in zip(coords, labels, colors): ax.text(coord[0], coord[1], label, transform=ax.transAxes, fontsize=pylab.rcParams['font.size'] + 2, **{'color': color}) lines = ax.lines for line in lines: misc.slice_line(line, xlim=[0, 48]) ax.set_xlim(misc.adjust_limit([0, 50])) ax.set_ylim(misc.adjust_limit([0, 5])) ax.my_set_no_ticks(yticks=6, xticks=6) pylab.setp(ax.lines, linewidth=2.0) # Need to pu ti before generating legend
def plot_text(ax, infoString=''): my_nest.ResetKernel() model_list, model_dict = models() my_nest.MyLoadModels(model_list, NEURON_MODELS) my_nest.MyLoadModels(model_list, SYNAPSE_MODELS) my_nest.MyLoadModels(model_list, ['GPE_SNR_gaba_s_ref', 'GPE_SNR_gaba_s_max']) SNR = MyGroup(NEURON_MODELS[0], 2, mm_dt=0.1) statusSNR = my_nest.GetStatus(SNR[:])[0] statusSynapes = [] for s in SYNAPSE_MODELS: statusSynapes.append(my_nest.GetDefaults(s)) tb = '' tb = tb + infoString for ss in statusSynapes: tb = tb + '\n' tb = tb + ' %s %10s\n' % ('Synapse', ss['synapsemodel']) tb = tb + ' %s %5s %3s\n' % ('Weight', str(round(ss['weight'], 1)), 'nS') tb = tb + ' %s %5s %3s \n' % ('U:', str(ss['U']), '--') tb = tb + ' %s %5s %3s \n' % ('tau_fac:', str(ss['tau_fac']), 'ms') tb = tb + ' %s %5s %3s \n' % ('tau_rec:', str(ss['tau_rec']), 'ms') tb = tb + ' %s %5s %3s \n' % ('tau_psc:', str(ss['tau_psc']), 'ms') synapticEficacy = ss['weight'] * ss['U'] tb = tb + ' %s %5s %3s \n' % ('P1:', synapticEficacy, 'nS') sw = my_nest.GetDefaults('GPE_SNR_gaba_s_ref') tb = tb + ' %s %5s %3s \n' % (r'$ref_{32 Hz}^{GPe}$ fraction', str(sw['weight'] / synapticEficacy), '--') sw = my_nest.GetDefaults('GPE_SNR_gaba_s_max') tb = tb + ' %s %5s %3s \n' % (r'$dep^{GPe}$ max', str(sw['weight']), '--') ax.text( 0.85, 0.5, tb, fontsize=font_size_text, horizontalalignment='right', verticalalignment='center', transform=ax.transAxes, # to define coordinates in right scale **{'fontname': 'monospace'}) ax.my_remove_axis(xaxis=True, yaxis=True) ax.my_remove_spine(left=True, bottom=True, right=True, top=True)
def simulate_example(I_e): simTime = 1000. # ms my_nest.ResetKernel() model_list, model_dict = models() my_nest.MyLoadModels(model_list, NEURON_MODELS) I_e0 = my_nest.GetDefaults(NEURON_MODELS[0])['I_e'] SNR = MyGroup(NEURON_MODELS[0], 1, sd=True, mm=True, mm_dt=1., params={'I_e': I_e + I_e0}) my_nest.MySimulate(simTime) SNR.get_signal('v', 'V_m', stop=simTime) # retrieve signal SNR.get_signal('s') # retrieve signal meanRate = round(SNR.signals['spikes'].mean_rate(0, 1000), 1) print SNR.signals['spikes'].isi() SNR.signals['V_m'].my_set_spike_peak(21, spkSignal=SNR.signals['spikes']) s = '\n' s = s + 'Example:\n' s = s + ' %s %5s %3s %s %5s %3s \n' % ('Mean rate:', meanRate, 'Hz', 'I_e', I_e, 'pA') infoString = s return SNR, infoString
def simulate_steady_state_freq(frequencies, flag='ss'): global sname_nb relativeFacilitation=[] model_list=models() data={} n=len(frequencies) for syn in synapseModels: my_nest.ResetKernel() my_nest.MyLoadModels( model_list, neuronModels ) my_nest.MyLoadModels( model_list, [syn]) ss=my_nest.GetDefaults(syn) synapticEficacy = ss['weight']*ss['U'] SNR = MyGroup( neuronModels[0], n, mm_dt = .1, params={'I_e':-150.}, record_from=['g_GABAA_2'], spath=spath, sname_nb=sname_nb ) sname_nb+=1 tSim=3*1000/frequencies[0] spikeTimes=[] for f in frequencies : isi = 1000./f spikeTimes.append(numpy.arange(1,tSim,isi)) if not LOAD: for target, st in zip(SNR, spikeTimes ) : source = my_nest.Create('spike_generator', params={'spike_times':st} ) my_nest.SetDefaults(syn, params={'delay':1.}) my_nest.Connect(source, [target], model=syn) my_nest.MySimulate(tSim) SNR.get_signal( 'g','g_GABAA_2', stop=tSim ) # retrieve signal SNR.save_signal( 'g','g_GABAA_2', stop=tSim ) elif LOAD: SNR.load_signal( 'g','g_GABAA_2') signal=SNR.signals['g_GABAA_2'] tmpSteadyState=[] for i, st in enumerate(spikeTimes, start=1): if SNR.mm_dt==0.1: indecies=numpy.int64(numpy.ceil(st*10))+9 elif SNR.mm_dt==1.: indecies=numpy.int64(numpy.ceil(st)) values=signal[i].signal[indecies]-signal[i].signal[indecies-1] if flag=='ss': tmpSteadyState.append(values[-1]/synapticEficacy) if flag=='max': tmpSteadyState.append(max(values)/synapticEficacy) relativeFacilitation.append(tmpSteadyState) relativeFacilitation=numpy.array(relativeFacilitation) return frequencies, relativeFacilitation
def simulate_recovery(revoceryTimes): global sname_nb relativeRecovery=[] model_list=models() data={} n=len(revoceryTimes) for syn in synapseModels: my_nest.ResetKernel() my_nest.MyLoadModels( model_list, neuronModels ) my_nest.MyLoadModels( model_list, [syn]) ss=my_nest.GetDefaults(syn) synapticEficacy = ss['weight']*ss['U'] SNR = MyGroup( neuronModels[0], n, mm_dt = .1, params={'I_e':-150.}, record_from=['g_GABAA_2'], spath=spath, sname_nb=sname_nb) sname_nb+=1 tSim=5000 spikeTimes=[] for rt in revoceryTimes: spikeTimes.append(numpy.array([1.,11.,21.,31.,41.,41+rt])) if not LOAD: for target, st in zip(SNR, spikeTimes ) : source = my_nest.Create('spike_generator', params={'spike_times':st} ) my_nest.SetDefaults(syn, params={'delay':1.}) my_nest.Connect(source, [target], model=syn) my_nest.MySimulate(tSim) SNR.get_signal( 'g','g_GABAA_2', stop=tSim ) # retrieve signal SNR.save_signal( 'g','g_GABAA_2', stop=tSim ) elif LOAD: SNR.load_signal( 'g','g_GABAA_2') signal=SNR.signals['g_GABAA_2'] tmpSteadyState=[] for i, st in enumerate(spikeTimes, start=1): if SNR.mm_dt==0.1: indecies=numpy.int64(numpy.ceil(st*10))+9 elif SNR.mm_dt==1.: indecies=numpy.int64(numpy.ceil(st)) values=signal[i].signal[indecies]-signal[i].signal[indecies-1] tmpSteadyState.append(values[-1]/synapticEficacy) #tmpSteadyState.append(max(values)/synapticEficacy) relativeRecovery.append(tmpSteadyState) relativeRecovery=numpy.array(relativeRecovery) return revoceryTimes, relativeRecovery
def plot_steady_state_freq(ax, frequencies, relativeFacilitation): colors = ['r', 'c'] linestyles = ['--', '-'] labels = [r'$ref_{30 Hz}^{GPe}$', r'$dep^{GPe}$'] coords = [[0.35, 0.2], [0.1, 0.7]] syn_static = ['GPE_SNR_gaba_s_ref'] #print relativeFacilitation[0, 23:26] #print frequencies[23:26] ax.plot(frequencies, relativeFacilitation[0, :], **{'color': colors[1]}) my_nest.ResetKernel() model_list, model_dict = models() syns = [SYNAPSE_MODELS[0]] syns.extend(syn_static) my_nest.MyLoadModels(model_list, syns) xdata = ax.lines[0].get_xdata() ss = my_nest.GetDefaults(SYNAPSE_MODELS[0]) synapticEficacy = ss['weight'] * ss['U'] sw = my_nest.GetDefaults('GPE_SNR_gaba_s_ref') ax.plot([min(xdata), max(xdata)], [sw['weight'] / synapticEficacy, sw['weight'] / synapticEficacy], **{ 'color': colors[0], 'linestyle': linestyles[0] }) t_a = ax.transAxes for coord, label, color in zip(coords, labels, colors): ax.text(coord[0], coord[1], label, transform=ax.transAxes, fontsize=pylab.rcParams['font.size'] + 2, **{'color': color}) ytext = ax.set_ylabel(r'$p_{ss}$/$p_1$') pylab.setp(ytext, fontsize=16.) ax.set_xlabel('Firing rate (spikes/s)') ax.my_set_no_ticks(yticks=6, xticks=6) ax.set_xlim(misc.adjust_limit([0, 100])) ax.set_ylim(misc.adjust_limit([0, 1])) pylab.setp(ax.lines, linewidth=2.0) # Need to pu ti before generating legend
def multiply_weight_factor(synapses, weightFactor): for i in range(len(synapses)): # Multiply with weight factor defaults = my_nest.GetDefaults(synapses[i]) my_nest.SetDefaults(synapses[i], {'weight': defaults['weight'] * weightFactor})
def simulate_basa_line_STN(ctx_rate, gpe_rate, n_ctx, n_gpe, neuron_model, syn_models, stn_current, sim_time=1000, threads=8, w_GPE_STN=0): Params_in = {} if w_GPE_STN: Params_in['GPE_STN_gaba_s'] = w_GPE_STN model_list, model_dict = models(Params_in) my_nest.ResetKernel(threads=threads) my_nest.MyLoadModels(model_dict, neuron_model) my_nest.MyLoadModels(model_dict, syn_models) SNR_list = [] # List with SNR groups for synapse. if n_ctx > 0: CTX = MyPoissonInput(n=n_ctx, sd=True) if n_gpe > 0: GPE = MyPoissonInput(n=n_gpe, sd=False) if n_ctx > 0: CTX.set_spike_times(rates=[ctx_rate], times=[1], t_stop=sim_time, seed=0) if n_gpe > 0: GPE.set_spike_times(rates=[gpe_rate], times=[1], t_stop=sim_time, seed=0) I_e = my_nest.GetDefaults(neuron_model[0])['I_e'] + stn_current STN = MyGroup(neuron_model[0], n=1, sd=True, params={'I_e': I_e}, mm_dt=.1, mm=True) if n_ctx > 0: my_nest.Connect(CTX[:], STN[:] * len(CTX[:]), model=syn_models[0]) if n_gpe > 0: my_nest.Connect(GPE[:], STN[:] * len(GPE[:]), model=syn_models[1]) my_nest.MySimulate(sim_time) STN.get_signal('s', start=0, stop=sim_time) STN.get_signal('v', recordable='V_m', start=0, stop=sim_time) return STN
def plot_steady_state_freq(ax, frequencies, relativeFacilitation ): colors = ['r','c'] labels=[r'$\delta_{ref}^{STN}$', r'$\delta_{dep}^{STN}$'] coords=[[0.35, 0.2], [0.1, 0.7]] syn_static=['STN_SNR_ampa_s'] #print relativeFacilitation[0, 23:26] #print frequencies[23:26] ax.plot(frequencies,relativeFacilitation[0,:],**{'label':'Data 1+2', 'color':colors[1]}) my_nest.ResetKernel() model_list, model_dict=models() syns=[SYNAPSE_MODELS[0]] syns.extend(syn_static) my_nest.MyLoadModels( model_list, syns ) xdata=ax.lines[0].get_xdata() ss=my_nest.GetDefaults(SYNAPSE_MODELS[0]) synapticEficacy = ss['weight']*ss['U'] sw=my_nest.GetDefaults('STN_SNR_ampa_s') ax.plot([min(xdata), max(xdata)],[sw['weight']/synapticEficacy, sw['weight']/synapticEficacy], **{'color':colors[0]}) t_a = ax.transAxes for coord, label, color in zip(coords, labels, colors): ax.text( coord[0], coord[1], label , transform=ax.transAxes, fontsize=pylab.rcParams['text.fontsize']+2, **{ 'color' : color}) ytext=ax.set_ylabel(r'$p_{ss}$/$p_1$') pylab.setp(ytext, fontsize=14.) ax.set_xlabel('Firing rate (spikes/s)') ax.my_set_no_ticks( yticks=6, xticks = 6 ) ax.set_xlim(misc.adjust_limit([0,20])) ax.set_ylim(misc.adjust_limit([0,1]))
def simulate_example_inh_current(I_vec): simTime = 1000. # ms my_nest.ResetKernel() model_list, model_dict = models() my_nest.MyLoadModels(model_list, NEURON_MODELS) df = my_nest.GetDefaults(NEURON_MODELS[0]) n = len(I_vec) STN = MyGroup(NEURON_MODELS[0], n, sd=True, mm=True, mm_dt=1.0, record_from=['V_m', 'u']) I_e0 = my_nest.GetStatus(STN[:])[0]['I_e'] my_nest.SetStatus(STN[:], params={'I_e': I_e0 + I_E + 50}) # Set I_e I_e = my_nest.GetStatus(STN.ids, 'I_e')[0] scg = my_nest.Create('step_current_generator', n=n) rec = my_nest.GetStatus(STN[:])[0]['receptor_types'] for source, target, I in zip(scg, STN[:], I_vec): my_nest.SetStatus([source], { 'amplitude_times': [280., 700.], 'amplitude_values': [float(I), 0.] }) my_nest.Connect([source], [target], params={'receptor_type': rec['CURR']}) my_nest.MySimulate(simTime) STN.get_signal('v', 'V_m', stop=simTime) # retrieve signal STN.get_signal('s') # retrieve signal STN.signals['V_m'].my_set_spike_peak(21, spkSignal=STN.signals['spikes']) e = my_nest.GetStatus(STN.mm)[0]['events'] # get events #pylab.plot(e['u']) #pylab.show() meanRate = round(STN.signals['spikes'].mean_rate(0, 500), 1) s = '\n' s = s + 'Example inhibitory current:\n' s = s + ' %s %5s %3s %s %5s %3s \n' % ('Mean rate:', meanRate, 'Hz', 'I_e', I_e, 'pA') s = s + 'Steps:\n' s = s + ' %5s %3s \n' % (I_vec, 'pA') infoString = s return STN, infoString
def plot_IV(ax, current, voltage): color = 'b' ''' lower_limit=-55 upper_limit=-80 current=current[voltage<lower_limit] voltage=voltage[voltage<lower_limit] current=current[voltage>upper_limit] voltage=voltage[voltage>upper_limit] ''' current = current - current[-1] ax.plot(current, voltage, **{'color': color}) line = ax.lines ax.my_set_no_ticks(yticks=8, xticks=6) ax.set_xlabel('Current (pA)') ax.set_ylabel('Potential (mV)') #ax.set_xlim(misc.adjust_limit([-220-I_E,-110-I_E])) #ax.set_ylim(misc.adjust_limit([-80,limit])) df = my_nest.GetDefaults(NEURON_MODELS[0]) speed = numpy.diff(voltage) / numpy.diff(current / 1000.) mean_resistance = numpy.mean(speed) mean_membrane_time_constant = mean_resistance * df['C_m'] * 0.001 point = -15 ax.text(0.50, 0.75, str(round(speed[point])) + r' M$\Omega$', backgroundcolor='w', transform=ax.transAxes, fontsize=16, **{'color': 'k'}) ax.plot(current[point], voltage[point], color=color, marker='.', markersize=10) x = [current[point], current[point] - 100] y = [voltage[point], voltage[point] - (100) * speed[point] / 1000.] ax.plot(x, y, color=color, linestyle='--') ax.set_xlim(misc.adjust_limit([-200, 0])) ax.set_ylim(misc.adjust_limit([-85, -55])) pylab.setp(ax.lines, linewidth=2.0) # Need to pu ti before generating legend
def text(ax, binSize, nRep, Output, synapses): statusOutput = my_nest.GetStatus(Output[:])[0] statusSynapes = [] for s in synapses: statusSynapes.append(my_nest.GetDefaults(s)) tb = '' tb = tb + ' %s %10s\n' % ('Model', statusOutput['model']) tb = tb + '\n' tb = tb + ' %s %5s %3s\n' % ('Bin size', binSize, 'ms') tb = tb + ' %s %5s %3s\n' % ('Experiments', nRep, '# ') tb = tb + ' %s %5s %3s\n' % ('Mean rates', meanInputRates, 'Hz ') tb = tb + ' %s %5s %3s\n' % ('selected number', nSelectedInput, '# ') tb = tb + ' %s %5s %3s\n' % ('selected rate', selectedInputRates, 'Hz ') tb = tb + ' %s %5s %3s\n' % ('Inbetween time', inbetweenInputTime, 'ms ') tb = tb + ' %s %5s %3s\n' % ('Inbetween rate', inbetweenInputRate, 'Hz ') tb = tb + '\n' tb = tb + ' %s %5s %3s \n' % ('E rev:', str( statusOutput['GABAA_1_E_rev']), 'mV') tb = tb + ' %s %5s %3s \n' % ('Tau_decay:', str(statusOutput['GABAA_1_Tau_decay']), 'mV') for ss in statusSynapes: tb = tb + '\n' tb = tb + ' %s %10s\n' % ('Synapse', ss['synapsemodel']) tb = tb + ' %s %5s %3s\n' % ('Weight', str(round(ss['weight'], 1)), 'nS') if 'U' in ss.keys(): tb = tb + '\n ' tb = tb + ' %s %5s %3s \n' % ('U:', str(ss['U']), ' ') tb = tb + ' %s %5s %3s \n' % ('tau_fac:', str(ss['tau_fac']), 'ms') tb = tb + ' %s %5s %3s \n' % ('tau_rec:', str(ss['tau_rec']), 'ms') tb = tb + ' %s %5s %3s \n' % ('tau_psc:', str(ss['tau_psc']), 'ms') ax.text( 0.85, 0.5, tb, fontsize=font_size_text, horizontalalignment='right', verticalalignment='center', transform=ax.transAxes, # to define coordinates in right scale **{'fontname': 'monospace'}) ax.remove_axis(xaxis=True, yaxis=True) ax.remove_spine(left=True, bottom=True, right=True, top=True)
def plot_text(ax, infoString): my_nest.ResetKernel() model_list, model_dict = models() my_nest.MyLoadModels(model_list, NEURON_MODELS) my_nest.MyLoadModels(model_list, SYNAPSE_MODELS) SNR = MyGroup(NEURON_MODELS[0], 2, mm_dt=0.1) statusSNR = my_nest.GetStatus(SNR[:])[0] statusSynapes = [] for s in SYNAPSE_MODELS: statusSynapes.append(my_nest.GetDefaults(s)) tb = '' tb = tb + infoString tb = tb + '\n' tb = tb + 'Neuron models:\n ' tb = tb + ' %s \n' % (NEURON_MODELS[0]) tb = tb + '\n' tb = tb + ' %s %5s %3s \n' % ('E rev:', str( statusSNR['GABAA_1_E_rev']), 'mV') tb = tb + ' %s %5s %3s \n' % ('Tau_decay:', str(statusSNR['GABAA_1_Tau_decay']), 'mV') tb = tb + ' %s %5s %3s \n' % ('E rev:', str(statusSNR['AMPA_E_rev']), 'mV') tb = tb + ' %s %5s %3s \n' % ('Tau_decay:', str( statusSNR['AMPA_Tau_decay']), 'mV') for ss in statusSynapes: tb = tb + '\n' tb = tb + ' %s %10s\n' % ('Synapse', ss['synapsemodel']) tb = tb + ' %s %5s %3s\n' % ('Weight', str(round(ss['weight'], 1)), 'nS') ax.text( 0.85, 0.5, tb, fontsize=font_size_text, horizontalalignment='right', verticalalignment='center', transform=ax.transAxes, # to define coordinates in right scale **{'fontname': 'monospace'}) ax.my_remove_axis(xaxis=True, yaxis=True) ax.my_remove_spine(left=True, bottom=True, right=True, top=True)
def simulate_example(I_e): simTime = 3000. # ms my_nest.ResetKernel() model_list, model_dict = models() my_nest.MyLoadModels(model_list, NEURON_MODELS) I_e0 = my_nest.GetDefaults(NEURON_MODELS[0])['I_e'] STN = MyGroup(NEURON_MODELS[0], 1, sd=True, mm=True, mm_dt=1., params={'I_e': I_e + I_e0}) ''' scg = my_nest.Create( 'step_current_generator',n=1 ) rec=my_nest.GetStatus(STN[:])[0]['receptor_types'] my_nest.SetStatus(scg, {'amplitude_times':[280.,1700.], 'amplitude_values':[100.0,0.]}) my_nest.Connect( scg, STN.ids, params = { 'receptor_type' : rec['CURR'] } ) ''' my_nest.MySimulate(simTime) STN.get_signal('v', 'V_m', stop=simTime) # retrieve signal STN.get_signal('s') # retrieve signal meanRate = round(STN.signals['spikes'].mean_rate(0, 1000), 1) print STN.signals['spikes'].isi() STN.signals['V_m'].my_set_spike_peak(21, spkSignal=STN.signals['spikes']) s = '\n' s = s + 'Example:\n' s = s + ' %s %5s %3s %s %5s %3s \n' % ('Mean rate:', meanRate, 'Hz', 'I_e', I_e, 'pA') infoString = s return STN, infoString
def plot_text(ax, infoString=''): my_nest.ResetKernel() model_list = models() my_nest.MyLoadModels(model_list, neuronModels) my_nest.MyLoadModels(model_list, synapseModels) SNR = MyGroup(neuronModels[0], 2, mm_dt=0.1) statusSNR = my_nest.GetStatus(SNR[:])[0] statusSynapes = [] for s in synapseModels: statusSynapes.append(my_nest.GetDefaults(s)) tb = '' tb = tb + infoString for ss in statusSynapes: tb = tb + '\n' tb = tb + ' %s %10s\n' % ('Synapse', ss['synapsemodel']) tb = tb + ' %s %5s %3s\n' % ('Weight', str(round(ss['weight'], 1)), 'nS') if 'U' in ss.keys(): tb = tb + ' %s %5s %3s \n' % ('U:', str(ss['U']), '--') tb = tb + ' %s %5s %3s \n' % ('tau_fac:', str(ss['tau_fac']), 'ms') tb = tb + ' %s %5s %3s \n' % ('tau_rec:', str(ss['tau_rec']), 'ms') tb = tb + ' %s %5s %3s \n' % ('tau_psc:', str(ss['tau_psc']), 'ms') ax.text( 0.85, 0.5, tb, fontsize=font_size_text, horizontalalignment='right', verticalalignment='center', transform=ax.transAxes, # to define coordinates in right scale **{'fontname': 'monospace'}) ax.my_remove_axis(xaxis=True, yaxis=True) ax.my_remove_spine(left=True, bottom=True, right=True, top=True)
def simulate_basa_line_GPe(msn_rate, stn_rate, gpe_rate, n_msn, n_stn, n_gpe, neuron_model, syn_models, gpe_current, sim_time=1000, threads=8): model_list, model_dict = models() my_nest.ResetKernel(threads=threads) my_nest.MyLoadModels(model_dict, neuron_model) my_nest.MyLoadModels(model_dict, syn_models) SNR_list = [] # List with SNR groups for synapse. if n_msn > 0: MSN = MyPoissonInput(n=n_msn, sd=False) if n_stn > 0: STN = MyPoissonInput(n=n_stn, sd=False) if n_gpe > 0: GPE = MyPoissonInput(n=n_gpe, sd=False) if n_msn > 0: MSN.set_spike_times(rates=[msn_rate], times=[1], t_stop=sim_time, seed=0) if n_stn > 0: STN.set_spike_times(rates=[stn_rate], times=[1], t_stop=sim_time, seed=0) if n_gpe > 0: GPE.set_spike_times(rates=[gpe_rate], times=[1], t_stop=sim_time, seed=0) I_e = my_nest.GetDefaults(neuron_model[0])['I_e'] + gpe_current GPE_target = MyGroup(neuron_model[0], n=1, sd=True, params={'I_e': I_e}, mm_dt=.1, mm=True) if n_msn > 0: my_nest.Connect(MSN[:], GPE_target[:] * len(MSN[:]), model=syn_models[0]) if n_stn > 0: my_nest.Connect(STN[:], GPE_target[:] * len(STN[:]), model=syn_models[1]) if n_gpe > 0: my_nest.Connect(GPE[:], GPE_target[:] * len(GPE[:]), model=syn_models[2]) my_nest.MySimulate(sim_time) GPE_target.get_signal('s', start=0, stop=sim_time) meanRate = round(GPE_target.signals['spikes'].mean_rate(1000, sim_time), 1) spk = GPE_target.signals['spikes'].time_slice(1000, sim_time).raw_data() CV = numpy.std(numpy.diff(spk[:, 0], axis=0)) / numpy.mean( numpy.diff(spk[:, 0], axis=0)) GPE_target.get_signal('v', recordable='V_m', start=0, stop=sim_time) GPE_target.signals['V_m'].my_set_spike_peak( 15, spkSignal=GPE_target.signals['spikes']) pylab.rcParams.update({'path.simplify': False}) GPE_target.signals['V_m'].plot() pylab.title(str(meanRate) + 'Hz, CV=' + str(CV)) pylab.show() return
def simulate_selection_vs_neurons(selection_intervals=[0.0, 500.0], hz=20, 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=100 n_exp = 2 if hz > 7: n_max_sel = 60 if hz > 20: n_max_sel = 30 else: n_max_sel = 100 RATE_BASE = 0.1 RATE_SELE = hz save_result_at = (OUTPUT_PATH + '/' + FILE_NAME + '-simulate_selection_vs_neurons' + str(hz) + '-hz.pkl') save_header_at = (OUTPUT_PATH + '/' + FILE_NAME + '-simulate_selection_vs_neurons' + str(hz) + '-hz_header') burst_time = 500. sim_time = burst_time + 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_TESTED) 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_max_sel, sd=True) MSN_list.append(MSN) GPE_list = [] # GPE input for each experiment for i_exp in EXPERIMENTS: GPE = MyPoissonInput(n=N_GPE, sd=True) GPE_list.append(GPE) SNR_list = [] # SNR groups for each synapse and number of selected MSN SNR_list_experiments = [] for i_syn, syn in enumerate(SYNAPSE_MODELS_TESTED): SNR = [] for i_sel in range(n_max_sel + 1): # Plus one to get no burst point I_e = my_nest.GetDefaults( NEURON_MODELS[0])['I_e'] + SNR_INJECTED_CURRENT SNR.append( MyGroup(NEURON_MODELS[0], n=n_exp, sd=True, params={'I_e': I_e})) SNR_list.append(SNR) if not load: for i_exp in EXPERIMENTS: MSN = MSN_list[i_exp] GPE = GPE_list[i_exp] # Set spike times # Base rate for id in MSN[1:N_MSN]: MSN.set_spike_times(id=id, rates=[RATE_BASE], times=[1], t_stop=sim_time, seed=int(numpy.random.random() * 10000.0)) # Selection for id in MSN[N_MSN:N_MSN + n_max_sel]: rates = [RATE_BASE, RATE_SELE, RATE_BASE] times = [1, SEL_ONSET, burst_time + 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)) # Base rate GPE 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)) # Connect for i_syn, syn in enumerate(SYNAPSE_MODELS_TESTED): # i_sel goes over 0,..., n_max_sel for i_sel in range(0, n_max_sel + 1): target = SNR_list[i_syn][i_sel][i_exp] my_nest.ConvergentConnect(MSN[0:N_MSN - i_sel], [target], model=syn) my_nest.ConvergentConnect(MSN[N_MSN:N_MSN + i_sel], [target], model=syn) my_nest.ConvergentConnect( GPE[:], [target], model=SYNAPSE_MODELS_BACKGROUND[0]) my_nest.MySimulate(sim_time) for SNR_sel in SNR_list: for SNR in SNR_sel: SNR.get_signal('s') sel_interval_mean_rates = [] sel_interval_mean_rates_std = [] for i_interval, interval in enumerate(selection_intervals): t1 = selection_intervals[i_interval][0] t2 = selection_intervals[i_interval][1] mean_rates = [] mean_rates_std = [] # Time until arrival of spikes in SNr delay = my_nest.GetDefaults(SYNAPSE_MODELS_BACKGROUND[0])['delay'] for SNR_sel in SNR_list: m_r = [] m_r_std = [] for SNR in SNR_sel: m_r.append(SNR.signals['spikes'].mean_rate( SEL_ONSET + t1 + delay, SEL_ONSET + t2 + delay)) m_r_std.append(SNR.signals['spikes'].mean_rate_std( SEL_ONSET + t1 + delay, SEL_ONSET + t2 + delay)) mean_rates.append(m_r) mean_rates_std.append(m_r_std) mean_rates = numpy.array(mean_rates) mean_rates_std = numpy.array(mean_rates_std) sel_interval_mean_rates.append(mean_rates) sel_interval_mean_rates_std.append(mean_rates_std) nb_neurons = numpy.arange(0, n_max_sel + 1, 1) s = '\n' s = s + ' %s %5s %3s \n' % ('N MSNs:', str(N_MSN), '#') s = s + ' %s %5s %3s \n' % ('N experiments:', str(n_exp), '#') 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' % ('SNR_INJECTED_CURRENT:', str(SNR_INJECTED_CURRENT), 'pA') for i_interval, interval in enumerate(selection_intervals): s = s + ' %s %5s %3s \n' % ('Sel interval ' + str(i_interval) + ':', str(selection_intervals), 'ms') info_string = s header = HEADER_SIMULATION_SETUP + s misc.text_save(header, save_header_at) misc.pickle_save([ nb_neurons, sel_interval_mean_rates, sel_interval_mean_rates_std, info_string ], save_result_at) elif load: nb_neurons, sel_interval_mean_rates, sel_interval_mean_rates_std, info_string = misc.pickle_load( save_result_at) return nb_neurons, sel_interval_mean_rates, sel_interval_mean_rates_std, info_string
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_network_poisson(params_msn_d1, params_msn_d2, params_stn, synapse_models, sim_time, seed, I_e_add, threads=1, start_rec=0, model_params={}, params_in={}, p_weights=False, p_conn=False, p_I_e=False): ''' Assume that the background MSN are static weak, then can use poisson process for them, params_msn_d1 - dictionary with timing and burst freq setup for msn {'base_rates':0.1, 'base_times':[1], 'mod_rates': 20, 'mod_times':[1,200], 'mod_units':list() 'n_tot':500, n_mod=20} params_msn_d2 - dictionary with timing and burst freq setup for gpe params_stn - dictionary {'rate':50} same as params_msn neuron_model - string, the neuron model to use synapse_models - dict, {'MSN':'...', 'GPE':,'...', 'STN':'...'} sim_time - simulation time seed - seed for random generator I_e_add - diabled start_rec - start recording from model_params - general model paramters ''' params = { 'conns': { 'MSN_D1_SNR': { 'syn': synapse_models[0] }, 'GPE_SNR': { 'syn': synapse_models[1] } } } my_nest.ResetKernel(threads=8) numpy.random.seed(seed) params = misc.dict_merge(model_params, params) params = misc.dict_merge({'neurons': {'GPE': {'paused': 0}}}, params) model_list, model_dict = models({}, p_weights) layer_list, connect_list = network(model_dict, params, p_conn) dic_p_I_e = {'SNR': 1., 'GPE': 1., 'STN': 1.} if p_I_e is not False: dic_p_I_e['SNR'] *= p_I_e[0] dic_p_I_e['GPE'] *= p_I_e[1] dic_p_I_e['STN'] *= p_I_e[2] # Create neurons and synapses layer_dic = {} for name, model, props in layer_list: # Update input current my_nest.MyLoadModels(model_dict, [model[1]]) if name in I_IN_VIVO.keys(): I_in_vitro = my_nest.GetDefaults(model[1])['I_e'] I_e = I_in_vitro + I_IN_VIVO[name] my_nest.SetDefaults(model[1], {'I_e': I_e * dic_p_I_e[name]}) #! Create layer, retrieve neurons ids per elements and p if model[0] == 'spike_generator': layer = MyLayerPoissonInput(layer_props=props, sd=True, sd_params={ 'start': start_rec, 'stop': sim_time }) elif model[0] == 'poisson_generator': layer = MyPoissonInput(model[0], props['columns'], sd=True, sd_params={ 'start': start_rec, 'stop': sim_time }) else: layer = MyLayerGroup(layer_props=props, sd=True, mm=False, mm_dt=0.1, sd_params={ 'start': start_rec, 'stop': sim_time }) for iter, id in enumerate(layer[:]): if name == 'GPE' and params_msn_d2[ 'n_mod'] and iter < params['neurons']['GPE']['paused']: scg = my_nest.Create('step_current_generator', n=1) rec = my_nest.GetStatus([id])[0]['receptor_types'] my_nest.SetStatus( scg, { 'amplitude_times': params_msn_d2['mod_times'], 'amplitude_values': [0., -300., 0.] }) my_nest.Connect(scg, [id], params={'receptor_type': rec['CURR']}) I_e = my_nest.GetDefaults(model[1])['I_e'] if I_E_VARIATION[name]: I = numpy.random.normal( I_e, I_E_VARIATION[name]) #I_E_VARIATION[name]) else: I = I_e my_nest.SetStatus([id], {'I_e': I}) layer_dic[name] = layer # Connect populations for conn in connect_list: print[conn[2]['synapse_model']] if not conn[2]['synapse_model'] in nest.Models(): my_nest.MyLoadModels(model_dict, [conn[2]['synapse_model']]) if layer_dic[conn[0]].model == 'poisson_generator': my_nest.Connect(layer_dic[conn[0]].ids, layer_dic[conn[1]].ids, model=conn[2]['synapse_model']) else: name = conn[0] + '_' + conn[1] + '_' + conn[3] tp.ConnectLayers(layer_dic[conn[0]].layer_id, layer_dic[conn[1]].layer_id, conn[2]) layer_dic[conn[1]].add_connection(source=layer_dic[conn[0]], type=conn[3], props=conn[2]) # Sort MSN D2 such that the closest to center is first in ids list. # Do this to we can get focused inhibition in GPe if params_msn_d2['focus']: MSN_D2_idx = layer_dic['MSN_D2'].sort_ids() else: MSN_D2_idx = range(len(numpy.array(layer_dic['MSN_D2'].ids))) n_mod_msn_d1 = params_msn_d1['n_mod'] n_mod_msn_d2 = params_msn_d2['n_mod'] MSN_D1_ids = layer_dic['MSN_D1'].ids MSN_D2_ids = layer_dic['MSN_D2'].ids MSN_D1_mod, MSN_D2_mod = [], [] if params_msn_d1['n_mod']: MSN_D1_mod = MSN_D1_ids[0:n_mod_msn_d1] if params_msn_d2['n_mod']: MSN_D2_mod = MSN_D2_ids[0:n_mod_msn_d2 * params_msn_d2['skip']:params_msn_d2['skip']] MSN_D1_base = list(set(MSN_D1_ids).difference(MSN_D1_mod)) MSN_D2_base = list(set(MSN_D2_ids).difference(MSN_D2_mod)) layer_dic['MSN_D1'].set_spike_times(params_msn_d1['base_rates'], params_msn_d1['base_times'], sim_time, ids=MSN_D1_base) layer_dic['MSN_D2'].set_spike_times(params_msn_d2['base_rates'], params_msn_d2['base_times'], sim_time, ids=MSN_D2_base) if params_msn_d1['n_mod']: layer_dic['MSN_D1'].set_spike_times(params_msn_d1['mod_rates'], params_msn_d1['mod_times'], sim_time) if params_msn_d2['n_mod']: layer_dic['MSN_D2'].set_spike_times(params_msn_d2['mod_rates'], params_msn_d2['mod_times'], sim_time, ids=MSN_D2_mod) # If background poisson are use if params_msn_d1['bg_rate']: layer_dic['MSN_D1_bg'].set_spike_times(params_msn_d1['bg_rate'], [1.], sim_time) if params_msn_d2['bg_rate']: layer_dic['MSN_D2_bg'].set_spike_times(params_msn_d2['bg_rate'], [1.], sim_time) STN_CTX_input_base = my_nest.Create('poisson_generator', params={ 'rate': BASE_RATE_CTX_STN, 'start': 0., 'stop': sim_time }) my_nest.MyLoadModels(model_dict, ['CTX_STN_ampa_s']) if 'STN' in layer_dic.keys(): my_nest.DivergentConnect(STN_CTX_input_base, layer_dic['STN'].ids, model='CTX_STN_ampa_s') if params_stn['mod'] and 'STN' in layer_dic.keys(): STN_CTX_input_mod = my_nest.Create('poisson_generator', params={ 'rate': params_stn['mod_rate'], 'start': params_stn['mod_times'][0], 'stop': params_stn['mod_times'][1] }) my_nest.DivergentConnect(STN_CTX_input_mod, layer_dic['STN'].ids, model='CTX_STN_ampa_s') my_nest.MySimulate(sim_time) if params_msn_d1['n_mod']: layer_dic['MSN_D1'].id_mod = MSN_D1_mod if params_msn_d2['n_mod']: layer_dic['MSN_D2'].id_mod = MSN_D2_mod if 'MSN_D1' in layer_dic.keys(): layer_dic['MSN_D1'].get_signal('s', start=start_rec, stop=sim_time) if 'MSN_D2' in layer_dic.keys(): layer_dic['MSN_D2'].get_signal('s', start=start_rec, stop=sim_time) if 'GPE' in layer_dic.keys(): layer_dic['GPE'].get_signal('s', start=start_rec, stop=sim_time) if 'SNR' in layer_dic.keys(): layer_dic['SNR'].get_signal('s', start=start_rec, stop=sim_time) if 'STN' in layer_dic.keys(): layer_dic['STN'].get_signal('s', start=start_rec, stop=sim_time) return layer_dic
def simulate_network_test(params_msn_d1, params_msn_d2, params_stn, synapse_models, sim_time, seed, I_e_add, threads=1, start_rec=0, model_params={}, params_in={}, dis_conn_GPE_STN=False): ''' params_msn_d1 - dictionary with timing and burst freq setup for msn {'base_rates':0.1, 'base_times':[1], 'mod_rates': 20, 'mod_times':[1,200], 'mod_units':list() 'n_tot':500, n_mod=20} params_msn_d2 - dictionary with timing and burst freq setup for gpe params_stn - dictionary {'rate':50} same as params_msn neuron_model - string, the neuron model to use synapse_models - dict, {'MSN':'...', 'GPE':,'...', 'STN':'...'} sim_time - simulation time seed - seed for random generator I_e_add - diabled start_rec - start recording from model_params - general model paramters ''' my_nest.ResetKernel(threads=8) numpy.random.seed(seed) params = { 'conns': { 'MSN_D1_SNR': { 'syn': synapse_models[0] }, 'GPE_SNR': { 'syn': synapse_models[1] } } } params = misc.dict_merge(model_params, params) params = misc.dict_merge({'neurons': {'GPE': {'paused': 0}}}, params) model_list, model_dict = models(params_in) layer_list, connect_list = network(model_dict, params) # Create neurons and synapses layer_dic = {} for name, model, props in layer_list: # Update input current my_nest.MyLoadModels(model_dict, [model[1]]) if name in I_IN_VIVO.keys(): I_e = my_nest.GetDefaults(model[1])['I_e'] + I_IN_VIVO[name] my_nest.SetDefaults(model[1], {'I_e': I_e}) #! Create layer, retrieve neurons ids per elements and p if model[0] == 'spike_generator': layer = MyLayerPoissonInput(layer_props=props, sd=True, sd_params={ 'start': start_rec, 'stop': sim_time }) else: layer = MyLayerGroup(layer_props=props, sd=True, mm=False, mm_dt=0.1, sd_params={ 'start': start_rec, 'stop': sim_time }) for iter, id in enumerate(layer[:]): if name == 'GPE' and params_msn_d2[ 'n_mod'] and iter < params['neurons']['GPE']['paused']: scg = my_nest.Create('step_current_generator', n=1) rec = my_nest.GetStatus([id])[0]['receptor_types'] my_nest.SetStatus( scg, { 'amplitude_times': params_msn_d2['mod_times'], 'amplitude_values': [0., -300., 0.] }) my_nest.Connect(scg, [id], params={'receptor_type': rec['CURR']}) I_e = my_nest.GetDefaults(model[1])['I_e'] if I_E_VARIATION[name]: I = numpy.random.normal(I_e, I_E_VARIATION[name]) else: I = I_e #I=I_e my_nest.SetStatus([id], {'I_e': I}) layer_dic[name] = layer mm = nest.Create('multimeter', 1) recodables = ['V_m', 'I', 'g_AMPA', 'g_NMDA', 'g_GABAA_1', 'g_GABAA_2'] my_nest.SetStatus(mm, {'interval': 0.1, 'record_from': recodables}) my_nest.Connect(mm, [layer_dic['STN'].ids[0]]) # Connect populations for conn in connect_list: name = conn[0] + '_' + conn[1] my_nest.MyLoadModels(model_dict, [conn[2]['synapse_model']]) if dis_conn_GPE_STN == 'GPE' and (name in ['GPE_SNR']): r, syn = 32 * 30.0, 'GPE_SNR_gaba_s_ref' if not syn in my_nest.Models(): my_nest.MyLoadModels(model_dict, [syn]) pg = my_nest.Create('poisson_generator', 1, { 'rate': r, 'start': 1. }) my_nest.DivergentConnect(pg, layer_dic[conn[1]].ids, model=syn) elif dis_conn_GPE_STN == 'STN' and (name in ['STN_SNR']): r, syn = 30 * 10.0, 'STN_SNR_ampa_s' if not syn in my_nest.Models(): my_nest.MyLoadModels(model_dict, [syn]) pg = my_nest.Create('poisson_generator', 1, { 'rate': r, 'start': 1. }) my_nest.DivergentConnect(pg, layer_dic[conn[1]].ids, model=syn) else: name = name + '_' + conn[3] tp.ConnectLayers(layer_dic[conn[0]].layer_id, layer_dic[conn[1]].layer_id, conn[2]) layer_dic[conn[1]].add_connection(source=layer_dic[conn[0]], type=conn[3], props=conn[2]) # Sort MSN D2 such that the closest to center is first in ids list. # Do this to we can get focused inhibition in GPe if params_msn_d2['focus']: MSN_D2_idx = layer_dic['MSN_D2'].sort_ids() else: MSN_D2_idx = range(len(numpy.array(layer_dic['MSN_D2'].ids))) n_mod_msn_d1 = params_msn_d1['n_mod'] n_mod_msn_d2 = params_msn_d2['n_mod'] MSN_D1_ids = layer_dic['MSN_D1'].ids MSN_D2_ids = layer_dic['MSN_D2'].ids MSN_D1_mod, MSN_D2_mod = [], [] if params_msn_d1['n_mod']: MSN_D1_mod = MSN_D1_ids[0:n_mod_msn_d1] if params_msn_d2['n_mod']: MSN_D2_mod = MSN_D2_ids[0:n_mod_msn_d2 * params_msn_d2['skip']:params_msn_d2['skip']] MSN_D1_base = list(set(MSN_D1_ids).difference(MSN_D1_mod)) MSN_D2_base = list(set(MSN_D2_ids).difference(MSN_D2_mod)) #layer_dic['MSN_D1'].ids[0:n_base_msn_d1] #MSN_D2_ids=numpy.array(layer_dic['MSN_D2'].ids) #MSN_D2_base=MSN_D2_ids#[MSN_D2_idx[0:n_base_msn_d1]] #set().difference(t) layer_dic['MSN_D1'].set_spike_times(params_msn_d1['base_rates'], params_msn_d1['base_times'], sim_time, ids=MSN_D1_base) layer_dic['MSN_D2'].set_spike_times(params_msn_d2['base_rates'], params_msn_d2['base_times'], sim_time, ids=MSN_D2_base) if params_msn_d1['n_mod']: layer_dic['MSN_D1'].set_spike_times(params_msn_d1['mod_rates'], params_msn_d1['mod_times'], sim_time, ids=MSN_D1_mod) if params_msn_d2['n_mod']: layer_dic['MSN_D2'].set_spike_times(params_msn_d2['mod_rates'], params_msn_d2['mod_times'], sim_time, ids=MSN_D2_mod) STN_CTX_input_base = my_nest.Create('poisson_generator', params={ 'rate': BASE_RATE_CTX_STN, 'start': 0., 'stop': sim_time }) my_nest.MyLoadModels(model_dict, ['CTX_STN_ampa_s']) my_nest.DivergentConnect(STN_CTX_input_base, layer_dic['STN'].ids, model='CTX_STN_ampa_s') if params_stn['mod']: STN_CTX_input_mod = my_nest.Create('poisson_generator', params={ 'rate': params_stn['mod_rate'], 'start': params_stn['mod_times'][0], 'stop': params_stn['mod_times'][1] }) my_nest.DivergentConnect(STN_CTX_input_mod, layer_dic['STN'].ids, model='CTX_STN_ampa_s') #tar=[] #for id in layer_dic['MSN_D1'].ids: # tar.extend(sorted(nest.GetStatus(my_nest.FindConnections([id]),'target'))[:-1]) #pylab.subplot(211).hist(tar, 1500) # # tar=[] # for id in layer_dic['MSN_D2'].ids: # tar.extend(sorted(nest.GetStatus(my_nest.FindConnections([id]),'target'))[1:]) # # pylab.subplot(212).hist(tar, 1500) #pylab.show() # # my_nest.MySimulate(sim_time) if params_msn_d1['n_mod']: layer_dic['MSN_D1'].id_mod = MSN_D1_mod if params_msn_d2['n_mod']: layer_dic['MSN_D2'].id_mod = MSN_D2_mod #layer_dic['MSN_D1'].get_signal( 's', start=start_rec, stop=sim_time ) #layer_dic['MSN_D2'].get_signal( 's', start=start_rec, stop=sim_time ) #layer_dic['GPE'].get_signal( 's', start=start_rec, stop=sim_time ) #layer_dic['SNR'].get_signal( 's', start=start_rec, stop=sim_time ) #layer_dic['STN'].get_signal( 's', start=start_rec, stop=sim_time ) st_mm = my_nest.GetStatus(mm)[0] pylab.plot(st_mm['events']['g_AMPA']) pylab.plot(st_mm['events']['g_GABAA_1']) pylab.plot(st_mm['events']['g_NMDA']) pylab.plot(st_mm['events']['g_GABAA_2']) m_ampa = numpy.mean(st_mm['events']['g_AMPA']) m_gaba = numpy.mean(st_mm['events']['g_GABAA_1']) pylab.title("{0} m_ampa:{1:2.1f} m_gaba:{2:2.1f}".format( my_nest.version(), m_ampa, m_gaba)) pylab.show() return layer_dic
def simulate_basa_line_SNr(msn_rate, gpe_rate, stn_rate, n_msn, n_gpe, n_stn, neuron_model, syn_models, snr_current, sim_time=1000, threads=8, w_STN_SNR=0, seed=0, record_vm=True, multiple=False): if not multiple: Params_in = {} if w_STN_SNR: Params_in['STN_SNR_ampa_s'] = w_STN_SNR model_list, model_dict = models(Params_in) my_nest.ResetKernel(threads=threads) my_nest.MyLoadModels(model_dict, neuron_model) my_nest.MyLoadModels(model_dict, syn_models) SNR_list = [] # List with SNR groups for synapse. if n_msn > 0: MSN = MyPoissonInput(n=n_msn, sd=True) if n_gpe > 0: GPE = MyPoissonInput(n=n_gpe, sd=False) if n_stn > 0: STN = MyPoissonInput(n=n_stn, sd=False) if n_msn > 0: MSN.set_spike_times(rates=[msn_rate], times=[1], t_stop=sim_time, seed=seed) if n_gpe > 0: GPE.set_spike_times(rates=[gpe_rate], times=[1], t_stop=sim_time, seed=seed) if n_stn > 0: STN.set_spike_times(rates=[stn_rate], times=[1], t_stop=sim_time, seed=seed) I_e = my_nest.GetDefaults(neuron_model[0])['I_e'] + snr_current SNR = MyGroup(neuron_model[0], n=1, sd=True, params={'I_e': I_e}, mm_dt=.1, mm=record_vm) if n_msn > 0: my_nest.Connect(MSN[:], SNR[:] * len(MSN[:]), model=syn_models[0]) if n_gpe > 0: my_nest.Connect(GPE[:], SNR[:] * len(GPE[:]), model=syn_models[1]) if n_stn > 0: my_nest.Connect(STN[:], SNR[:] * len(STN[:]), model=syn_models[2]) return SNR
def simulate_basa_line_GPe(msn_rate, stn_rate, gpe_rate, n_msn, n_stn, n_gpe, neuron_model, syn_models, gpe_current, sim_time=1000, threads=8, w_GPE_GPE=False, w_STN_GPE=False): Params_in = {} if w_GPE_GPE: Params_in['GPE_GPE_gaba_s'] = w_GPE_GPE if w_STN_GPE: Params_in['STN_GPE_ampa_s'] = w_STN_GPE model_list, model_dict = models(Params_in) my_nest.ResetKernel(threads=threads) my_nest.MyLoadModels(model_dict, neuron_model) my_nest.MyLoadModels(model_dict, syn_models) SNR_list = [] # List with SNR groups for synapse. if n_msn > 0: MSN = MyPoissonInput(n=n_msn, sd=False) if n_stn > 0: STN = MyPoissonInput(n=n_stn, sd=False) if n_gpe > 0: GPE = MyPoissonInput(n=n_gpe, sd=False) if n_msn > 0: MSN.set_spike_times(rates=[msn_rate], times=[1], t_stop=sim_time, seed=0) if n_stn > 0: STN.set_spike_times(rates=[stn_rate], times=[1], t_stop=sim_time, seed=0) if n_gpe > 0: GPE.set_spike_times(rates=[gpe_rate], times=[1], t_stop=sim_time, seed=0) I_e = my_nest.GetDefaults(neuron_model[0])['I_e'] + gpe_current GPE_target = MyGroup(neuron_model[0], n=1, sd=True, params={'I_e': I_e}, mm_dt=.1, mm=True) if n_msn > 0: my_nest.Connect(MSN[:], GPE_target[:] * len(MSN[:]), model=syn_models[0]) if n_stn > 0: my_nest.Connect(STN[:], GPE_target[:] * len(STN[:]), model=syn_models[1]) if n_gpe > 0: my_nest.Connect(GPE[:], GPE_target[:] * len(GPE[:]), model=syn_models[2]) my_nest.MySimulate(sim_time) GPE_target.get_signal('s', start=0, stop=sim_time) GPE_target.get_signal('v', recordable='V_m', start=0, stop=sim_time) return GPE_target
def simulate_steady_state_freq(frequencies, flag='ss', load=True): # Path were raw data is saved. For example the spike trains. save_result_at=OUTPUT_PATH+'/simulate_steady_state_freq.pkl' save_header_at=OUTPUT_PATH+'/simulate_steady_state_freq_header' relativeFacilitation=[] n=len(frequencies) if not load: for syn in SYNAPSE_MODELS: my_nest.ResetKernel() model_list, model_dict=models() my_nest.MyLoadModels( model_list, NEURON_MODELS ) my_nest.MyLoadModels( model_list, [syn]) SNR = MyGroup( NEURON_MODELS[0], n, mm=True, mm_dt = .1, params={'I_e':-150.}, record_from=['g_AMPA'] ) tSim=5*1000/frequencies[0] spikeTimes=[] tmpSteadyState=[] for f in frequencies : isi = 1000./f spikeTimes.append(numpy.arange(1,tSim,isi)) for target, st in zip(SNR, spikeTimes ) : source = my_nest.Create('spike_generator', params={'spike_times':st} ) my_nest.SetDefaults(syn, params={'delay':1.}) my_nest.Connect(source, [target], model=syn) my_nest.MySimulate(tSim) SNR.get_signal( 'g','g_AMPA', stop=tSim ) # retrieve signal signal=SNR.signals['g_AMPA'] for i, st in enumerate(spikeTimes, start=1): if SNR.mm_dt==0.1: indecies=numpy.int64(numpy.ceil(st*10))+9 elif SNR.mm_dt==1.: indecies=numpy.int64(numpy.ceil(st)) values=signal[i].signal[indecies]-signal[i].signal[indecies-1] ss=my_nest.GetDefaults(syn) synapticEficacy = ss['weight']*ss['U'] if flag=='ss': tmpSteadyState.append(values[-1]/synapticEficacy) if flag=='max': tmpSteadyState.append(max(values)/synapticEficacy) relativeFacilitation.append(tmpSteadyState) relativeFacilitation=numpy.array(relativeFacilitation) header=HEADER_SIMULATION_SETUP misc.text_save(header, save_header_at) misc.pickle_save([frequencies, relativeFacilitation], save_result_at) elif load: frequencies, relativeFacilitation=misc.pickle_load(save_result_at) return frequencies, relativeFacilitation
def simulate_network(params_msn_d1, params_msn_d2, params_stn, synapse_models, sim_time, seed, I_e_add, threads=1, start_rec=0, model_params={}): ''' params_msn_d1 - dictionary with timing and burst freq setup for msn {'base_rates':[0.1, 0.1, ..., 0.1], #Size number of actions 'mod_rates': [[20,0,...,0], [0,20,...,0],...[0,0,...,20]] #size number of actions times number of events 'mod_times':[[500,1000],[1500,2000],[9500,10000]] # size number of events 'n_neurons':500} params_msn_d2 - dictionary with timing and burst freq setup for gpe params_stn - dictionary {'rate':50} same as params_msn neuron_model - string, the neuron model to use synapse_models - dict, {'MSN':'...', 'GPE':,'...', 'STN':'...'} sim_time - simulation time seed - seed for random generator I_e_add - diabled start_rec - start recording from model_params - general model paramters ''' I_e_add = {'SNR': 300, 'STN': 0, 'GPE': 30} f = 0.01 #0.01#0.5 I_e_variation = {'GPE': 25 * f, 'SNR': 100 * f, 'STN': 10 * f} my_nest.ResetKernel(threads=8) numpy.random.seed(seed) params = { 'conns': { 'MSN_D1_SNR': { 'syn': synapse_models[0] }, 'GPE_SNR': { 'syn': synapse_models[1] } } } params = misc.dict_merge(model_params, params) model_list, model_dict = models() group_list, group_dict, connect_list, connect_params = network( model_dict, params) print connect_params groups = {} for name, model, setup in group_list: # Update input current my_nest.MyLoadModels(model_dict, [model]) if name in I_e_add.keys(): I_e = my_nest.GetDefaults(model)['I_e'] + I_e_add[name] my_nest.SetDefaults(model, {'I_e': I_e}) groups[name] = [] for action in range(connect_params['misc']['n_actions']): if model in ['MSN_D1_spk_gen', 'MSN_D2_spk_gen']: group = MyPoissonInput(params=setup, sd=True, sd_params={ 'start': start_rec, 'stop': sim_time }) else: group = MyGroup(params=setup, sd=True, mm=False, mm_dt=0.1, sd_params={ 'start': start_rec, 'stop': sim_time }) groups[name].append(group) for action in range(connect_params['misc']['n_actions']): groups['MSN_D1'][action].set_spike_times( list(params_msn_d1['mod_rates'][action]), list(params_msn_d1['mod_times']), sim_time, ids=groups['MSN_D1'][action].ids) groups['MSN_D2'][action].set_spike_times( params_msn_d2['mod_rates'][action], params_msn_d2['mod_times'], sim_time, ids=groups['MSN_D2'][action].ids) # Create neurons and synapses for source, target, props in connect_list: my_nest.MyLoadModels(model_dict, [props['model']]) for action in range(connect_params['misc']['n_actions']): pre = list(groups[source][action].ids) post = list(groups[target][action].ids) my_nest.MyRandomConvergentConnect(pre, post, params=props) STN_CTX_input_base = my_nest.Create('poisson_generator', params={ 'rate': params_stn['rate'], 'start': 0., 'stop': sim_time }) my_nest.MyLoadModels(model_dict, ['CTX_STN_ampa_s']) for action in range(connect_params['misc']['n_actions']): my_nest.DivergentConnect(STN_CTX_input_base, groups['STN'][action].ids, model='CTX_STN_ampa_s') my_nest.MySimulate(sim_time) for action in range(connect_params['misc']['n_actions']): groups['MSN_D1'][action].get_signal('s', start=start_rec, stop=sim_time) groups['MSN_D2'][action].get_signal('s', start=start_rec, stop=sim_time) groups['GPE'][action].get_signal('s', start=start_rec, stop=sim_time) groups['SNR'][action].get_signal('s', start=start_rec, stop=sim_time) groups['STN'][action].get_signal('s', start=start_rec, stop=sim_time) return groups
MSN.get_signal('v', 'V_m') pylab.close('all') # display # Create figure where figsize(width,height) and figure dimenstions window # width = figsize(width) x dpi and window hight = figsize(hight) x dpi plot_settings.set_mode(mode='dynamic', w=700.0, h=400.0) font_size_text = 10 fig = pylab.figure(facecolor='w') pylab.suptitle('MSN to MSN') ax_list = [] ax_list.append(MyAxes(fig, [.1, .37, .2, .26])) # text box ax_list.append(MyAxes(fig, [.50, .15, .40, .65])) # voltage trace ds = my_nest.GetDefaults(syn_model) sn = my_nest.GetStatus(MSN[:])[0] ax = ax_list[0] # Text box tb = '' tb = tb + ' %6s %7s %3s \n' % ('Synapse model:', ds['synapsemodel'], ' ') tb = tb + ' \n ' tb = tb + ' %6s %7s %3s \n' % ('Delay:', ds['delay'], 'ms') tb = tb + ' %6s %7s %3s \n' % ('Weight:', ds['weight'], 'nS') tb = tb + ' \n ' tb = tb + ' %6s %7s %3s \n' % ('Decay:', sn['GABAA_2_Tau_decay'], 'ms') tb = tb + ' %6s %7s %3s \n' % ('E_rev:', sn['GABAA_2_E_rev'], 'mV') ax.text( 0.9, 0.5,
def simulate_recovery(revoceryTimes, load=True): # Path were raw data is saved. For example the spike trains. save_result_at=OUTPUT_PATH+'/simulate_recovery.pkl' save_header_at=OUTPUT_PATH+'/simulate_recovery_header' relativeRecovery=[] n=len(revoceryTimes) if not load: for syn in SYNAPSE_MODELS: my_nest.ResetKernel() model_list, model_dict=models() my_nest.MyLoadModels( model_list, NEURON_MODELS ) my_nest.MyLoadModels( model_list, [syn]) ss=my_nest.GetDefaults(syn) synapticEficacy = ss['weight']*ss['U'] SNR = MyGroup( NEURON_MODELS[0], n, mm=True, mm_dt = .1, params={'I_e':-150.}, record_from=['g_AMPA']) tSim=10000 spikeTimes=[] for rt in revoceryTimes: #spikeTimes.append(numpy.array([1.,11.,21.,31.,41.,41+rt])) # Choosen so that it starts at a pairpulse ration of 0.2 spikeTimes.append(numpy.array([1.,11.,21.,31.,41., 51.,61.,71.,81.,91., 101.,111.,121.,131.,141., 151.,161.,171.,181.,191., 191+rt])) for target, st in zip(SNR, spikeTimes ) : source = my_nest.Create('spike_generator', params={'spike_times':st} ) my_nest.SetDefaults(syn, params={'delay':1.}) my_nest.Connect(source, [target], model=syn) my_nest.MySimulate(tSim) SNR.get_signal( 'g','g_AMPA', stop=tSim ) # retrieve signal signal=SNR.signals['g_AMPA'] tmpSteadyState=[] for i, st in enumerate(spikeTimes, start=1): if SNR.mm_dt==0.1: indecies=numpy.int64(numpy.ceil(st*10))+9 elif SNR.mm_dt==1.: indecies=numpy.int64(numpy.ceil(st)) values=signal[i].signal[indecies]-signal[i].signal[indecies-1] tmpSteadyState.append(values[-1]/synapticEficacy) #tmpSteadyState.append(max(values)/synapticEficacy) relativeRecovery.append(tmpSteadyState) relativeRecovery=numpy.array(relativeRecovery) header=HEADER_SIMULATION_SETUP misc.text_save(header, save_header_at) misc.pickle_save([revoceryTimes, relativeRecovery], save_result_at) elif load: revoceryTimes, relativeRecovery=misc.pickle_load(save_result_at) return revoceryTimes, relativeRecovery
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 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_basa_line_SNr(msn_rate, gpe_rate, stn_rate, n_msn, n_gpe, n_stn, neuron_model, snr_current, sim_time=1000, threads=8, stn_syn='STN_SNR_ampa_s'): SNR_INJECTED_CURRENT = snr_current SYNAPSE_MODEL_BACKROUND_STN = [stn_syn] model_list, model_dict = models() my_nest.ResetKernel(threads=threads) my_nest.MyLoadModels(model_dict, neuron_model) my_nest.MyLoadModels(model_dict, SYNAPSE_MODEL_BACKROUND_MSN) my_nest.MyLoadModels(model_dict, SYNAPSE_MODEL_BACKROUND_GPE) my_nest.MyLoadModels(model_dict, SYNAPSE_MODEL_BACKROUND_STN) SNR_list = [] # List with SNR groups for synapse. if n_msn > 0: MSN_base = MyPoissonInput(n=n_msn, sd=True) if n_gpe > 0: GPE = MyPoissonInput(n=n_gpe, sd=False) if n_stn > 0: STN = MyPoissonInput(n=n_stn, sd=False) if n_msn > 0: MSN_base.set_spike_times(rates=[msn_rate], times=[1], t_stop=sim_time, seed=0) if n_gpe > 0: GPE.set_spike_times(rates=[gpe_rate], times=[1], t_stop=sim_time, seed=0) if n_stn > 0: STN.set_spike_times(rates=[stn_rate], times=[1], t_stop=sim_time, seed=0) I_e = my_nest.GetDefaults(neuron_model[0])['I_e'] + SNR_INJECTED_CURRENT SNR = MyGroup(neuron_model[0], n=1, sd=True, params={'I_e': I_e}, mm_dt=.1, mm=True) if n_msn > 0: my_nest.Connect(MSN_base[:], SNR[:] * len(MSN_base[:]), model=SYNAPSE_MODEL_BACKROUND_MSN[0]) if n_gpe > 0: my_nest.Connect(GPE[:], SNR[:] * len(GPE[:]), model=SYNAPSE_MODEL_BACKROUND_GPE[0]) if n_stn > 0: my_nest.Connect(STN[:], SNR[:] * len(STN[:]), model=SYNAPSE_MODEL_BACKROUND_STN[0]) my_nest.MySimulate(sim_time) SNR.get_signal('s', start=0, stop=sim_time) meanRate = round(SNR.signals['spikes'].mean_rate(1000, sim_time), 1) spk = SNR.signals['spikes'].time_slice(1000, sim_time).raw_data() CV = numpy.std(numpy.diff(spk[:, 0], axis=0)) / numpy.mean( numpy.diff(spk[:, 0], axis=0)) SNR.get_signal('v', recordable='V_m', start=0, stop=sim_time) SNR.signals['V_m'].my_set_spike_peak(15, spkSignal=SNR.signals['spikes']) pylab.rcParams.update({'path.simplify': False}) SNR.signals['V_m'].plot() pylab.title(str(meanRate) + 'Hz, CV=' + str(CV)) pylab.show() return
def simulate_selection_vs_neurons(selRateInterval=[0.0, 500.0], hz=0, load=True): global SEL_ONSET global SNR_INJECTED_CURRENT global N_GPE global N_STN global MSN_RATE_BASE global GPE_BASE_RATE global STN_BASE_RATE SNAME_NB = hz #n_exp=200 n_exp = 20 N_MAX_SEL = N_GPE + 1 # Plus one to account for the case when all GPe have stopped RATE_SELE = hz save_at = (SPATH + '/' + NEURON_MODELS[0] + '-' + str(SNAME_NB) + '-hz.pkl') #SEL_TIME = 1000. sim_time = SEL_TIME + 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_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 + N_MAX_SEL) 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 = [] # STN 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 and number of selected GPE I_e = my_nest.GetDefaults(NEURON_MODELS[0])['I_e'] + SNR_INJECTED_CURRENT for i, i_syn in enumerate(SYNAPSE_MODELS_TESTED): SNR = [] for i_sel in range(N_MAX_SEL): SNR.append( MyGroup(NEURON_MODELS[0], n=n_exp, params={'I_e': I_e}, sd=True, sd_params={ 'start': 0., 'stop': sim_time })) 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 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]: 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_GPE + N_MAX_SEL]: 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 in enumerate(SYNAPSE_MODELS_TESTED): for i_sel in range(N_MAX_SEL): target = SNR_list[i][i_sel][i_exp] my_nest.ConvergentConnect(GPE[0:N_GPE - i_sel], [target], model=syn) my_nest.ConvergentConnect(GPE[N_GPE:N_GPE + i_sel], [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 SNR_sel in SNR_list: for SNR in SNR_sel: SNR.get_signal('s') misc.pickle_save_groups(SNR_list, save_at) elif load: SNR_list = misc.pickle_load_groups(save_at) t1 = selRateInterval[0] t2 = selRateInterval[1] mean_rates = [] delay = my_nest.GetDefaults(SYNAPSE_MODELS_TESTED[0])['delay'] for SNR_sel in SNR_list: m_r = [] for SNR in SNR_sel: m_r_pre = SNR.signals['spikes'].mean_rate(SEL_ONSET - (t2 - t1), SEL_ONSET) m_r_post = SNR.signals['spikes'].mean_rate(SEL_ONSET + t1 + delay, SEL_ONSET + t2 + delay) m_r.append(m_r_post) mean_rates.append(m_r) mean_rates = numpy.array(mean_rates) nb_neurons = numpy.arange(0, N_MAX_SEL, 1) s = '\n' s = s + ' %s %5s %3s \n' % ('N GPEs:', str(N_GPE), '#') s = s + ' %s %5s %3s \n' % ('N experiments:', str(n_exp), '#') 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' % ('SNR_INJECTED_CURRENT:', str(SNR_INJECTED_CURRENT), 'pA') info_string = s return nb_neurons, mean_rates, info_string