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)
