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