def simulate_response_example_clamped_spiking(I_e):
'''
Response when SNR is clamped to a voltage for strong and weak synapse
'''
spike_at = 500. # ms
simTime = 700. # ms
my_nest.ResetKernel()
model_list = models()
my_nest.MyLoadModels(model_list, NEURON_MODELS)
my_nest.MyLoadModels(model_list, SYNAPES_MODELS)
SNR = MyGroup(NEURON_MODELS[0],
len(SYNAPES_MODELS) + 1,
mm=True,
mm_dt=0.1,
params={'I_e': I_e})
SG = my_nest.Create('spike_generator', params={'spike_times': [spike_at]})
for i in range(len(SYNAPES_MODELS)):
my_nest.Connect(SG, [SNR[i]], model=SYNAPES_MODELS[i])
my_nest.MySimulate(simTime)
SNR.get_signal('v', 'V_m', stop=simTime) # retrieve signal
SNR.signals['V_m'] = SNR.signals['V_m'].my_time_slice(500, 560)
return SNR
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 simulate_voltage_ipsp(I_vec):
simTime = 700. # ms
spikes_at = numpy.arange(500., len(I_vec) * simTime, simTime) # ms
voltage = [] # mV
ipsp_weak = [] # mV
ipsp_strong = [] # mV
my_nest.ResetKernel()
model_list = models()
my_nest.MyLoadModels(model_list, NEURON_MODELS)
my_nest.MyLoadModels(model_list, SYNAPES_MODELS)
SNR = MyGroup(NEURON_MODELS[0], len(SYNAPES_MODELS), mm=True, mm_dt=0.1)
SG = my_nest.Create('spike_generator', params={'spike_times': spikes_at})
for i in range(len(SYNAPES_MODELS)):
my_nest.Connect(SG, [SNR[i]], model=SYNAPES_MODELS[i])
simTimeTot = 0
for I_e in I_vec:
my_nest.SetStatus(SNR[:], params={'I_e': float(I_e)})
my_nest.MySimulate(simTime)
simTimeTot += simTime
SNR.get_signal('v', 'V_m', stop=simTimeTot) # retrieve signal
simTimeAcum = 0
for I_e in I_vec:
signal = SNR.signals['V_m'].my_time_slice(400 + simTimeAcum,
700 + simTimeAcum)
simTimeAcum += simTime
clamped_at = signal[1].signal[-1]
minV = min(signal[1].signal)
maxV = max(signal[1].signal)
if abs(minV - clamped_at) < abs(maxV - clamped_at):
size_weak = max(signal[1].signal) - clamped_at
size_strong = max(signal[2].signal) - clamped_at
else:
size_weak = min(signal[1].signal) - clamped_at
size_strong = min(signal[2].signal) - clamped_at
voltage.append(clamped_at)
ipsp_weak.append(size_weak)
ipsp_strong.append(size_strong)
ipsp = numpy.array([ipsp_weak, ipsp_strong])
return voltage, ipsp
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 simulate_response_example_clamped_silent(I_e):
'''
Response when SNR is clamped to a voltage for Ref 2 and Ref 1 synapse
'''
spike_at = 500. # ms
simTime = 700. # ms
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],
len(SYNAPSE_MODELS),
mm=True,
mm_dt=0.1,
params={'I_e': I_e})
SG = my_nest.Create('spike_generator', params={'spike_times': [spike_at]})
for i in range(len(SYNAPSE_MODELS)):
my_nest.Connect(SG, [SNR[i]], model=SYNAPSE_MODELS[i])
my_nest.MySimulate(simTime)
SNR.get_signal('v', 'V_m', stop=simTime) # retrieve signal
SNR.signals['V_m'] = SNR.signals['V_m'].my_time_slice(400, 700)
clamped_at = SNR.signals['V_m'][1].signal[-1]
size_MSN_weak = min(SNR.signals['V_m'][1].signal) - clamped_at
size_MSN_strong = min(SNR.signals['V_m'][2].signal) - clamped_at
size_GPE_ref = min(SNR.signals['V_m'][3].signal) - clamped_at
s = ''
s = s + ' %s %5s %3s \n' % ('Clamped at:', str(round(clamped_at, 1)), 'mV')
s = s + ' %s %5s %3s \n' % (r'$\delta_w^{MSN}$',
str(round(size_MSN_weak, 1)), 'mV')
s = s + ' %s %5s %3s \n' % (r'$\delta_s^{MSN}$',
str(round(size_MSN_strong, 1)), 'mV')
s = s + ' %s %5s %3s \n' % (r'$\delta_s^{MSN}$', str(round(
size_GPE_ref, 1)), 'mV')
infoString = s
return SNR, infoString
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
my_nest.ResetKernel()
model_list = models() # Get model list
for model in model_list:
my_nest.CopyModel(model[0], model[1], model[2]) # Create models
neuron_model = 'MSN_izh'
MSN = MyGroup(neuron_model, 3, mm_dt=0.1)
#! Spike train experiment 1. Train of 8 spikes at 20 Hz and the recovery spike
#! at 550 ms as in Planert 2009
spike_times = range(10, 430, 50)
spike_times.extend([430 + 550])
# input
sgs = my_nest.Create('spike_generator',
params={'spike_times': [float(sp) for sp in spike_times]})
syn_model = 'MSN_MSN_gaba_s'
my_nest.Connect(sgs, [MSN[0]], model=syn_model) # connect MSNs
T = 2000 # simulation time
my_nest.Simulate(T) # simulate
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')
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_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
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_selection_vs_neurons(selRateInterval=[0.0, 500.0], hz=20):
sname_nb = hz
nGPE = 500
nExp = 5
if hz > 7:
nMaxSelected = 60
else:
nMaxSelected = 100
baseRate = 0.1
selectionRate = hz
I_e = -5.
simTime = 3500.
model_list = models()
selectionTime = 3000.
selectionOnset = 500.
expParams = []
expIntervals = []
iSNR = 0
for syn in SYNAPSE_MODELS:
for iSel in range(nMaxSelected):
expIntervals.append([iSNR, iSNR + nExp])
for iExp in range(nExp):
expParams.append((syn, iSel, iExp, iSNR))
iSNR += 1
synIntervals = []
iSNR = 0
for syn in SYNAPSE_MODELS:
synIntervals.append([iSNR, iSNR + nMaxSelected])
iSNR += nMaxSelected
my_nest.ResetKernel()
my_nest.MyLoadModels(model_list, NEURONMODELS)
my_nest.MyLoadModels(model_list, SYNAPSE_MODELS)
SNR = MyGroup(NEURONMODELS[0],
n=len(expParams),
params={'I_e': I_e},
mm_dt=.1,
record_from=[''],
spath=SPATH,
sname_nb=sname_nb)
sourceBack = []
sourceSel = []
for iExp in range(nExp):
# Background
tmpSourceBack = []
for iGPE in range(nGPE - 1):
spikeTimes = misc.inh_poisson_spikes([baseRate], [1],
t_stop=simTime,
n_rep=nExp,
seed=iGPE + 10 * iExp)
if any(spikeTimes):
tmpSourceBack.extend(
my_nest.Create('spike_generator',
params={'spike_times': spikeTimes}))
sourceBack.append(tmpSourceBack)
if not LOAD:
for syn, iSel, iExp, iSNR in expParams:
print 'Connect SNR ' + str(SNR[iSNR]) + ' ' + syn
target = SNR[iSNR]
my_nest.ConvergentConnect(sourceBack[iExp][0:nGPE - iSel],
[target],
model=syn)
my_nest.ConvergentConnect(sourceSel[iExp][0:iSel + 1], [target],
model=syn)
my_nest.MySimulate(simTime)
SNR.save_signal('s')
SNR.get_signal('s') # retrieve signal
#SNR.get_signal( 'v','V_m' ) # retrieve signal
#SNR.signals['V_m'].plot()
#SNR.signals['spikes'].raster_plot()
#pylab.show()
if LOAD:
SNR.load_signal('s')
#SNR.get_signal( 'v','V_m', stop=simTime ) # retrieve signal
#SNR.signals['V_m'].plot(id_list=[5])
#SNR.['spikes'].raster_plot()
#pylab.show()
t1 = selRateInterval[0]
t2 = selRateInterval[1]
tmpMeanRates1 = []
tmpMeanRates2 = []
tmpMeanRates3 = []
tmpMeanRates4 = []
tmpMeanRates1 = SNR.signals['spikes'].mean_rates(selectionOnset + t1,
selectionOnset + t2)
for interval in expIntervals:
tmpMeanRates3.append(
numpy.mean(tmpMeanRates1[interval[0]:interval[1]], axis=0))
for interval in synIntervals:
tmpMeanRates4.append(tmpMeanRates3[interval[0]:interval[1]])
meanRates = numpy.array(tmpMeanRates4)
nbNeurons = numpy.arange(1, nMaxSelected + 1, 1)
s = '\n'
s = s + ' %s %5s %3s \n' % ('N GPEs:', str(nGPE), '#')
s = s + ' %s %5s %3s \n' % ('N experiments:', str(nExp), '#')
s = s + ' %s %5s %3s \n' % ('Base rate:', str(baseRate), 'Hz')
s = s + ' %s %5s %3s \n' % ('Selection rate:', str(selectionRate), 'Hz')
s = s + ' %s %5s %3s \n' % ('Selection time:', str(selectionTime), 'ms')
s = s + ' %s %5s %3s \n' % ('I_e:', str(I_e), 'pA')
infoString = s
return nbNeurons, meanRates, infoString
#! Train at 3, 10, 50 and 100 Hz and then a recovery spike at
keys = ['10 Hz', '50 hz', '100 hz'] # stimulation frequencies
nb_spikes = [50., 50., 50.] # number of spikes for each stimulation
shift = 50. # first spike
spikes = {} # store spike time lists
sg = {} # store spike generators
rec1, rec2 = 500, 1500
for key, nb in zip(keys, nb_spikes):
hz = float(key.split()[0])
spikes[key] = numpy.linspace(shift, shift + nb * 1000 / hz,
nb + 1) # create frequency train
rec_spk = numpy.array([rec1, rec2]) + max(spikes[key])
spikes[key] = numpy.append(spikes[key], rec_spk)
sg[key] = my_nest.Create('spike_generator',
params={'spike_times': spikes[key]})
#! Connections
#! ===========
for i, key in enumerate(keys):
my_nest.Connect(sg[key], [SNR.ids[i]], params={'weight': 1.}, model=syn)
#! Simulate
#! ========
T = int(spikes[keys[0]][-1] + 2000) # simulation time
my_nest.Simulate(T) # simulate
#! Plot
#! ====
SNR.get_signal('v', 'g_GABAA_1', stop=T) # retrieve signal
def simulate_example_msn_snr():
nFun=0 # Function number
nSim=0 # Simulation number within function
rates=numpy.array([.1,.1])
times=numpy.array([0.,25000.])
nMSN =500
simTime=100000.
I_e=0.
my_nest.ResetKernel()
model_list=models()
my_nest.MyLoadModels( model_list, neuronModels )
my_nest.MyLoadModels( model_list, synapseModels )
MSN = MyGroup( 'spike_generator', nMSN, mm_dt=1.0, mm=False, sd=False,
spath=spath,
sname_nb=str(nFun)+str(nSim))
SNR = MyGroup( neuronModels[0], n=len(synapseModels), params={'I_e':I_e},
sd=True,
mm_dt = .1, mm=False, spath=spath,
sname_nb=str(nFun)+str(nSim) )
nSim+=1
spikeTimes=[]
for i in range(nMSN):
spikes=misc.inh_poisson_spikes( rates, times,
t_stop=simTime,
n_rep=1, seed=i )
my_nest.SetStatus([MSN[i]], params={ 'spike_times':spikes } )
for spk in spikes: spikeTimes.append((i,spk))
# add spike list for MSN to MSN spike list
MSN.signals['spikes'] = my_signals.MySpikeList(spikeTimes, MSN.ids)
MSN.save_signal( 's')
noise=my_nest.Create('noise_generator', params={'std':100.})
my_nest.Connect(noise,[SNR[0]],params={'receptor_type':5})
my_nest.Connect(noise,[SNR[1]],params={'receptor_type':5})
my_nest.Connect(noise,[SNR[2]],params={'receptor_type':5})
for i, syn in enumerate(synapseModels):
my_nest.ConvergentConnect(MSN[:],[SNR[i]], model=syn)
my_nest.MySimulate( simTime )
SNR.get_signal( 's' ) # retrieve signal
SNR_rates=[SNR.signals['spikes'].mean_rates(0,5000),
SNR.signals['spikes'].mean_rates(5000, 10000)]
for i in range(0, len(SNR_rates)):
for j in range(0, len(SNR_rates[0])):
SNR_rates[i][j]=int(SNR_rates[i][j])
s='\n'
s =s + 'Example plot MSN and SNr:\n'
s =s + 'Synapse models:\n'
for syn in synapseModels:
s = s + ' %s\n' % (syn )
s = s + ' %s %5s %3s \n' % ( 'N MSN:', str ( nMSN ), '#' )
s = s + ' %s %5s %3s \n' % ( 'MSN Rates:', str ( [str(round(r,1))
for r in rates]),'Hz' )
s = s + ' %s %5s %3s \n' % ( '\nSNR Rates 0-5000:\n',
str ( SNR_rates [0]) ,'Hz' )
s = s + ' %s %5s %3s \n' % ( '\nSNR Rates 10000-5000:\n',
str ( SNR_rates [1]) ,'Hz' )
s = s + ' %s %5s %3s \n' % ( '\nTimes:', str ( times), 'ms' )
s = s + ' %s %5s %3s \n' % ( 'I_e:', str ( I_e ), 'pA' )
infoString=s
return MSN, SNR, infoString
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_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
save_result_at = OUTPUT_PATH + '/simulate.plk'
if 0:
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)
