def get():
l=[];
p={'equal':{},
'mul':{}}#
for w1, w2 in [
[1., .0],
[.8, .2],
[.6, .4],
[.5, .5],
[.4, .6],
[.2, .8],
[.0, 1.],
]:
d={}
d=misc.dict_update(p['mul'], d)
l+=[pl(d, '*', **{'name':''})]
d={'nest':{
'GA_FS_gaba':{'weight':w1},
'GF_FS_gaba':{'weight':w2}
}}
d=misc.dict_update(p['equal'], d)
s='GA_{0}_GF_{1}'.format( w1, w2 )
l[-1]+=pl(d, '=', **{'name':s})
return l
def get():
l = []
solution, s_mul, s_equal = get_solution()
# Decrease/increase C1,C2,CF,CS, EI and EA. Test idea that at
# slow wave cortical and thalamic input is decreased.
mod = numpy.arange(0.5, 1.5, 0.05)
for x in mod:
d = {}
for keys in s_mul:
update(solution, d, keys)
misc.dict_update(d, {'node': {'CF': {'rate': x}}})
misc.dict_update(d, {'node': {'CS': {'rate': x}}})
l += [pl(d, '*', **{'name': ''})]
d = {}
for keys in s_equal:
update(solution, d, keys)
d['node']['C1']['rate'] *= x
d['node']['C2']['rate'] *= x
d['node']['EI']['rate'] *= x
d['node']['EA']['rate'] *= x
l[-1] += pl(d, '=', **{'name': 'mod_C1_C2_CF_CS_EI_EA_' + str(x)})
return l
def get():
l=[]
solution, s_mul, s_equal=get_solution()
# Decrease/increase C1,C2,CF,CS, EI and EA. Test idea that at
# slow wave cortical and thalamic input is decreased.
mod=numpy.arange(0.5, 1.5, 0.05)
for x in mod:
d={}
for keys in s_mul: update(solution, d, keys)
misc.dict_update(d, {'node':{'CF':{'rate':x}}} )
misc.dict_update(d, {'node':{'CS':{'rate':x}}} )
l+=[pl(d, '*', **{'name':''})]
d={}
for keys in s_equal: update(solution, d, keys)
d['node']['C1']['rate']*=x
d['node']['C2']['rate']*=x
d['node']['EI']['rate']*=x
d['node']['EA']['rate']*=x
l[-1]+=pl(d, '=', **{'name':'mod_C1_C2_CF_CS_EI_EA_'+str(x)})
return l
def gather(path, **kw):
tuning_key=kw.get('tuning_freq_amp_to')
fs=os.listdir(path)
d={}
for name in sorted(fs):
if name[-4:]!='.pkl':
continue
file_name=path+name[:-4]
sd = Storage_dic.load(file_name)
dd=sd.load_dic(*['Net_0', tuning_key,'mean_rate_slices'])
d = misc.dict_update(d, {name[:-4]:dd['Net_0']})
# ax=pylab.subplot(211)
if d=={}:
i=0
for name in sorted(fs):
if name[0:6]!='script':
continue
# i+=1
# ax=pylab.subplot(5,6,i)
file_name=path+name+'/'+'Net_0'
sd = Storage_dic.load(file_name)
dd=sd.load_dic(*['Net_0', tuning_key,'mean_rate_slices', 'firing_rate'])
print file_name
pp(dd)
# ax.plot(dd['Net_0']['M1']['firing_rate'].y)
# ax.text(0.1,0.1,name, transform=ax.transAxes, fontsize=7)
d = misc.dict_update(d, {name:dd['Net_0']})
# pylab.show()
return d
def par(self):
d={'simu':{
'print_time':False,
'start_rec':1000.0
},
# 'netw':{'rand_nodes':{'C_m':True,
# 'V_th':True,
# 'V_m':True}}
}
misc.dict_update(d,self.target_perturbations()[self.tp_name])
return d
def simulate_irregular_firing(**kw):
n=len(kw.get('irf_curr'))
I_vec=numpy.array(kw.get('irf_curr'))
simTime = 2000. # ms
my_nest.ResetKernel({'local_num_threads':1})
sd={'active':True, 'params':{'to_memory':True,'to_file':False}}
mm={'active':True,'params':{'interval':0.1,'to_memory':True,'to_file':False}}
p=kw.get('rs_params')
if 'type_id' in p.keys(): del p['type_id']
mnn=MyNetworkNode('dummy',model=kw.get('model'), n=n, params=p, mm=mm, sd=sd)
I_e0 = my_nest.GetStatus(mnn.ids,'I_e')[0]
for i, I_e in enumerate(I_vec):
my_nest.SetStatus([mnn[i]], params={'I_e':I_e+I_e0})
scg = my_nest.Create( 'step_current_generator',n=n )
noise=my_nest.Create('noise_generator', params={'mean':0.,'std':10.})
rec=my_nest.GetStatus(mnn[:])[0]['receptor_types']
for source, target, I in zip(scg, mnn[:], I_vec):
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)
mnn.voltage_signal.my_set_spike_peak( 21, spkSignal= mnn.spike_signal )
d={}
for i in range(n):
voltage=mnn.voltage_signal.analog_signals[i+1].signal
x=numpy.linspace(0,simTime, len(voltage))
dg=Data_generic(**{'x':x, 'y':voltage, 'xlabel':'Time (ms)', 'ylabel':'Voltage (mV)'})
misc.dict_update(d, {'irf_voltage_{0}'.format(i):dg})
# my_nest.MySimulate(simTime)
# mnn.get_signal( 'v','V_m', stop=simTime ) # retrieve signal
# mnn.get_signal( 's') # retrieve signal
# mnn.signals['V_m'].my_set_spike_peak( 15, spkSignal= mnn.signals['spikes'] )
return d
def simulate(from_disk=0,
kw={},
net='Net_0',
script_name=__file__.split('/')[-1][0:-3],
setup=Setup(50,20) ):
setup=Setup(50,20)
file_name = kw.get('file_name', dr.HOME_DATA+'/'+script_name)
file_name_figs = kw.get('file_name_figs', dr.HOME_DATA+'/fig/'+script_name)
sd=get_storage_list([net], file_name, '')[0]
d={}
if from_disk==0:
print net
dd={net:simulate_network(**kw)}
dd=compute_attrs(dd, net, setup)
save(sd, dd)
if from_disk==1:
filt= [net]+['gi','st', 'gi_st']+['spike_signal']
dd = load(sd, *filt)
pp(dd)
dd=compute_attrs(dd, net, setup)
save(sd, dd)
elif from_disk==2:
filt = [net]+['gi','st', 'gi_st']+['firing_rate', 'phases_diff_with_cohere']
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
return d, file_name_figs
def create_mm(self, name, d_add, **kw):
model = name + '_multimeter'
if model not in my_nest.Models():
my_nest.CopyModel('multimeter', model)
d = {
'active': False,
'id': [],
'model': name + '_multimeter',
'params': {
'record_from': ['V_m'],
'start': 0.0,
'stop': numpy.inf,
'interval': 1.,
'to_file': False,
'to_memory': True
}
} # recodring interval (dt)
d = misc.dict_update(d, d_add)
if d['active']:
_id = my_nest.Create(model, params=d['params'])
if 'slice' in kw.keys():
my_nest.DivergentConnect(_id, self.ids[kw['slice']])
else:
my_nest.DivergentConnect(_id, self.ids)
d.update({'id': _id, 'model': model})
return d
def get_perturbation_dics(c, w_rel):
d = {}
for key in c.keys():
for conn in c[key]:
u = {key:{'nest':{conn:{'weight':w_rel}}}}
d = misc.dict_update(d, u)
return d
def simulate(from_disk=0,
kw={},
net='Net_0',
script_name=__file__.split('/')[-1][0:-3],
setup=Setup(50, 20)):
setup = Setup(50, 20)
file_name = kw.get('file_name', dr.HOME_DATA + '/' + script_name)
file_name_figs = kw.get('file_name_figs',
dr.HOME_DATA + '/fig/' + script_name)
sd = get_storage_list([net], file_name, '')[0]
d = {}
if from_disk == 0:
print net
dd = {net: simulate_network(**kw)}
dd = compute_attrs(dd, net, setup)
save(sd, dd)
if from_disk == 1:
filt = [net] + ['gi', 'st', 'gi_st'] + ['spike_signal']
dd = load(sd, *filt)
pp(dd)
dd = compute_attrs(dd, net, setup)
save(sd, dd)
elif from_disk == 2:
filt = [net] + ['gi', 'st', 'gi_st'
] + ['firing_rate', 'phases_diff_with_cohere']
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
return d, file_name_figs
def get_perturbation_dics(c, w_rel):
d = {}
for key in c.keys():
for conn in c[key]:
u = {key: {'nest': {conn: {'weight': w_rel}}}}
d = misc.dict_update(d, u)
return d
def get():
l=[]
d={}
for name in ['M1', 'CTX_M1', 'CTX_M2', 'MS_MS', 'FS_FS',
'GP_FS', 'FS_M2', 'M2_GI', 'FS',
'GA_MS', 'GA_FS', 'GI_FS']:
d=misc.dict_update(d, get_change_to(name))
l+=[pl(d,'*', **{'name':'no_ch_dop-striatum'})]
d={}
for name in ['CTX_ST', 'GP_ST', 'GP', 'ST_GP', 'GP_GP', 'SN', 'M1_SN']:
d=misc.dict_update(d, get_change_to(name))
l+=[pl(d,'*', **{'name':'no_ch_dop-GP_ST_SN'})]
d={}
for name in ['M1', 'CTX_M1', 'CTX_M2', 'MS_MS', 'FS_FS',
'GP_FS', 'FS_M2', 'CTX_ST', 'GP_ST', 'GP',
'ST_GP', 'GP_GP', 'SN', 'M1_SN',
'M2_GI', 'FS',
'GA_MS', 'GA_FS', 'GI_FS']:
d=misc.dict_update(d, get_change_to(name))
pp(d)
l+=[pl(d,'*', **{'name':'no_ch_dop-all'})]
for s in [ 'CTX_M1', 'CTX_M2', 'MS_MS', 'FS_FS',
'GP_FS', 'FS_M2', 'CTX_ST', 'GP_ST', 'GP',
'ST_GP', 'GP_GP', 'SN', 'M1_SN', 'M2_GI',
'FS','M1',
'GA_MS', 'GA_FS', 'GI_FS']:
d={}
for name in [s]:
d=misc.dict_update(d, get_change_to(name))
l+=[pl(d,'*', **{'name':'no_ch-'+s})]
d={}
l+=[pl(d,'*', **{'name':'-Normal'})]
return l
def get_perturbation_dics(val, hz_mod, i):
d = {}
# for key in c.keys():
for neuron, hz_pA in val:
hz = hz_mod[neuron][i]
u = {key: {'node': {neuron: {'I_vivo': 1. / hz_pA * hz}}}}
d = misc.dict_update(d, u)
return d
def get_perturbation_dics(val, hz_mod, i):
d = {}
# for key in c.keys():
for neuron, hz_pA in val:
hz=hz_mod[neuron][i]
u = {key:{'node':{neuron:{'I_vivo':1./hz_pA*hz}}}}
d = misc.dict_update(d, u)
return d
def get():
l = []
d = {}
for name in [
'M1', 'CTX_M1', 'CTX_M2', 'MS_MS', 'FS_FS', 'GP_FS', 'FS_M2',
'M2_GI', 'FS'
]:
d = misc.dict_update(d, get_change_to(name))
l += [pl(d, '*', **{'name': 'no_ch_dop-striatum'})]
d = {}
for name in ['CTX_ST', 'GP_ST', 'GP', 'ST_GP', 'GP_GP', 'SN', 'M1_SN']:
d = misc.dict_update(d, get_change_to(name))
l += [pl(d, '*', **{'name': 'no_ch_dop-GP_ST_SN'})]
d = {}
for name in [
'M1', 'CTX_M1', 'CTX_M2', 'MS_MS', 'FS_FS', 'GP_FS', 'FS_M2',
'CTX_ST', 'GP_ST', 'GP', 'ST_GP', 'GP_GP', 'SN', 'M1_SN', 'M2_GI',
'FS'
]:
d = misc.dict_update(d, get_change_to(name))
pp(d)
l += [pl(d, '*', **{'name': 'no_ch_dop-all'})]
for s in [
'M1', 'CTX_M1', 'CTX_M2', 'MS_MS', 'FS_FS', 'GP_FS', 'FS_M2',
'CTX_ST', 'GP_ST', 'GP', 'ST_GP', 'GP_GP', 'SN', 'M1_SN', 'M2_GI',
'FS'
]:
d = {}
for name in [s]:
d = misc.dict_update(d, get_change_to(name))
l += [pl(d, '*', **{'name': 'no_ch-' + s})]
d = {}
l += [pl(d, '*', **{'name': '-Normal'})]
return l
def simulate(builder, from_disk, perturbation_list, script_name, setup):
home = expanduser("~")
# file_name = get_file_name(script_name, home)
# file_name_figs = get_file_name_figs(script_name, home)
#
d_firing_rate = setup.firing_rate()
attr = ['firing_rate', 'mean_rate_slices']
attr_conn=['conn_matrix']
models=['M1', 'M2']
models_conn=['M1_M1_gaba', 'M1_M2_gaba',
'M2_M1_gaba', 'M2_M2_gaba']
sets = ['set_0']
info, nets, intervals, rep, x = get_networks(builder,
**setup.builder())
key=nets.keys()[0]
file_name = get_file_name(script_name, nets[key].par)
file_name_figs = get_file_name_figs(script_name, nets[key].par)
path_nest=get_path_nest(script_name, nets.keys(), nets[key].par)
for net in nets.values():
net.set_path_nest(path_nest)
kwargs_dic = {'firing_rate':d_firing_rate,
'mean_rate_slices': {'intervals':intervals[1],
'repetition':rep,
'set_0':{'x':x},
'sets':[0]}}
# add_perturbations(perturbation_list, nets)
# sd = get_storage(file_name, info)
#
# # _, d1 = main_loop_conn(from_disk, attr_conn, models_conn,
# # sets, nets, kwargs_dic, sd)
d1={}
# from_disks, d2 = main_loop(from_disk, attr, models,
# sets, nets, kwargs_dic, sd)
#
add_perturbations(perturbation_list, nets)
# Adding nets no file name
sd_list=get_storage_list(nets, file_name, info)
from_disks, d2 = main_loop(from_disk, attr, models,
sets, nets, kwargs_dic, sd_list)
d=misc.dict_update(d1,d2)
if from_disk==2:
d=cmp_mean_rate_diff(d, models, [['Net_0', 'Net_5'],
['Net_1', 'Net_6'],
['Net_2', 'Net_7'],
['Net_3', 'Net_8'],
['Net_4', 'Net_9']], x)
return file_name, file_name_figs, from_disks, d, models
def simulate_rebound_spike(**kw):
n=len(kw.get('rs_curr'))
simTime = 3000. # ms
my_nest.ResetKernel({'local_num_threads':1})
sd={'active':True, 'params':{'to_memory':True,'to_file':False}}
mm={'active':True,
'params':{'interval':0.1,'to_memory':True,'to_file':False}}
p=kw.get('rs_params')
if 'type_id' in p.keys(): del p['type_id']
mnn=MyNetworkNode('dummy',model=kw.get('model'), n=n, params=p, mm=mm, sd=sd)
my_nest.SetStatus(mnn[:], params={'I_e':kw.get('rs_I_e')}) # Set I_e
# my_nest.SetStatus(mnn[:], params={'I_e':.5}) # Set I_e
# I_e = my_nest.GetStatus(mnn.ids,'I_e')[0]
scg = my_nest.Create( 'step_current_generator',n=n )
rec=my_nest.GetStatus(mnn[:])[0]['receptor_types']
i=0
for t, c in zip(kw.get('rs_time'), kw.get('rs_curr')):
my_nest.SetStatus([scg[i]], {'amplitude_times':[500.,t+500.],
'amplitude_values':[float(c),0.]})
my_nest.Connect( [scg[i]], [mnn[i]], params = { 'receptor_type' : rec['CURR'] } )
i+=1
my_nest.MySimulate(simTime)
mnn.voltage_signal.my_set_spike_peak( 21, spkSignal= mnn.spike_signal )
d={}
for i in range(n):
voltage=mnn.voltage_signal.analog_signals[i+1].signal
x=numpy.linspace(0,simTime, len(voltage))
dg=Data_generic(**{'x':x, 'y':voltage, 'xlabel':'Time (ms)', 'ylabel':'Voltage (mV)'})
misc.dict_update(d, {'rs_voltage_{0}'.format(i):dg})
rd=mnn.spike_signal.raw_data()
dg=Data_scatter(**{'x':rd[:,0], 'y':rd[:,1], 'xlabel':'Time (ms)', 'ylabel':'Voltage (mV)'})
misc.dict_update(d, {'rs_scatter':dg})
return d
def simulate_rebound_spike(**kw):
n=len(kw.get('rs_curr'))
simTime = 3000. # ms
my_nest.ResetKernel({'local_num_threads':1})
sd={'active':True, 'params':{'to_memory':True,'to_file':False}}
mm={'active':True,
'params':{'interval':0.1,'to_memory':True,'to_file':False}}
p=kw.get('rs_params')
if 'type_id' in p.keys(): del p['type_id']
mnn=MyNetworkNode('dummy',model=kw.get('model'), n=n, params=p, mm=mm, sd=sd)
my_nest.SetStatus(mnn[:], params={'I_e':.5}) # Set I_e
I_e = my_nest.GetStatus(mnn.ids,'I_e')[0]
scg = my_nest.Create( 'step_current_generator',n=n )
rec=my_nest.GetStatus(mnn[:])[0]['receptor_types']
i=0
for t, c in zip(kw.get('rs_time'), kw.get('rs_curr')):
my_nest.SetStatus([scg[i]], {'amplitude_times':[500.,t+500.],
'amplitude_values':[float(c),0.]})
my_nest.Connect( [scg[i]], [mnn[i]], params = { 'receptor_type' : rec['CURR'] } )
i+=1
my_nest.MySimulate(simTime)
mnn.voltage_signal.my_set_spike_peak( 21, spkSignal= mnn.spike_signal )
d={}
for i in range(n):
voltage=mnn.voltage_signal.analog_signals[i+1].signal
x=numpy.linspace(0,simTime, len(voltage))
dg=Data_generic(**{'x':x, 'y':voltage, 'xlabel':'Time (ms)', 'ylabel':'Voltage (mV)'})
misc.dict_update(d, {'rs_voltage_{0}'.format(i):dg})
rd=mnn.spike_signal.raw_data()
dg=Data_scatter(**{'x':rd[:,0], 'y':rd[:,1], 'xlabel':'Time (ms)', 'ylabel':'Voltage (mV)'})
misc.dict_update(d, {'rs_scatter':dg})
return d
def simulate(
from_disk=0,
kw={},
net='Net_0',
script_name=__file__.split('/')[-1][0:-3],
setup=Setup(50, 20),
):
file_name = kw.get('file_name', dr.HOME_DATA + '/' + script_name)
file_name_figs = kw.get('file_name_figs',
dr.HOME_DATA + '/fig/' + script_name)
sd = get_storage_list([net], file_name, '')[0]
d = {}
if from_disk == 0:
print net
dd = {}
for call in kw.get('calls', [
simulate_irregular_firing,
simulate_ahp,
simulate_IV,
simulate_IF,
get_nullcline,
simulate_rebound_spike,
]):
misc.dict_update(dd, {net: call(**kw)})
save(sd, dd)
elif from_disk == 1:
filt = kw.get('filter', [net] + ['IV', 'IF', 'ahp', 'nullcline'] +
['rs_scatter'] +
['rs_voltage_{0}'.format(i) for i in range(6)] +
['irf_voltage_{0}'.format(i) for i in range(3)])
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
return d, file_name_figs
def load_mpi(cls, file_name, nets):
'''It makes perfect sense that you should use foo=Foo.load(),
and not foo=Foo();foo.load(). for example, if Foo has some
variables that MUST be passed in to the init, you would need
to make them up for foo=Foo(); or if the init does some heavy
calculations of variables stored in the instance,
it would be for nothing. '''
if os.path.isfile(file_name + '.pkl'):
# cls.file_name=file_name
# cls.directory=file_name+'/'
out = {}
for net in nets:
file_name = file_name + '/' + net
d = pickle_load(file_name)
d.force_update(file_name)
misc.dict_update(out, d)
return out
else:
return Storage_dic(file_name)
def perturbations():
sim_time = 10000.0
size = 20000.0
threads = 1
freqs = [1., 2.0]
path = ('/home/mikael/results/papers/inhibition' +
'/network/simulate_inhibition_ZZZ4/')
l = op.get()[-3:]
for i in range(len(l)):
l[i] += pl(
{
'simu': {
'sim_time': sim_time,
'sim_stop': sim_time,
'threads': threads
},
'netw': {
'size': size
}
}, '=')
damp = process(path, freqs)
for key in sorted(damp.keys()):
val = damp[key]
print numpy.round(val, 2), key
ll = []
for i, _l in enumerate(l):
for j, _ in enumerate(freqs):
amp = [numpy.round(damp[_l.name][j], 2), 1]
d = {
'type': 'oscillation2',
'params': {
'p_amplitude_mod': amp[0],
'p_amplitude0': amp[1],
'freq': 20.
}
}
_ll = deepcopy(_l)
dd = {}
for key in ['C1', 'C2', 'CF', 'CS']:
dd = misc.dict_update(dd, {'netw': {'input': {key: d}}})
_ll += pl(dd, '=', **{'name': 'amp_{0}-{1}'.format(*amp)})
ll.append(_ll)
return ll, threads
def get():
l = []
p = {'equal': {}, 'mul': {}} #
for w1, w2 in [
[1., .0],
[.8, .2],
[.6, .4],
[.5, .5],
[.4, .6],
[.2, .8],
[.0, 1.],
]:
d = {}
d = misc.dict_update(p['mul'], d)
l += [pl(d, '*', **{'name': ''})]
d = {
'nest': {
'GA_FS_gaba': {
'weight': w1
},
'GF_FS_gaba': {
'weight': w2
}
}
}
d = misc.dict_update(p['equal'], d)
s = 'GA_{0}_GF_{1}'.format(w1, w2)
l[-1] += pl(d, '=', **{'name': s})
return l
def load_mpi(cls, file_name, nets):
'''It makes perfect sense that you should use foo=Foo.load(),
and not foo=Foo();foo.load(). for example, if Foo has some
variables that MUST be passed in to the init, you would need
to make them up for foo=Foo(); or if the init does some heavy
calculations of variables stored in the instance,
it would be for nothing. '''
if os.path.isfile(file_name+'.pkl'):
# cls.file_name=file_name
# cls.directory=file_name+'/'
out={}
for net in nets:
file_name=file_name+'/'+net
d= pickle_load(file_name)
d.force_update(file_name)
misc.dict_update(out, d)
return out
else:
return Storage_dic(file_name)
def gather2(path, nets, models, attrs):
fs = os.listdir(path)
d = {}
i = 0
for name0 in fs:
dd = {}
for net in nets:
name = name0 + '/' + net + '.pkl'
if not os.path.isfile(path + name):
print name
continue
file_name = path + name[:-4]
sd = Storage_dic.load(file_name)
args = nets + models + attrs
misc.dict_update(dd, sd.load_dic(*args))
if dd:
d = misc.dict_update(d, {name0.split('-')[-1]: dd})
i += 1
return d
def simulate(from_disk=0,
kw={},
net='Net_0',
script_name=__file__.split('/')[-1][0:-3],
setup=Setup(50,20),
):
file_name = kw.get('file_name', dr.HOME_DATA+'/'+script_name)
file_name_figs = kw.get('file_name_figs', dr.HOME_DATA+'/fig/'+script_name)
sd=get_storage_list([net], file_name, '')[0]
d={}
if from_disk==0:
print net
dd={}
for call in kw.get('calls',[simulate_irregular_firing,
simulate_ahp,
simulate_IV,
simulate_IF,
get_nullcline,
simulate_rebound_spike,]):
misc.dict_update(dd,{net:call(**kw)})
save(sd, dd)
elif from_disk==1:
filt = kw.get('filter', [net]+['IV', 'IF', 'ahp', 'nullcline']
+['rs_scatter']+['rs_voltage_{0}'.format(i) for i in range(6)]
+['irf_voltage_{0}'.format(i) for i in range(3)])
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
return d, file_name_figs
def gather2(path, nets, models, attrs):
fs=os.listdir(path)
d={}
i=0
for name0 in fs:
dd={}
for net in nets:
name=name0+'/'+net+'.pkl'
if not os.path.isfile(path+name):
print name
continue
file_name=path+name[:-4]
sd = Storage_dic.load(file_name)
args=nets+models+attrs
misc.dict_update(dd, sd.load_dic(*args))
if dd:
d = misc.dict_update(d, {name0.split('-')[-1]:dd})
i+=1
return d
def main():
k = get_kwargs_builder()
from os.path import expanduser
home = expanduser("~")
attr = ['firing_rate', 'mean_rates', 'spike_statistic']
kwargs_dic = {
'mean_rates': {
't_start': k['start_rec']
},
'spike_statistic': {
't_start': k['start_rec']
},
}
file_name = (home + '/results/papers/inhibition/network/' +
__file__.split('/')[-1][0:-3])
models = ['M1', 'M2', 'FS', 'GI', 'GA', 'ST', 'SN']
info, nets, _ = get_networks()
sd = Storage_dic.load(file_name)
sd.add_info(info)
sd.garbage_collect()
d = {}
for net, from_disk in zip(nets, [1] * 2):
if not from_disk:
dd = run(net)
dd = compute(dd, models, attr, **kwargs_dic)
save(sd, dd)
elif from_disk:
filt = [net.get_name()] + models + attr
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
figs = []
figs.append(show_fr(d, models))
figs.append(show_hr(d, models))
sd.save_figs(figs)
if DISPLAY: pylab.show()
pylab.show()
def _run(storage_dic, d, net, from_disk, attr, **kwargs):
model = net.get_single_unit()
kwargs_dic = {attr: kwargs}
if not from_disk:
dd = {net.get_name(): net.simulation_loop()}
dd = compute(dd, [model], [attr], **kwargs_dic)
save(storage_dic, dd)
elif from_disk:
# filt = [net.get_name()] + [model] + ['spike_signal']
# dd = load(storage_dic, *filt)
# dd = compute(dd, [model], [attr], **kwargs_dic)
# save(storage_dic, dd)
filt = [net.get_name()] + [model] + [attr]
dd = load(storage_dic, *filt)
dd = reduce_levels(dd, [model] + [attr])
d = misc.dict_update(d, dd)
return d
def create_sd(self, name, d_add):
model=name+'_spike_detector'
if model not in my_nest.Models():
my_nest.CopyModel('spike_detector', model )
d={'active':False,
'params': {"withgid": True,
'to_file':False,
'start':0.0,
'stop':numpy.inf,
'to_memory':True }}
d=misc.dict_update(d, d_add)
if d['active']:
_id=my_nest.Create(model, params=d['params'])
my_nest.ConvergentConnect(self.ids, _id)
d.update({'id':_id, 'model':model})
return d
def main_loop(from_disk, attr, models, sets, nets, kwargs_dic, sd_list,
**kwargs):
run_method = kwargs.get('run', run)
compute_method = kwargs.get('compute', compute)
d = {}
from_disks = [from_disk] * len(nets.keys())
if type(sd_list) == list:
iterator = [nets.values(), from_disks, sd_list]
else:
iterator = [nets.values(), from_disks]
for vals in zip(*iterator):
if type(sd_list) == list:
net, fd, sd = vals
else:
net, fd = vals
if fd == 0:
dd = run_method(net)
save(sd, dd)
elif fd == 1:
filt = [net.get_name()] + models + ['spike_signal']
dd = load(sd, *filt)
dd = compute_method(dd, models, attr, **kwargs_dic)
save(sd, dd)
elif fd == 2:
print 'Loading data'
filt = ([net.get_name()] + sets + models + attr +
kwargs.get('attrs_load', []))
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
return from_disks, d
def _run_XX(flag, storage_dic, stim, d, net, from_disk):
model = net.get_single_unit()
inp = net.get_single_unit_input()
if flag == 'IV':
attr = 'IV_curve'
stim_name = 'node.' + model + '.nest_params.I_e'
call = getattr(net, 'sim_IV_curve')
if flag == 'IF':
attr = 'IF_curve'
stim_name = 'node.' + model + '.nest_params.I_e'
call = getattr(net, 'sim_IF_curve')
if flag == 'FF':
attr = 'FF_curve'
stim_name = 'node.' + inp + '.rate'
call = getattr(net, 'sim_FF_curve')
if not from_disk:
k = {
'stim': stim,
'stim_name': stim_name,
'stim_time': net.get_sim_time(),
'model': model
}
dd = {net.get_name(): call(**k)}
dd = compute(dd, [model], [attr])
save(storage_dic, dd)
elif from_disk:
filt = [net.get_name()] + [model] + [attr]
dd = load(storage_dic, *filt)
pp(dd)
dd = reduce_levels(dd, [model] + [attr])
d = misc.dict_update(d, dd)
return d
def create_mm(self, name, d_add, **kw):
model=name+'_multimeter'
if model not in my_nest.Models():
my_nest.CopyModel('multimeter', model )
d={'active':False,
'id':[],
'model':name+'_multimeter',
'params': {'record_from':['V_m'],
'start':0.0,
'stop':numpy.inf,
'interval':1.,
'to_file':False,
'to_memory':True}} # recodring interval (dt)
d=misc.dict_update(d, d_add)
if d['active']:
_id=my_nest.Create(model, params=d['params'])
if 'slice' in kw.keys():
my_nest.DivergentConnect(_id, self.ids[kw['slice']])
else:
my_nest.DivergentConnect(_id, self.ids)
d.update({'id':_id, 'model':model})
return d
def _optimize(flag, net, storage_dic, d, from_disk, **kwargs):
model = net.get_single_unit()
inp = net.get_single_unit_input()
attr = 'fmin'
f = [model]
if flag == 'opt_rate':
x = ['node.' + inp + '.rate']
if flag == 'opt_curr':
x = ['node.' + model + '.nest_params.I_e']
x0 = kwargs.get('x0', 900.)
opt = {'netw': {'optimization': {'f': f, 'x': x, 'x0': x0}}}
net.par.update_dic_rep(opt)
kwargs_fmin = {
'model': net,
'call_get_x0': 'get_x0',
'call_get_error': 'sim_optimization',
'verbose': kwargs.get('verbose', True)
}
if not from_disk:
f = Fmin(net.name, **kwargs_fmin)
dd = {net.get_name(): {model: {attr: f.fmin()}}}
print dd
save(storage_dic, dd)
elif from_disk:
filt = [net.get_name()] + [model] + [attr]
dd = load(storage_dic, *filt)
dd = reduce_levels(dd, [model] + [attr])
d = misc.dict_update(d, dd)
return d
def create_sd(self, name, d_add):
model = name + '_spike_detector'
if model not in my_nest.Models():
my_nest.CopyModel('spike_detector', model)
d = {
'active': False,
'params': {
"withgid": True,
'to_file': False,
'start': 0.0,
'stop': numpy.inf,
'to_memory': True
}
}
d = misc.dict_update(d, d_add)
if d['active']:
_id = my_nest.Create(model, params=d['params'])
my_nest.ConvergentConnect(self.ids, _id)
d.update({'id': _id, 'model': model})
return d
dd = compute_attrs(dd, net)
save(sd, dd)
if from_disk == 1:
filt = [net] + ['gi', 'st', 'gi_st'] + ['spike_signal']
dd = load(sd, *filt)
pp(dd)
dd = compute_attrs(dd, net)
save(sd, dd)
elif from_disk == 2:
filt = [net] + ['gi', 'st', 'gi_st'
] + ['firing_rate', 'phases_diff_with_cohere']
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
pp(d)
fig, axs = get_fig_axs()
for i in range(len(nets)):
d['Net_0{0}'.format(i)]['gi']['firing_rate'].plot(
axs[i], **{'win': 1.})
d['Net_0{0}'.format(i)]['st']['firing_rate'].plot(
axs[i], **{'win': 1.})
axs[i].set_xlim(0.0, 1500.0)
colors = misc.make_N_colors('copper', len(kw_list))
# for net, c in zip(nets, colors):
# kw={ 'all':True,
def get():
l = []
solution = get_solution()
rEA = 200.0
rES = 3200.0
for rCS, rM2, rEI in [
[250.0, 700.0, 1700.0],
[200.0, 740.0, 1700.0],
[250.0, 700.0, 1400.0],
]:
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
d['node']['EI']['rate'] = rEI
d['node']['EA']['rate'] = rEA
d['node']['C2']['rate'] = rM2
misc.dict_update(d, {'node': {'CS': {'rate': rCS}}})
misc.dict_update(d, {'node': {'ES': {'rate': rES}}})
s = 'rEI_{0}_rEA_{1}_rCS_{2}_rES_{3}_rM2_{4}'.format(
rEI, rEA, rCS, rES, rM2)
l[-1] += pl(d, '=', **{'name': s})
rEI = 1700.0
rEA = 200.0
rCS = 250.0
rES = 1800.0
for wGISN in [0.8, 0.6, 0.4, 0.2]:
d = {}
misc.dict_update(d, solution['mul'])
misc.dict_update(d, {'nest': {'GI_SN_gaba': {'weight': wGISN}}})
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
d['node']['EI']['rate'] = rEI
d['node']['EA']['rate'] = rEA
d['node']['C2']['rate'] = rM2
misc.dict_update(d, {'node': {'CS': {'rate': rCS}}})
misc.dict_update(d, {'node': {'ES': {'rate': rES}}})
s = 'rEI_{0}_rEA_{1}_rCS_{2}_rES_{3}_rM2_{4}_wGISN_{5}'.format(
rEI, rEA, rCS, rES, rM2, wGISN)
l[-1] += pl(d, '=', **{'name': s})
rEA = 200.0
rES = 3200.0
for rCS, rM2, rEI in [
[250.0, 740.0, 1700.0],
]:
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
d['node']['EI']['rate'] = rEI
d['node']['EA']['rate'] = rEA
d['node']['C2']['rate'] = rM2
misc.dict_update(d, {'node': {'CS': {'rate': rCS}}})
misc.dict_update(d, {'node': {'ES': {'rate': rES}}})
s = 'rEI_{0}_rEA_{1}_rCS_{2}_rES_{3}_rM2_{4}'.format(
rEI, rEA, rCS, rES, rM2)
l[-1] += pl(d, '=', **{'name': s})
return l
nets = ['Net_{0:0>2}'.format(i) for i in range(len(kw_list))]
sd_list = get_storage_list(nets, path, '')
d = {}
for net, sd, kw in zip(nets, sd_list, kw_list):
if from_disk == 0: # and net=='Net_05':
print net
dd = {}
for call in [
simulate_IV,
simulate_IF,
get_nullcline,
simulate_rebound_spike,
]:
misc.dict_update(dd, {net: call(**kw)})
save(sd, dd)
# if from_disk==1:
# filt= [net]+['gi','st', 'gi_st']+['spike_signal']
# dd = load(sd, *filt)
# pp(dd)
# dd=compute_attrs(dd, net)
# save(sd, dd)
elif from_disk == 1:
filt = [net] + ['IV', 'IF', 'nullcline'] + ['rs_scatter']
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
def plot(file_name, figs, setup, flag, **k):
nets=['Net_0', 'Net_1']
attr = [
'firing_rate',
'mean_rates',
'spike_statistic'
]
attr2=['psd',
'activity_histogram',
'activity_histogram_stat']
attr_coher = [
'phase_diff',
'phases_diff_with_cohere',
'mean_coherence'
]
models = ['M1', 'M2', 'FS', 'GI', 'GA', 'ST', 'SN', 'GP']
models_coher = ['GI_GA', 'GI_GI', 'GA_GA', 'GA_ST', 'GI_ST', 'GP_GP',
'ST_ST', 'GP_ST',]
# Adding nets no file name
sd_list=get_storage_list(nets, file_name, '')
d = {}
for sd, net in zip(sd_list, nets):
filt = ([net]
+ models + models_coher
+ attr + attr2 + attr_coher)
dd = load(sd, *filt)
# cmp_statistical_test(models, dd)
d = misc.dict_update(d, dd)
kw=setup.plot_summed2()
kw['alphas']=[1.,1.]
kw['coherence_xcut']=[0,50]
kw['coherence_color']=['grey', 'k']
kw['coherence_p_conf95_linestyle']='--'
kw['hatchs_ti_ti']=['','']
kw['label_model']='Black=Model'
kw['label_exp']='White=Exp., Mallet et al 2008'
kw['linewidth']=1.
kw['set_text_on_bars']=False
kw['top_label']=False
kw['phases_diff_with_cohere_colors']=['grey','k']
kw['phases_diff_with_cohere_xcut']=[-numpy.pi*0.97, numpy.pi**0.97]
kw['phases_diff_with_cohere_remove_peaks']=True
kw['scale']=1
kw['spk_stats_color_axis']=1
kw['spk_stats_colors']=['k', 'w']
kw['spk_stats_colors_ti_ta']=['k','w']
kw['xlim_cohere']=[-1, 51]
kw.update(k)
figs.append(base_oscillation.show_summed2(d, **kw))
kw=setup.plot_summed_STN()
kw['alphas']=[1.,1.]
kw['coherence_color']=['grey','k']
kw['coherence_p_conf95_linestyle']='--'
kw['hatchs_ti_ti']=['','']
kw['label_model']='Black=Model'
kw['label_exp']='White=Exp., Mallet et al 2008'
kw['linewidth']=1.
kw['phases_diff_with_cohere_xcut']=[-numpy.pi*0.97, numpy.pi**0.97]
kw['phases_diff_with_cohere_remove_peaks']=True
kw['phases_diff_with_cohere_colors']=['grey','k']
kw['scale']=1
kw['set_text_on_bars']=False
kw['spk_stats_colors']=['k', 'w']
kw['spk_stats_colors_ti_ta']=['k','w']
kw['spk_stats_color_axis']=1
kw['top_label']=False
kw['xlim_cohere']=[-1, 51]
if flag=='slow_wave':
kw['ylim_cohere']=[0, 1.0]
elif flag=='beta':
kw['ylim_cohere']=[0, 0.4]
kw['coherence_xcut']=[0,50]
kw.update(k)
figs.append(base_oscillation.show_summed_STN(d, **kw))
return figs
def get_solution_eNeuro_rev():
solution={'mul':{},
'equal':{}}
#Decreasing from 0.25 leads to ...
#Increasing from 0.25 leads to ...
d={'nest':{'M1_M1_gaba':{'weight':0.25},
'M1_M2_gaba':{'weight':0.25},
'M2_M1_gaba':{'weight':0.25},
'M2_M2_gaba':{'weight':0.25}}}
misc.dict_update(solution,{'mul':d})
# GA firing rate needs to be maintained, around 12 Hz for sw in
# dopamine depleted rats). When decreasing/increasing
# ST-GA one need to either compensate by changing inhibition from
# GPe and/or EA external input (assume that synapses from TA and TI
# are of equal strength.
# This script is first run where ST-GA GP-GA and EA individually are
# perturbed to determine each relative influence to TA firing rate.
# From this data then combinations fo changes that should results in
# 12 Hz TA firing rate are created.
d={'nest':{'ST_GA_ampa':{'weight':0.3},
'GA_GA_gaba':{'weight':0.25},
'GI_GA_gaba':{'weight':0.25},
'GF_GA_gaba':{'weight':0.25},
}}
misc.dict_update(solution, {'mul':d})
# EA rate
d={'node':{'EA':{'rate':200.0}}}
misc.dict_update(solution,{'equal':d})
# Lower GA IF curve.
d={'nest':{'GA':{
'b':1.5,
'C_m':1.5,
'Delta_T':1.5
}}}
misc.dict_update(solution,{'mul':d})
# CF rate
d={'node':{'CF':{'rate':950.0}}}
misc.dict_update(solution,{'equal':d})
d={'netw':{
'GA_prop':0.25,
'GI_prop':0.675, #<=0.9*0.75
'GF_prop':0.075,
}}
misc.dict_update(solution,{'equal':d})
# C1 and C2 have been set such that MSN D1 and MSN D2 fires at
# low firing rates (0.1-0,2 Hz).
d={'node':{'C1':{'rate':560.0},
'C2':{'rate':700.}
}}
misc.dict_update(solution,{'equal':d})
# Set such that GPe TI fires in accordance with slow wave sleep
# in dopamine depleted rats.
d={'node':{
'EI':{'rate':1400.0}, # Increase with 340, to get close to 24 Hz sw dopamine depleted rats TI
'EF':{'rate':1400.0}, # Increase with 340, to get close to 24 Hz sw dopamine depleted rats TI
}}
misc.dict_update(solution,{'equal':d})
# Decrease weight since tau decay is 5 times stronger
d={'nest':{'GA_M1_gaba':{'weight':0.04},
'GA_M2_gaba':{'weight':0.08}}}
misc.dict_update(solution,{'equal':d})
# GF connects stronger to GA. This accounts for Gage 2010 data.
# d={'nest':{'GA_FS_gaba':{'weight':0.4},
# 'GF_FS_gaba':{'weight':0.6}}}
# misc.dict_update(solution,{'mul':d})
# Long time constant from TA
d={'nest':{'M1_low':{'GABAA_3_Tau_decay':87.},
'M2_low':{'GABAA_3_Tau_decay':76.},
'FS_low':{'GABAA_2_Tau_decay':66.},
}}
misc.dict_update(solution,{'equal':d})
# Dopamine effect on TA and TI to striatum
d={'nest':{
'M1_low':{'beta_I_GABAA_3': f_beta_rm(2.6),
'beta_I_GABAA_2': f_beta_rm(0.25)},
'M2_low':{'beta_I_GABAA_3': f_beta_rm(2.5),
'beta_I_GABAA_2': f_beta_rm(0.25)},
'FS_low':{'beta_I_GABAA_2': f_beta_rm(1.6)},
},
'conn':{'M1_M1_gaba':{'beta_fan_in': f_beta_rm(0.25)},
'M1_M2_gaba':{'beta_fan_in': f_beta_rm(0.25)},
'M2_M1_gaba':{'beta_fan_in': f_beta_rm(0.25)},
'M2_M2_gaba':{'beta_fan_in': f_beta_rm(0.25)}
}}
misc.dict_update(solution,{'equal':d})
# Weight TA M1/M2 1/2
# d={'nest':{
# 'GA_M1_gaba':{'weight':0.01},
# 'GA_M2_gaba':{'weight':0.01*2},
# }}
misc.dict_update(solution,{'equal':d})
#Dopamine such that STN increase above 50-100 %
x=2.5
d={'nest':{'ST':{'beta_I_AMPA_1': f_beta_rm(x),
'beta_I_NMDA_1': f_beta_rm(x)}}}
misc.dict_update(solution,{'equal':d})
# Delay ctx striatum and ctx stn set to 2.5 ms Jaeger 2011
y=2.5
misc.dict_update(solution,{'equal':{'nest':{'C1_M1_ampa':{'delay':y}}}})
misc.dict_update(solution,{'equal':{'nest':{'C1_M1_nmda':{'delay':y}}}})
misc.dict_update(solution,{'equal':{'nest':{'C2_M2_ampa':{'delay':y}}}})
misc.dict_update(solution,{'equal':{'nest':{'C2_M2_nmda':{'delay':y}}}})
misc.dict_update(solution,{'equal':{'nest':{'CF_FS_ampa':{'delay':y}}}})
# Set delay GP->STN 1 ms and STN->GP 2 ms as Jaeger 2011. Might need say something
# that this is not rat data. With this the coherence in STN goes up. Total delay from cortex
# to STN via striatum is 2.5+7+1 = 10.5.
d={'nest':{'GI_ST_gaba':{'delay':1.},
'GF_ST_gaba':{'delay':1.},
'ST_GI_ampa':{'delay':2.},
'ST_GF_ampa':{'delay':2.},
'ST_GA_ampa':{'delay':2.} }
}
misc.dict_update(solution,{'equal':d})
# Dopamine effect on MS-GI
d={'equal':{'nest':{
'GI':{'beta_I_GABAA_1': f_beta_rm(2)},
'GF':{'beta_I_GABAA_1': f_beta_rm(2)},
}}}
misc.dict_update(solution,d)
# Activate GF to FS connection
d={ 'conn':{'GF_FS_gaba':{'lesion':False}}}
misc.dict_update(solution,{'equal':d})
# GI predominently connect to to GA
# d={'equal':{'conn': {
# 'GA_GA_gaba':{'fan_in0': 5},
# 'GI_GA_gaba':{'fan_in0': round(25*0.9) },
# 'GF_GA_gaba':{'fan_in0': 25-round(25*0.9) },
# }}]
misc.dict_update(solution,d)
return solution
def plot(file_name, figs, setup, flag, **k):
nets = ['Net_0', 'Net_1']
attr = ['firing_rate', 'mean_rates', 'spike_statistic']
attr2 = ['psd', 'activity_histogram', 'activity_histogram_stat']
attr_coher = ['phase_diff', 'phases_diff_with_cohere', 'mean_coherence']
models = ['M1', 'M2', 'FS', 'GI', 'GA', 'ST', 'SN', 'GP']
models_coher = [
'GI_GA',
'GI_GI',
'GA_GA',
'GA_ST',
'GI_ST',
'GP_GP',
'ST_ST',
'GP_ST',
]
# Adding nets no file name
sd_list = get_storage_list(nets, file_name, '')
d = {}
for sd, net in zip(sd_list, nets):
filt = ([net] + models + models_coher + attr + attr2 + attr_coher)
dd = load(sd, *filt)
# cmp_statistical_test(models, dd)
d = misc.dict_update(d, dd)
kw = setup.plot_summed2()
kw['alphas'] = [1., 1.]
kw['coherence_xcut'] = [0, 50]
kw['coherence_color'] = ['grey', 'k']
kw['coherence_p_conf95_linestyle'] = '--'
kw['hatchs_ti_ti'] = ['', '']
kw['label_model'] = 'Black=Model'
kw['label_exp'] = 'White=Exp., Mallet et al 2008'
kw['linewidth'] = 1.
kw['set_text_on_bars'] = False
kw['top_label'] = False
kw['phases_diff_with_cohere_colors'] = ['grey', 'k']
kw['phases_diff_with_cohere_xcut'] = [-numpy.pi * 0.97, numpy.pi**0.97]
kw['phases_diff_with_cohere_remove_peaks'] = True
kw['scale'] = 1
kw['spk_stats_color_axis'] = 1
kw['spk_stats_colors'] = ['k', 'w']
kw['spk_stats_colors_ti_ta'] = ['k', 'w']
kw['xlim_cohere'] = [-1, 51]
kw.update(k)
figs.append(base_oscillation.show_summed2(d, **kw))
kw = setup.plot_summed_STN()
kw['alphas'] = [1., 1.]
kw['coherence_color'] = ['grey', 'k']
kw['coherence_p_conf95_linestyle'] = '--'
kw['hatchs_ti_ti'] = ['', '']
kw['label_model'] = 'Black=Model'
kw['label_exp'] = 'White=Exp., Mallet et al 2008'
kw['linewidth'] = 1.
kw['phases_diff_with_cohere_xcut'] = [-numpy.pi * 0.97, numpy.pi**0.97]
kw['phases_diff_with_cohere_remove_peaks'] = True
kw['phases_diff_with_cohere_colors'] = ['grey', 'k']
kw['scale'] = 1
kw['set_text_on_bars'] = False
kw['spk_stats_colors'] = ['k', 'w']
kw['spk_stats_colors_ti_ta'] = ['k', 'w']
kw['spk_stats_color_axis'] = 1
kw['top_label'] = False
kw['xlim_cohere'] = [-1, 51]
if flag == 'slow_wave':
kw['ylim_cohere'] = [0, 1.0]
elif flag == 'beta':
kw['ylim_cohere'] = [0, 0.4]
kw['coherence_xcut'] = [0, 50]
kw.update(k)
figs.append(base_oscillation.show_summed_STN(d, **kw))
return figs
nets=['Net_{0:0>2}'.format(i) for i in range(len(kw_list))]
sd_list=get_storage_list(nets, path, '')
d={}
for net, sd, kw in zip(nets, sd_list, kw_list):
if from_disk==0:# and net=='Net_05':
print net
dd={}
for call in [
simulate_IV,
simulate_IF,
get_nullcline,
simulate_rebound_spike,
]:
misc.dict_update(dd,{net:call(**kw)})
save(sd, dd)
# if from_disk==1:
# filt= [net]+['gi','st', 'gi_st']+['spike_signal']
# dd = load(sd, *filt)
# pp(dd)
# dd=compute_attrs(dd, net)
# save(sd, dd)
elif from_disk==1:
filt = [net]+['IV', 'IF', 'nullcline'] +['rs_scatter']
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
def sim_group(self, **kwargs):
kwargs = misc.dict_update(self.kwargs, kwargs)
return sim_group(self.sim_time, *self.args, **self.kwargs)
def get():
l = []
solution = {'equal': {}, 'mul': {}} #get_solution_final_beta()
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
l[-1] += pl(d, '=', **{'name': 'control_sim'})
# Decreasing delay TA-striatum increases oscillations in MSN and FSN
for y in [12] + list(numpy.arange(5, 105, 10)):
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
ratio = 100. / y
dd = {
'nest': {
'GA_M1_gaba': {
'weight': 0.4 * ratio
},
'GA_M2_gaba': {
'weight': 0.8 * ratio
}
}
}
misc.dict_update(d, dd)
# Decreasing from 2 leads to ...
# Increasing from 2 leads to ...
dd = {
'nest': {
'GA_FS_gaba': {
'weight': 2. / 0.29 * (17. / 66.) * ratio
}
}
}
misc.dict_update(d, dd)
# Just assumed to be 12 ms
dd = {
'nest': {
'M1_low': {
'GABAA_3_Tau_decay': 87. / ratio
},
'M2_low': {
'GABAA_3_Tau_decay': 76. / ratio
},
'FS_low': {
'GABAA_2_Tau_decay': 66. / ratio
},
}
}
misc.dict_update(d, dd)
l[-1] += pl(d, '=', **{'name': 'mod_GAtau_' + str(y)})
# Phase synch in GP and ST effected by delay from cortex
for y in numpy.arange(2.5, 21., 2.5):
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
misc.dict_update(d, {'nest': {'CS_ST_ampa': {'delay': y}}})
misc.dict_update(d, {'nest': {'CS_ST_nmda': {'delay': y}}})
l[-1] += pl(d, '=', **{'name': 'CSSTdelay_' + str(y)})
# Effect on phase TI-TA when having MSN connect to TA
for y, EA_rate in zip(numpy.arange(25, 130, 25),
numpy.arange(1, 1.8, 0.15)):
d = {}
misc.dict_update(d, solution['mul'])
misc.dict_update(d, {'node': {'EA': {'rate': EA_rate}}})
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
misc.dict_update(d, {'conn': {'M2_GA_gaba': {'lesion': False}}})
misc.dict_update(d, {'conn': {'M2_GA_gaba': {'fan_in0': y}}})
l[-1] += pl(d, '=',
**{'name': 'M2GA_' + str(y) + '_EArate_' + str(EA_rate)})
# Effect of TI back to str
for y in numpy.arange(1, 6, 1):
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
misc.dict_update(d, {'conn': {'GI_FS_gaba': {'lesion': False}}})
misc.dict_update(d, {'conn': {'GI_FS_gaba': {'fan_in0': y}}})
misc.dict_update(d, {'conn': {'GI_M1_gaba': {'lesion': False}}})
misc.dict_update(d, {'conn': {'GI_M1_gaba': {'fan_in0': y}}})
misc.dict_update(d, {'conn': {'GI_M2_gaba': {'lesion': False}}})
misc.dict_update(d, {'conn': {'GI_M2_gaba': {'fan_in0': y}}})
l[-1] += pl(d, '=', **{'name': 'mod_GI_M2_' + str(y)})
# Connectivity GPe-STN
v = STN_ampa_gaba_input_magnitude()
for _, x, y in v:
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
misc.dict_update(d, {'node': {'CS': {'rate': x}}})
misc.dict_update(d, {'nest': {'GI_ST_gaba': {'weight': y}}})
l[-1] += pl(d, '=', **{'name': 'mod_ST_inp_' + str(x) + '_' + str(y)})
# Effect of connectiviity onto TA from TI and TA
for y in numpy.arange(5., 29., 5.):
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
dd = {
'conn': {
'GA_GA_gaba': {
'fan_in0': y,
'rule': 'all-all'
},
'GF_GA_gaba': {
'fan_in0': int((30 - y) * 0.1),
'rule': 'all-all'
},
'GI_GA_gaba': {
'fan_in0': (30 - y) - int((30 - y) * 0.1),
'rule': 'all-all'
},
}
}
misc.dict_update(d, dd)
l[-1] += pl(d, '=',
**{'name': 'GAGA_' + str(y) + '_GIGA_' + str(30 - y)})
# Effect of MSN-MSN strength
for y in [0.125, 0.25, 0.5, 1, 2, 4, 8]:
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
dd = {
'nest': {
'M1_M1_gaba': {
'weight': y
},
'M1_M2_gaba': {
'weight': y
},
'M2_M1_gaba': {
'weight': y
},
'M2_M2_gaba': {
'weight': y
}
}
}
misc.dict_update(d, dd)
l[-1] += pl(d, '=', **{'name': 'MSMS_' + str(y)})
# Phase synch in GP and ST effected by delay from cortex to STR
for y in numpy.arange(20., 1.5, -2.5):
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
dd = {
'nest': {
'C1_M1_ampa': {
'delay': y
},
'C1_M1_nmda': {
'delay': y
},
'C2_M2_ampa': {
'delay': y
},
'C2_M2_nmda': {
'delay': y
},
'CF_FS_ampa': {
'delay': y
},
'CF_FS_nmda': {
'delay': y
}
}
}
misc.dict_update(d, dd)
l[-1] += pl(d, '=', **{'name': 'CXSTRdelay_' + str(y)})
# Delay STGP and GPST delay
for y, z in zip(*[numpy.arange(1., 9.)] * 2):
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
dd = {
'nest': {
'ST_GA_ampa': {
'delay': y
},
'ST_GI_ampa': {
'delay': y
},
'GI_ST_gaba': {
'delay': z
}
}
}
misc.dict_update(d, dd)
l[-1] += pl(d, '=',
**{'name': 'STGPdelay_' + str(y) + '_GPSTdelay_' + str(z)})
return l
# Strength STN-GP
r = numpy.array([0., 200., 400., 600., 800., 1000.0]) + 200.
w = numpy.array([304., 0.259, 0.225, 0.18, 0.134, 0.09]) + 0.46
for y, z in zip(*[r, w]):
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
misc.dict_update(d, solution['equal'])
dd = {
'nest': {
'ST_GA_ampa': {
'weight': z
}
},
'node': {
'GA': {
'rate': y
}
}
}
misc.dict_update(d, dd)
l[-1] += pl(d, '=', **{'name': 'GAr_' + str(y) + '_STGAw_' + str(z)})
return l
def sim_group(self, **kwargs):
kwargs=misc.dict_update(self.kwargs, kwargs)
return sim_group(self.sim_time, *self.args, **self.kwargs)
def get(flag='perturbations'):
l = []
ld = []
solution = get_solution_eNeuro_rev()
#
# for s in solution:
# print s
# pp(solution)
fEA = 3.
fEI = 0.9 #*1.6 working solution
fCF = .85
rEI = 1700.0 * fEI - 100.
rEA = 200.0 + 100. #*fEA
rCS = 250.0
rES = 2000.0
rM2 = 740.0
rCF = 950.0 * fCF
d = {}
ld.append({'mul': d})
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
d = {}
ld[-1].update({'equal': d})
misc.dict_update(d, solution['equal'])
d['node']['EF']['rate'] = rEI
d['node']['EI']['rate'] = rEI
d['node']['EA']['rate'] = rEA
d['node']['C2']['rate'] = rM2
d['node']['CF']['rate'] = rCF
misc.dict_update(d, {'node': {'CS': {'rate': rCS}}})
misc.dict_update(d, {'node': {'ES': {'rate': rES}}})
s = 'rEI_{0}_rEA_{1}_rCS_{2}_rES_{3}_rM2_{4}'.format(
rEI, rEA, rCS, rES, rM2)
l[-1] += pl(d, '=', **{'name': s})
rEI = 800.0 * fEI - 100.
rEA = 100.0 + 100. #*fEA
rCS = 170.0
rES = 2000.0
rM2 = 740.0
rCF = 950.0 * fCF
d = {}
misc.dict_update(d, solution['mul'])
l += [pl(d, '*', **{'name': ''})]
ld.append({'mul': d})
d = {}
misc.dict_update(d, solution['equal'])
d['node']['EF']['rate'] = rEI
d['node']['EI']['rate'] = rEI
d['node']['EA']['rate'] = rEA
d['node']['C2']['rate'] = rM2
d['node']['CF']['rate'] = rCF
misc.dict_update(d, {'node': {'CS': {'rate': rCS}}})
misc.dict_update(d, {'node': {'ES': {'rate': rES}}})
s = 'rEI_{0}_rEA_{1}_rCS_{2}_rES_{3}_rM2_{4}'.format(
rEI, rEA, rCS, rES, rM2)
l[-1] += pl(d, '=', **{'name': s})
ld[-1].update({'equal': d})
if flag == 'perturbations': return l
if flag == 'dictionary': return ld
paths=[]
paths.append('/home/mikael/results/papers/inhibition/network/'
+'milner/simulate_beta_new_beginning_slow4/')
paths.append('/home/mikael/results/papers/inhibition/network/'
+'milner/simulate_slow_wave_new_beginning_slow4/')
script_name=(__file__.split('/')[-1][0:-3]+'/data')
file_name = get_file_name(script_name)
sd = Storage_dic.load(file_name, **{'force_update':False})
if from_disk==0:
d={}
for path, create_name in zip(paths, [ create_name_beta,create_name_sw]):
d_tmp=effect_conns.gather(path, nets, models, attrs, **{'name_maker':create_name})
misc.dict_update(d, d_tmp)
save(sd, d)
pp(d)
elif from_disk==1:
d = sd.load_dic(*(nets+models+['spike_statistic']),
**{'star':[0]})
pp(d)
pp(sorted(d.keys()))
dd=postprocess(d)
misc.dict_update(d, dd)
save(sd, d)
elif from_disk==2:
keys_iterator=[]
def get_change_to(flag, E_rev='low'):
x=0.
#1 *
if flag=='M1':
if E_rev=='low':
d={'nest':{'M1_low':{'beta_d':x,
'beta_E_L':x,
'beta_V_b':x,
}}}
#2 *
if flag=='CTX_M1':
if E_rev=='low':
d={'nest':{'M1_low':{
'beta_I_NMDA_1':x,
}}}
#3 *
if flag=='CTX_M2':
if E_rev=='low':
d={'nest':{'M2_low':{'beta_I_AMPA_1':x,
}}}
#4 *
if flag=='FS_FS':
if E_rev=='low':
d={'nest':{'FS_low':{'beta_I_GABAA_1':x,
}},
}
#5 * //not used (shoudl also be GA not GP
if flag=='GP_FS':
if E_rev=='low':
d={'nest':{'FS_low':{'beta_I_GABAA_2':x,
}},
}
#6 *
if flag=='FS_M2':
if E_rev=='low':
d={
'conn':{'FS_M2_gaba':{'beta_fan_in':x}}}
#7 *
if flag=='CTX_ST':
d={'nest':{'ST':{'beta_I_AMPA_1':x,
'beta_I_NMDA_1':x,
}}}
#8 *
if flag=='GP_ST':
d={'nest':{'ST':{'beta_I_GABAA_1':x,
}}}
#9 *
if flag=='GP':
d={'nest':{'GI':{'beta_E_L':x,
'beta_V_a':x},
'GF':{'beta_E_L':x,
'beta_V_a':x},
'GA':{'beta_E_L':x,
'beta_V_a':x},
}}
#10 *
if flag=='ST_GP':
d={'nest':{'GI':{'beta_I_AMPA_1':x},
'GF':{'beta_I_AMPA_1':x},
'GA':{'beta_I_AMPA_1':x}
}}
#11 *
if flag=='GP_GP':
d={'nest':{'GI':{'beta_I_GABAA_2':x},
'GF':{'beta_I_GABAA_2':x},
'GA':{'beta_I_GABAA_2':x}
}}
#12 *
if flag=='SN':
d={'nest':{'SN':{'beta_E_L':x,
'beta_V_a':x,
}}}
#13 *
if flag=='M1_SN':
d={'nest':{'SN':{'beta_I_GABAA_1':x,
}}}
#14 *
if flag=='MS_MS':
if E_rev=='low':
d={'nest':{'M1_low':{'beta_I_GABAA_2':x},
'M2_low':{'beta_I_GABAA_2':x}}}
for conn in ['M1_M1_gaba', 'M1_M2_gaba','M2_M1_gaba','M2_M2_gaba']:
misc.dict_update(d,{'conn':{conn:{'beta_fan_in': x}}})
#15 *
if flag=='M2_GI':
d={'nest':{'GI':{'beta_I_GABAA_1':x,
}}}
#16 *
if flag=='FS':
d={'nest':{'FS_low':{'beta_E_L':x,
}}}
#17 *
if flag=='GA_MS':
d={'nest':{'M1_low':{'beta_I_GABAA_3':x},
'M2_low':{'beta_I_GABAA_3':x}}}
#18 *
if flag=='GA_FS':
d={'nest':{'FS_low':{'beta_I_GABAA_2':x}}}
#19 *
if flag=='GI_FS':
d={'nest':{'FS_low':{'beta_I_GABAA_3':x}}}
return d
def get_solution():
solution={'mul':{},
'equal':{}}
#Decreasing from 0.25 leads to ...
#Increasing from 0.25 leads to ...
d={'nest':{'M1_M1_gaba':{'weight':0.25},
'M1_M2_gaba':{'weight':0.25},
'M2_M1_gaba':{'weight':0.25},
'M2_M2_gaba':{'weight':0.25}}}
misc.dict_update(solution,{'mul':d})
# GA firing rate needs to be maintained, around 12 Hz for sw in
# dopamine depleted rats). When decreasing/increasing
# ST-GA one need to either compensate by changing inhibition from
# GPe and/or EA external input (assume that synapses from TA and TI
# are of equal strength.
# This script is first run where ST-GA GP-GA and EA individually are
# perturbed to determine each relative influence to TA firing rate.
# From this data then combinations fo changes that should results in
# 12 Hz TA firing rate are created.
d={'nest':{'ST_GA_ampa':{'weight':0.25},
'GA_GA_gaba':{'weight':0.25},
'GI_GA_gaba':{'weight':0.25},
'GF_GA_gaba':{'weight':0.25},
}}
misc.dict_update(solution, {'mul':d})
d={'node':{'EA':{'rate':200.0}}}
misc.dict_update(solution,{'equal':d})
# C1 and C2 have been set such that MSN D1 and MSN D2 fires at
# low firing rates (0.1-0,2 Hz).
d={'node':{'C1':{'rate':560.0},
'C2':{'rate':700.}}}
misc.dict_update(solution,{'equal':d})
# Set such that GPe TI fires in accordance with slow wave sleep
# in dopamine depleted rats.
d={'node':{
'EI':{'rate':1400.0}, # Increase with 340, to get close to 24 Hz sw dopamine depleted rats TI
'EF':{'rate':1400.0}, # Increase with 340, to get close to 24 Hz sw dopamine depleted rats TI
}}
misc.dict_update(solution,{'equal':d})
# Decrease weight since tau decay is 5 times stronger
d={'nest':{'GA_M1_gaba':{'weight':0.8/5},
'GA_M2_gaba':{'weight':0.8/5}}}
misc.dict_update(solution,{'equal':d})
# Decrease weight since tau decay is 5 times stronger
d={'nest':{'GA_FS_gaba':{'weight':2./5}}}
misc.dict_update(solution,{'equal':d})
# Just assumed to be 12*5 ms
d={'nest':{'M1_low':{'GABAA_3_Tau_decay':12.*5},
'M2_low':{'GABAA_3_Tau_decay':12.*5},
'FS_low':{'GABAA_2_Tau_decay':12.*5},
}}
misc.dict_update(solution,{'equal':d})
#Dopamine such that STN increase above 50-100 %
x=2.5
d={'nest':{'ST':{'beta_I_AMPA_1': f_beta_rm(x),
'beta_I_NMDA_1': f_beta_rm(x)}}}
misc.dict_update(solution,{'equal':d})
# Delay ctx striatum and ctx stn set to 2.5 ms Jaeger 2011
y=2.5
misc.dict_update(solution,{'equal':{'nest':{'C1_M1_ampa':{'delay':y}}}})
misc.dict_update(solution,{'equal':{'nest':{'C1_M1_nmda':{'delay':y}}}})
misc.dict_update(solution,{'equal':{'nest':{'C2_M2_ampa':{'delay':y}}}})
misc.dict_update(solution,{'equal':{'nest':{'C2_M2_nmda':{'delay':y}}}})
misc.dict_update(solution,{'equal':{'nest':{'CF_FS_ampa':{'delay':y}}}})
# Dopamine effect on MS-GI
d={'equal':{'nest':{
'GI':{'beta_I_GABAA_1': f_beta_rm(2)},
'GF':{'beta_I_GABAA_1': f_beta_rm(2)},
}}}
misc.dict_update(solution,d)
# GI predominently connect to to GA
# d={'equal':{'conn': {
# 'GA_GA_gaba':{'fan_in0': 5},
# 'GI_GA_gaba':{'fan_in0': round(25*0.9) },
# 'GF_GA_gaba':{'fan_in0': 25-round(25*0.9) },
# }}]
misc.dict_update(solution,d)
return solution
dd={net:simulate_network(**kw)}
dd=compute_attrs(dd, net)
save(sd, dd)
if from_disk==1:
filt= [net]+['gi','st', 'gi_st']+['spike_signal']
dd = load(sd, *filt)
pp(dd)
dd=compute_attrs(dd, net)
save(sd, dd)
elif from_disk==2:
filt = [net]+['gi','st', 'gi_st']+['firing_rate', 'phases_diff_with_cohere']
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
pp(d)
fig, axs=get_fig_axs()
for i in range(len(nets)):
d['Net_0{0}'.format(i)]['gi']['firing_rate'].plot(axs[i], **{'win':1.})
d['Net_0{0}'.format(i)]['st']['firing_rate'].plot(axs[i], **{'win':1.})
axs[i].set_xlim(0.0,1500.0)
colors=misc.make_N_colors('copper', len(kw_list))
# for net, c in zip(nets, colors):
# kw={ 'all':True,
def get():
l=[]
solution=get_solution()
d={}
misc.dict_update(d, solution['mul'])
l+=[pl(d, '*', **{'name':''})]
d={}
misc.dict_update(d, solution['equal'])
l[-1]+=pl(d, '=', **{'name':'control_sim'})
# Connectivity GPe-STN
v=STN_ampa_gaba_input_magnitude()
agg=[]
for _,a,b in v:
agg+=[[a,b] for _ in range(1)]
STN_beta_I=[]
for f in [1.]:
STN_beta_I.append(reversed(list(numpy.linspace(f*1.8, f*2.5, len(v)))))
STN_beta_I=zip(*STN_beta_I)
STN_beta_I=reduce(lambda x,y:x+y, STN_beta_I)
for i in range(len(agg)):
agg[i].append(STN_beta_I[i])
#
# M2_rate=[[1.0, 1.1, 1.2] for _ in range(len(agg))]
# M2_rate=reduce(lambda x,y:x+y, M2_rate)
# agg=[[e[:] for e in agg] for _ in range(3)]
# agg=zip(*agg)
# agg=reduce(lambda x,y:x[:]+y[:], agg)
#
# for i in range(len(agg)):
# agg[i].append(M2_rate[i])
# ST_GA_ampa_w=[[0.75,1.] for _ in range(len(agg))]
# ST_GA_ampa_w=reduce(lambda x,y:x+y, ST_GA_ampa_w)
# agg=[[e[:] for e in agg] for _ in range(2)]
# agg=zip(*agg)
# agg=reduce(lambda x,y:x[:]+y[:], agg)
#
# for i in range(len(agg)):
# agg[i].append(ST_GA_ampa_w[i])
EA_rate=[[200.,400., 600.] for _ in range(len(agg))]
EA_rate=reduce(lambda x,y:x+y, EA_rate)
agg=[[e[:] for e in agg] for _ in range(3)]
agg=zip(*agg)
agg=reduce(lambda x,y:x+y, agg)
for i in range(len(agg)):
agg[i].append(EA_rate[i])
for a0, a1, a2, a4 in agg:
d={}
misc.dict_update(d, solution['mul'])
# dd={'node':{'M1':{'rate':a3}}}
# dd={'nest':{'ST_GA_ampa':{'weight':a3*0.25}}}
# misc.dict_update(d,dd)
l+=[pl(d, '*', **{'name':''})]
d={}
misc.dict_update(d, solution['equal'])
dd={'node':{'CS':{'rate': float(a0)},
'EA':{'rate':a4}},
'nest':{'GI_ST_gaba':{'weight':a1 },
'ST':{'beta_I_AMPA_1': f_beta_rm(a2),
'beta_I_NMDA_1': f_beta_rm(a2)}}}
misc.dict_update(d,dd)
s='CS_{0}_GPST_{1}_STbI_{2}_EAr_{3}'.format(a0,str(a1)[0:4],str(a2)[0:4], int(a4))
print s
l[-1]+=pl(d, '=', **{'name':s})
return l
def pert_add_oscillations(**kwargs):
amp_base = kwargs.get('amp_base') # Scaling of base frequency
amp_base_skip = kwargs.get(
'amp_base_skip',
[]) #skip amplitude modulation for nuclies in this list
do_reset = kwargs.get(
'do_reset',
True) #reset simulations between runs in engine.py with nest.reset
down_vec = kwargs.get('down_vec') #?
freqs = kwargs.get('freqs') # Frequency amplitude modulation
freq_oscillation = kwargs.get('freq_oscillation')
external_input_mod = kwargs.get('external_input_mod', [])
input_mod = kwargs.get('input_mod', ['C1', 'C2', 'CF', 'CS'])
no_mod = kwargs.get('no_mod', [])
local_num_threads = kwargs.get('local_num_threads')
null_down = kwargs.get('null_down', False)
null_down_STN = kwargs.get('null_down_stn', False)
path_rate_runs = kwargs.get('path_rate_runs')
perturbation_list = kwargs.get('perturbation_list')
sim_time = kwargs.get('sim_time')
size = kwargs.get('size')
STN_amp_mod = kwargs.get('STN_amp_mod', [1.])
tuning_freq_amp_to = kwargs.get('tuning_freq_amp_to', 'M1')
l = perturbation_list
for i in range(len(l)):
l[i] += pl(
{
'simu': {
'do_reset': do_reset,
'sd_params': {
'to_file': True,
'to_memory': False
},
'sim_time': sim_time,
'sim_stop': sim_time,
'local_num_threads': local_num_threads
},
'netw': {
'size': size
}
}, '=')
kw_process = {'freqs': freqs, 'tuning_freq_amp_to': tuning_freq_amp_to}
damp = process(path_rate_runs, **kw_process)
for key in sorted(damp.keys()):
val = damp[key]
print key, numpy.round(val, 2)
ll = []
for j, i, STN_amp, _l in iterator_oscillations(freqs, STN_amp_mod, l):
amp = [numpy.round(damp[_l.name][j], 2), amp_base[j]]
_l = deepcopy(_l)
dd = {}
for key in input_mod:
if key in ['C1', 'C2', 'CF']:
factor = 1
elif key in ['CS']:
factor = STN_amp
if null_down:
down = -1.
elif null_down_STN and key in ['CS']:
down = -1
elif down_vec:
down = down_vec[j]
else:
down = -amp[0] * factor
if key not in amp_base_skip:
amp0 = amp[1]
else:
amp0 = 1.
if amp0 > 1.0:
pass
upp = amp[0]
# print amp, amp0
if (key in no_mod): upp, down = 0., 0.
d = {
'type': 'oscillation2',
'params': {
'p_amplitude_upp': upp * factor,
'p_amplitude_down': down,
'p_amplitude0': amp0,
'freq': freq_oscillation
}
}
dd = misc.dict_update(dd, {'netw': {'input': {key: d}}})
if STN_amp != 1:
_l += pl(
dd, '=',
**{'name': 'amp_{0}_{1}_stn_{2}'.format(upp, amp[1], STN_amp)})
elif down_vec:
_l += pl(dd, '=',
**{'name': 'amp_{0}_{1}_{2}'.format(upp, down, amp[1])})
else:
_l += pl(dd, '=', **{'name': 'amp_{0}_{1}'.format(*[upp, amp[1]])})
if external_input_mod:
dd = {}
for key in external_input_mod:
dd = misc.dict_update(dd, {'node': {key: {'rate': amp0}}})
_l += pl(dd, '*', **{'name': 'EIEA_{0}'.format(amp0)})
ll.append(_l)
return ll
def get(flag='perturbations'):
l=[]
ld=[]
solution=get_solution_eNeuro_rev()
#
# for s in solution:
# print s
# pp(solution)
fEA=3.
fEI=0.9 #*1.6 working solution
fCF=.85
rEI=1700.0*fEI - 100.
rEA=200.0 + 100. #*fEA
rCS=250.0
rES=2000.0
rM2=740.0
rCF=950.0*fCF
d={}
ld.append({'mul':d})
misc.dict_update(d, solution['mul'])
l+=[pl(d, '*', **{'name':''})]
d={}
ld[-1].update({'equal':d})
misc.dict_update(d, solution['equal'])
d['node']['EF']['rate']=rEI
d['node']['EI']['rate']=rEI
d['node']['EA']['rate']=rEA
d['node']['C2']['rate']=rM2
d['node']['CF']['rate']=rCF
misc.dict_update(d, {'node':{'CS':{'rate':rCS}}})
misc.dict_update(d, {'node':{'ES':{'rate':rES}}})
s='rEI_{0}_rEA_{1}_rCS_{2}_rES_{3}_rM2_{4}'.format( rEI, rEA, rCS, rES, rM2 )
l[-1]+=pl(d, '=', **{'name':s})
rEI=800.0*fEI - 100.
rEA=100.0 + 100. #*fEA
rCS=170.0
rES=2000.0
rM2=740.0
rCF=950.0*fCF
d={}
misc.dict_update(d, solution['mul'])
l+=[pl(d, '*', **{'name':''})]
ld.append({'mul':d})
d={}
misc.dict_update(d, solution['equal'])
d['node']['EF']['rate']=rEI
d['node']['EI']['rate']=rEI
d['node']['EA']['rate']=rEA
d['node']['C2']['rate']=rM2
d['node']['CF']['rate']=rCF
misc.dict_update(d, {'node':{'CS':{'rate':rCS}}})
misc.dict_update(d, {'node':{'ES':{'rate':rES}}})
s='rEI_{0}_rEA_{1}_rCS_{2}_rES_{3}_rM2_{4}'.format( rEI, rEA, rCS, rES, rM2 )
l[-1]+=pl(d, '=', **{'name':s})
ld[-1].update({'equal':d})
if flag=='perturbations': return l
if flag=='dictionary': return ld
