def simulate_IV(I_vec): my_nest.ResetKernel() model_list, model_dict = models() my_nest.MyLoadModels(model_list, NEURON_MODELS) SNR = MyGroup(NEURON_MODELS[0], 1, sd=True, mm=True, mm_dt=0.1) I_e0 = my_nest.GetStatus(SNR[:])[0]['I_e'] my_nest.SetStatus(SNR[:], params={'I_e': I_e0 + I_E}) # Set I_e I_e = my_nest.GetStatus(SNR.ids, 'I_e')[0] I_vec, voltage = SNR.IV_I_clamp(I_vec) #current=current speed = numpy.diff(voltage) / numpy.diff(I_vec) * 1000. speed = speed[speed > 0] s = '\n' s = s + 'IV:\n' s = s + ' %s %5s %3s \n' % ('I_e:', I_e, 'pA') ''' s = s + ' %s %4s %s %4s %s %4s\n' % ( 'Speed (mV/pA=MOhm), min:', str(min(speed))[0:4], 'max',str(max(speed))[0:4], 'mean', str(sum(speed)/len(speed))[0:4]) '''# infoString = s I_vec = numpy.array(I_vec) voltage = numpy.array(voltage) return I_vec, voltage, infoString
def simulate_IF(I_vec): tStim = 700 my_nest.ResetKernel() model_list, model_dict = models() my_nest.MyLoadModels(model_list, NEURON_MODELS) SNR = MyGroup(NEURON_MODELS[0], 1, mm=True, sd=True, mm_dt=0.1) I_e0 = my_nest.GetStatus(SNR[:])[0]['I_e'] my_nest.SetStatus(SNR[:], params={'I_e': I_e0 + I_E}) # Set I_e I_e = my_nest.GetStatus(SNR.ids, 'I_e')[0] I_vec, fIsi, mIsi, lIsi = SNR.IF(I_vec, tStim=tStim) speed_f = numpy.diff(1000.0 / fIsi) / numpy.diff(I_vec) speed_l = numpy.diff(1000.0 / lIsi) / numpy.diff(I_vec) speed_f = speed_f[speed_f > 0] speed_l = speed_l[speed_l > 0] s = '\n' s = s + 'IF:\n' s = s + ' %s %5s %3s \n' % ('First to Last ISI:', tStim, 'ms') s = s + ' %s %5s %3s \n' % ('Added I_e:', I_e, 'pA') s = s + ' %s %4s %s %4s %s %4s\n' % ( 'Speed first ((Hz/pA), min:', str(min(speed_f))[0:4], 'max', str(max(speed_f))[0:4], 'mean', str(sum(speed_f) / len(speed_f))[0:4]) s = s + ' %s %4s %s %4s %s %4s\n' % ( 'Speed last (Hz/pA), min:', str(min(speed_l))[0:4], 'max', str(max(speed_l))[0:4], 'mean', str(sum(speed_l) / len(speed_l))[0:4]) infoString = s return I_vec, fIsi, mIsi, lIsi, infoString
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 simulate_ahp(I_vec): simTime = 3000. # ms my_nest.ResetKernel() model_list, model_dict = models() my_nest.MyLoadModels(model_list, NEURON_MODELS) n = len(I_vec) STN = MyGroup(NEURON_MODELS[0], n, sd=True, mm=True, mm_dt=1.0) I_e0 = my_nest.GetStatus(STN[:])[0]['I_e'] #my_nest.SetStatus(STN[:], params={'I_e':-10.}) # Set I_e my_nest.SetStatus(STN[:], params={'I_e': 1.0}) # 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': [500., 1000.], 'amplitude_values': [float(I), 0.] }) my_nest.Connect([source], [target], params={'receptor_type': rec['CURR']}) my_nest.MySimulate(simTime) STN.get_signal('s') # retrieve signal STN.signals['spikes'] = STN.signals['spikes'].time_slice(700, 2000) delays = [] for i, curr in enumerate(I_vec): delays.append( max( numpy.diff( STN.signals['spikes'].spiketrains[i + 1.0].spike_times))) 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 I_vec, delays
def plot_text(ax, infoString=''): my_nest.ResetKernel() model_list = models() my_nest.MyLoadModels(model_list, neuronModels) SNR = MyGroup(neuronModels[0], 1, mm_dt=0.1) statusSNR = my_nest.GetStatus(SNR[:])[0] tb = '' tb = tb + ' %s %10s\n' % ('Neuron model', statusSNR['model']) tb = tb + infoString tb = tb + '\n' 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 plot_text(ax, infoString=''): my_nest.ResetKernel() model_list, model_dict = models() my_nest.MyLoadModels(model_list, NEURON_MODELS) SNR = MyGroup(NEURON_MODELS[0], 1, mm_dt=0.1) statusSNR = my_nest.GetStatus(SNR[:])[0] tb = '' tb = tb + infoString tb = tb + '\n' for key, val in statusSNR.iteritems(): if not key in [ 'vp', 'state', 't_spike', 'local', 'parent', 'Delta_T', 'tau_minus_triplet', 'address', 't_ref', 'thread', 'frozen', 'archiver_length', 'global_id', 'local_id', 'recordables', 'receptor_types' ]: tb = tb + ' %s %5s %3s \n' % (key + ':', str(val), '--') 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 plot_text(ax, info_string=''): my_nest.ResetKernel() MODEL_LIST = models() my_nest.MyLoadModels(MODEL_LIST, NEURON_MODELS) SNR = MyGroup(NEURON_MODELS[0], 1, mm_dt=0.1) statusSNR = my_nest.GetStatus(SNR[:])[0] tb = '' tb = tb + info_string tb = tb + '\n' 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_rebound_spike(I_vec): simTime = 5000. # ms my_nest.ResetKernel() model_list, model_dict=models() my_nest.MyLoadModels( model_list, NEURON_MODELS ) n=len(I_vec) GPE = MyGroup( NEURON_MODELS[0], n, sd=True, mm=True, mm_dt = 1.0 ) I_e0=my_nest.GetStatus(GPE[:])[0]['I_e'] #my_nest.SetStatus(GPE[:], params={'I_e':-10.}) # Set I_e my_nest.SetStatus(GPE[:], params={'I_e':-10.}) # Set I_e I_e = my_nest.GetStatus(GPE.ids,'I_e')[0] scg = my_nest.Create( 'step_current_generator',n=n ) rec=my_nest.GetStatus(GPE[:])[0]['receptor_types'] for source, target, I in zip(scg, GPE[:], I_vec): my_nest.SetStatus([source], {'amplitude_times':[500.,700.], 'amplitude_values':[float(I),0.]}) my_nest.Connect( [source], [target], params = { 'receptor_type' : rec['CURR'] } ) my_nest.MySimulate(simTime) GPE.get_signal( 'v','V_m', stop=simTime ) # retrieve signal GPE.get_signal( 's') # retrieve signal GPE.signals['V_m'].my_set_spike_peak( 21, spkSignal= GPE.signals['spikes'] ) meanRate=round(GPE.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 GPE, infoString
def create_output_population(nOutput, outputAddCurrent, outputName, sname, spath): create_models(outputName) Output = MyGroup(outputName, nOutput, mm_dt=1.0, sname=sname, spath=spath) I_e = my_nest.GetStatus(Output.local_ids, 'I_e')[0] # add output current my_nest.SetStatus(Output[:], {'I_e': I_e + outputAddCurrent}) return Output
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) 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 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 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_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
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, tb,
def simulate_example_irregular_firing(I_vec=[0]): simTime = 2000. # ms my_nest.ResetKernel() model_list, model_dict=models() my_nest.MyLoadModels( model_list, NEURON_MODELS ) n=len(I_vec) GPE = MyGroup( NEURON_MODELS[0], n, sd=True, mm=True, mm_dt = 1.0 ) I_e=I_vec[0] my_nest.SetStatus(GPE[:], params={'I_e':I_e}) # Set I_e scg = my_nest.Create( 'step_current_generator',n=n ) noise=my_nest.Create('noise_generator', params={'mean':0.,'std':10.}) rec=my_nest.GetStatus(GPE[:])[0]['receptor_types'] for source, target, I in zip(scg, GPE[:], I_vec): #I=5. my_nest.SetStatus([source], {'amplitude_times':[1., simTime], 'amplitude_values':[-5.,float(I)]}) my_nest.Connect( [source], [target], params = { 'receptor_type' : rec['CURR'] } ) my_nest.Connect( noise, [target], params = { 'receptor_type' : rec['CURR'] } ) my_nest.MySimulate(simTime) GPE.get_signal( 'v','V_m', stop=simTime ) # retrieve signal GPE.get_signal( 's') # retrieve signal GPE.signals['V_m'].my_set_spike_peak( 15, spkSignal= GPE.signals['spikes'] ) #a=GPE.signals['V_m'].analog_signals[1].signal #pylab.plot(a) # #a=a[500:] # pylab.subplot(211).plot(a, 'r') #pylab.show() # # a=a # a=a-numpy.mean(a) # # numpy.savetxt("foo.csv", a, delimiter=",") # # ff=numpy.abs(numpy.fft.fft(a)) # #pylab.plot(ff) # c=numpy.correlate(a, a, mode='full') # pylab.subplot(212).plot(c) # pylab.show() meanRate=round(GPE.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 GPE, infoString
#fig = pylab.figure( figsize = ( 20, 7 ), dpi = 50, facecolor = 'w' ) ax_list = [] ax_list.append(pylab.axes([.05, .37, .08, .43])) # text box ax_list.append(pylab.axes([.27, .72, .28, .08])) # conductance ax_list.append(pylab.axes([.27, .47, .28, .08])) # conductance ax_list.append(pylab.axes([.27, .2, .28, .08])) # conductance ax_list.append(pylab.axes([.69, .2, .28, .6])) # p1/p# ax = ax_list[0] # Text box tb = '' tb = tb + ' %s %5s %3s \n' % ('plastic w:', str(plastic_w), 'pS') tb = tb + '\n ' tb = tb + ' %s %5s %3s \n' % ( 'E rev:', str(my_nest.GetStatus(SNR.ids, 'GABAA_1_E_rev')[0]), 'mV') tb = tb + ' %s %5s %3s \n' % ( 'Tau_decay:', str(my_nest.GetStatus(SNR.ids, 'GABAA_1_Tau_decay')[0]), 'mV') tb = tb + '\n ' tb = tb + ' %s %5s %3s \n' % ('U:', str(my_nest.GetDefaults(syn)['U']), ' ') tb = tb + ' %s %5s %3s \n' % ('tau_fac:', str(my_nest.GetDefaults(syn)['tau_fac']), 'ms') tb = tb + ' %s %5s %3s \n' % ('tau_rec:', str(my_nest.GetDefaults(syn)['tau_rec']), 'ms') tb = tb + ' %s %5s %3s \n' % ('tau_psc:', str(my_nest.GetDefaults(syn)['tau_psc']), 'ms') tb = tb + '\n ' tb = tb + ' %s %5s %3s \n' % ('recovery spike 1:', str(rec1), 'ms') tb = tb + ' %s %5s %3s \n' % ('recovery spike 2:', str(rec2), 'ms') tb = tb + '\n '
neuron_list = [] for i, model in enumerate(neuron_models): my_nest.MyLoadModels(model_dict, [model]) I_in_vitro = my_nest.GetDefaults(model)['I_e'] neuron = MyGroup(model, n=n, sd=True, mm_dt=.1, mm=False) for id in neuron.ids: I = numpy.random.normal(I_in_vitro, I_in_vitro * norm_std[i] * mrs[i]) my_nest.SetStatus([id], {'I_e': I}) neuron_list.append(neuron) noise = my_nest.Create('noise_generator', params={ 'mean': 0., 'std': 1. }) rec = my_nest.GetStatus(neuron[:])[0]['receptor_types'] for id in neuron.ids: my_nest.Connect(noise, [id], params={'receptor_type': rec['CURR']}) my_nest.MySimulate(sim_time) mr_list = [] for neuron in neuron_list: neuron.get_signal('s', start=0, stop=sim_time) signal = neuron.signals['spikes'] mr = numpy.mean(signal.spike_histogram(time_bin=1, normalized=True), axis=1) mr_list.append(mr) misc.pickle_save(mr_list, save_result_at)