def gaussian_model_par(self, types=['C_m'], std_rel=0.1, sead=None):
'''
GaussianModelPar(self, types=['C_m'], std_rel=0.1, sead=None)
Make model parameters gaussian distributed
'''
#! Used identical sead.
if sead:
random.seed(sead)
for par in types:
for node in self.ids:
# OBS Does not work when GetStatus is taken on all nodes. Simulation
# hang. Need to reproduce this on the side and post on my_nest forum.
# sta=my_nest.GetStatus([nodes[0]])[0]
# If node type is proxynode then do nothing. The node is then a
# a shadow node for mpi process as I understand it.
nodetype = my_nest.GetStatus([node])[0]['model']
if nodetype != 'proxynode':
val = my_nest.GetStatus([node], par)[0]
rand = numpy.abs(random.gauss(val, std_rel * val))
if par in ['V_t', 'V_r']: rand = -rand
my_nest.SetStatus([node], {par: rand})
def voltage_response(self, currents, times, start, sim_time, id):
scg = my_nest.Create('step_current_generator', n=1)
my_nest.SetStatus(scg, {
'amplitude_times': times,
'amplitude_values': currents
})
rec = my_nest.GetStatus([id])[0]['receptor_types']
my_nest.Connect(scg, [id], params={'receptor_type': rec['CURR']})
my_nest.MySimulate(sim_time)
self.get_signal('v', 'V_m', start=start, stop=sim_time)
self.get_signal('s') #, start=start, stop=sim_time)
self.signals['V_m'].my_set_spike_peak(15,
spkSignal=self.signals['spikes'])
voltage = self.signals['V_m'][id].signal
times = numpy.arange(0,
len(voltage) * self.mm['params']['interval'],
self.mm['params']['interval'])
if len(times) != len(voltage):
raise Exception('The vectors has to be the same length')
return times, voltage
def model_par_randomize(self):
'''
Example:
self.randomization={ 'C_m':{'active':True,
'gaussian':{'sigma':0.2*C_m, 'my':C_m}}}
'''
pyrngs = self.set_random_states_nest()
for p, val in self.rand.iteritems():
if not val['active']:
continue
local_nodes = []
# st=my_nest.GetStatus(self.ids, ['local', 'gloabal_id', 'vp'])
for _id in self.ids:
ni = my_nest.GetStatus([_id])[0]
if ni['local']:
local_nodes.append((ni['global_id'], ni['vp']))
# local_nodes=[(ni['global_id'], ni['vp'])
# for ni in st if ni['local']]
for gid, vp in local_nodes:
val_rand = numpy.round(get_random_number(pyrngs, vp, val), 2)
# print val_rand
my_nest.SetStatus([gid], {p: val_rand})
def update_spike_times(self,
rates=[],
times=[],
t_stop=None,
ids=None,
seed=None,
idx=None):
if 'poisson_generator' == self.type_model:
t_starts = times
t_stops = list(times[1:]) + list([t_stop])
params = [{
'rate': v[0],
'start': v[1],
'stop': v[2]
} for v in zip(rates, t_starts, t_stops)]
my_nest.SetStatus(self.ids_generator[hash(tuple(idx))], params)
def gaussian_conn_par(self, type='delay', std_rel=0.1, sead=None):
'''
GaussianConnPar(self, type='delay', std_rel=0.1, sead=None)
Make connection parameters gaussian distributed
'''
#! Used identical sead.
if sead:
random.seed(sead)
if not self.connections:
self.find_connections()
for source, targets in self.connections.iteritems():
for target in targets:
conn = my_nest.FindConnections([int(source)], [target])
val = my_nest.GetStatus(conn, type)[0]
my_nest.SetStatus(
conn,
params={type: numpy.abs(random.gauss(val, std_rel * val))})
def set_spike_times(self,
rates=[],
times=[],
t_stop=None,
ids=None,
seed=None,
idx=None):
df = my_nest.GetDefaults(self.model)
if ids is None and (not idx is None):
tmp_ids = numpy.array(self.ids)
ids = list(tmp_ids[idx])
if ids is None:
ids = self.ids
#print df.keys()
#print df['model']
# Spike generator
if 'spike_generator' == df['model']:
for id in ids:
seed = random_integers(0, 10**5)
spikeTimes = misc.inh_poisson_spikes(rates,
times,
t_stop=t_stop,
n_rep=1,
seed=seed)
if any(spikeTimes):
rs = my_nest.GetKernelStatus('resolution')
n_dec = int(-numpy.log10(rs))
spikeTimes = numpy.round(spikeTimes, n_dec)
my_nest.SetStatus([id], params={'spike_times': spikeTimes})
# MIP
elif 'mip_generator' == df['model']:
c = df['p_copy']
seed = random_integers(0, 10**6)
new_ids = []
t_starts = times
t_stops = times[1:] + [t_stop]
for id in ids:
i = 0
for r, start, stop in rates, t_starts, t_stops:
r_mother = r / c
params = {
'rate': r_mother,
'start': start,
'stop': stop,
'p_copy': c,
'mother_seed': seed
}
if i == 0:
nest.SetStatus(id, params)
else:
new_id = my_nest.Create('mip_generator', 1, params)
new_ids.append(new_id)
self.ids.append(new_ids)
# Poisson generator
elif 'poisson_generator' == df['model']:
t_starts = times
t_stops = list(times[1:]) + list([t_stop])
for i in range(len(ids)):
id = ids[i]
model = my_nest.GetStatus([id], 'model')[0]
if model == 'parrot_neuron':
j = 1
else:
ids[i] = my_nest.Create('parrot_neuron')[0]
my_nest.Connect([id], [ids[i]])
#self.ids_mul_visited[id]=True
j = 0
for r, start, stop in zip(rates, t_starts, t_stops):
params = {'rate': r, 'start': start, 'stop': stop}
if j == 0:
#print my_nest.GetStatus([id])
my_nest.SetStatus([id], params)
else:
if params['rate'] != 0:
#print params
new_id = my_nest.Create('poisson_generator', 1,
params)
#self.ids_mul[ids[i]].append(new_id[0])
my_nest.Connect(new_id, [ids[i]])
j += 1
if not idx is None:
tmp_ids = numpy.array(self.ids)
tmp_ids[idx] = list(ids)
self.ids = list(tmp_ids)
else:
self.ids = list(ids)
self.local_ids = list(self.ids) # Nedd to put on locals also
def __init__(self,
model='iaf_neuron',
n=1,
params={},
mm_dt=1.0,
sname='',
spath='',
sname_nb=0,
sd=False,
sd_params={},
mm=False,
record_from=[],
ids=[]):
'''
Constructor
Arguments:
ids provide ids if nodes already created
model my_nest model type, can be a list
n number of model to create, can be a list
params common parameters for model to be set
mm_dt multimeter recording precision
sname file basename
spath Path to save file at
sd boolean, True if spikes should me recorded
mm boolean, True if mulitmeter should record
'''
self.connections = {
} # Set after network has been built with FindConnections
self.ids = []
self.local_ids = []
self.mm = [] # Id of multimeter
self.mm_dt = 0 # Recording interval multimeter
self.model = model
self.params = []
self.record_from = []
self.receptor_types = {}
self.recordables = {}
self.sd = [] # Id of spike detector
self.sd_params = sd_params
self.sname_nb = sname_nb # number for sname string
self.sname = '' # Specific file basename
self.spath = '' # Path to save file at
self.signals = {
} # dictionary with signals for current, conductance, voltage or spikes
if not self.sname:
self.sname = model + '-' + str(sname_nb) + '-'
else:
self.sname = self.snam + '-' + str(sname_nb) + '-'
# If no spath is provided current path plus data_tmp is set to
# spath.
if spath is '':
self.spath = os.getcwd() + '/output_tmp'
else:
self.spath = spath
# Create save dir if it do not exist
try:
msg = os.system('mkdir ' + self.spath + ' 2>/dev/null')
except:
pass
if ids:
self.ids = ids
else:
self.ids = my_nest.Create(model, n, params) # Create models
# Get local ids on this processor. Necessary to have for mpi run.
for id in self.ids:
nodetype = my_nest.GetStatus([id])[0]['model']
if nodetype != 'proxynode':
self.local_ids.append(id)
self.params = my_nest.GetStatus(self.ids)
# Pick out recordables and receptor types using first model.
try:
self.recordables = my_nest.GetDefaults(model)['recordables']
except:
pass
try:
self.receptor_types = my_nest.GetDefaults(model)['receptor_types']
except:
pass
if self.recordables:
if any(record_from):
self.record_from = record_from
else:
self.record_from = self.recordables
# Add spike detector
if sd:
self.sd = my_nest.Create("spike_detector")
self.sd_params.update({"withgid": True})
my_nest.SetStatus(self.sd, self.sd_params)
my_nest.ConvergentConnect(self.ids, self.sd)
# Record with multimeter from first neuron
if mm:
self.mm = my_nest.Create("multimeter")
self.mm_dt = mm_dt # Recording interval
my_nest.SetStatus(self.mm, {
'interval': self.mm_dt,
'record_from': self.record_from
})
my_nest.DivergentConnect(self.mm, self.ids)
def IV_I_clamp(self, I_vec, id=None, tStim=2000):
'''
Assure no simulations has been run before this (reset kernel).
Function that creates I-V by injecting hyperpolarizing currents
and then measuring steady-state membrane (current clamp). Each
trace is preceded and followed by 1/5 of the simulation time
of no stimulation
Inputs:
I_vec - step currents to inject
id - id of neuron to use for calculating I-F relation
tStim - lenght of each step current stimulation in ms
Returns:
I_vec - current for each voltage
vSteadyState - steady state voltage
Examples:
>> n = my_nest.Create('izhik_cond_exp')
>> sc = [ float( x ) for x in range( -300, 100, 50 ) ]
>> tr_t, tr_v, v_ss = IV_I_clamp( id = n, tSim = 500,
I_vec = sc ):
'''
vSteadyState = []
if not id: id = self.ids[0]
if isinstance(id, int): id = [id]
tAcum = 1 # accumulated simulation time, step_current_generator
# recuires it to start at t>0
scg = my_nest.Create('step_current_generator')
rec = my_nest.GetStatus(id)[0]['receptor_types']
my_nest.Connect(scg, id, params={'receptor_type': rec['CURR']})
ampTimes = []
ampValues = []
for I_e in I_vec:
ampTimes.extend([float(tAcum)])
ampValues.extend([float(I_e)])
tAcum += tStim
my_nest.SetStatus(scg,
params={
'amplitude_times': ampTimes,
'amplitude_values': ampValues
})
my_nest.Simulate(tAcum)
self.get_signal('v', 'V_m', stop=tAcum) # retrieve signal
self.get_signal('s')
if 0 < self.signals['spikes'].mean_rate():
print 'hej'
tAcum = 1
for I_e in I_vec:
if 0 >= self.signals['spikes'].mean_rate(tAcum + 10,
tAcum + tStim):
signal = self.signals['V_m'].my_time_slice(
tAcum + 10, tAcum + tStim)
vSteadyState.append(signal[1].signal[-1])
tAcum += tStim
I_vec = I_vec[0:len(vSteadyState)]
return I_vec, vSteadyState
def I_PSE(self, I_vec, synapse_model, id=0, receptor='I_GABAA_1'):
'''
Assure no simulations has been run before this (reset kernel).
Function creates relation between maz size of postsynaptic
event (current, conductance, etc). The type is set by receptor.
Inputs:
I_vec - step currents to clamp at
id - id of neuron to use for calculating I-F relation
If not providet id=ids[0]
Returns:
v_vec - voltage clamped at
size_vec - PSE size at each voltage
Examples:
>> n = my_nest.Create('izhik_cond_exp')
>> sc = [ float( x ) for x in range( -300, 100, 50 ) ]
>> tr_t, tr_v, v_ss = IV_I_clamp( id = n, tSim = 500,
I_vec = sc ):
'''
vSteadyState = []
if not id: id = self.ids[0]
if isinstance(id, int): id = [id]
simTime = 700. # ms
spikes_at = numpy.arange(500., len(I_vec) * simTime, simTime) # ms
voltage = [] # mV
pse = [] # post synaptic event
sg = my_nest.Create('spike_generator',
params={'spike_times': spikes_at})
my_nest.Connect(sg, id, model=synapse_model)
simTimeTot = 0
for I_e in I_vec:
my_nest.SetStatus(self[:], params={'I_e': float(I_e)})
my_nest.MySimulate(simTime)
simTimeTot += simTime
self.get_signal(receptor[0].lower(), receptor,
stop=simTimeTot) # retrieve signal
simTimeAcum = 0
for I_e in I_vec:
size = []
signal = self.signals[receptor].my_time_slice(
400 + simTimeAcum, 700 + simTimeAcum)
simTimeAcum += simTime
# First signal object at position 1
clamped_at = signal[1].signal[999]
minV = min(signal[1].signal)
maxV = max(signal[1].signal)
if abs(minV - clamped_at) < abs(maxV - clamped_at):
size.append(max(signal[1].signal) - clamped_at)
else:
size.append(min(signal[1].signal) - clamped_at)
voltage.append(clamped_at)
pse.append(size[0])
return voltage, pse
def IF(self, I_vec, id=None, tStim=None):
'''
Function that creates I-F curve
Inputs:
id - id of neuron to use for calculating
I-F relation
tStim - lenght of each step current injection
in miliseconds
I_vec - step currents to inject
Returns:
fIsi - first interspike interval
mIsi - mean interspike interval
Examples:
>> n = nest.Create('izhik_cond_exp')
>> sc = [ float( x ) for x in range( 10, 270, 50 ) ]
>> f_isi, m_isi, l_isi = IF_curve( id = n, sim_time = 500, I_vec = sc ):
'''
if not id: id = self.ids[0]
if isinstance(id, int): id = [id]
fIsi, mIsi, lIsi = [], [], [] # first, mean and last isi
if not tStim: tStim = 500.0
tAcum = 0
I_e0 = my_nest.GetStatus(id)[0]['I_e'] # Retrieve neuron base current
isi_list = []
for I_e in I_vec:
my_nest.SetStatus(id, params={'I_e': float(I_e + I_e0)})
my_nest.SetStatus(id, params={'V_m': float(-61)})
#my_nest.SetStatus( id, params = { 'w': float(0) } )
my_nest.SetStatus(id, params={'u': float(0)})
simulate = True
tStart = tAcum
while simulate:
my_nest.Simulate(tStim)
tAcum += tStim
self.get_signal('s', start=tStart, stop=tAcum)
signal = self.signals['spikes'].time_slice(tStart, tAcum)
if signal.mean_rate() > 0.1 or tAcum > 20000:
simulate = False
isi = signal.isi()[0]
if not any(isi): isi = [1000000.]
fIsi.append(isi[0]) # retrieve first isi
mIsi.append(numpy.mean(isi)) # retrieve mean isi
if len(isi) > 100: lIsi.append(isi[-1])
else: lIsi.append(isi[-1]) # retrieve last isi
isi_list.append(numpy.array(isi))
fIsi = numpy.array(fIsi)
mIsi = numpy.array(mIsi)
lIsi = numpy.array(lIsi)
I_vec = numpy.array(I_vec)
return I_vec, fIsi, mIsi, lIsi
def set_spike_times(self,
rates=[],
times=[],
t_stop=None,
ids=None,
seed=None,
idx=None):
df = my_nest.GetDefaults(self.input_model)['model']
if ids is None and (not idx is None):
tmp_ids = numpy.array(self.ids)
ids = list(tmp_ids[idx])
if ids is None:
ids = self.ids
# Spike generator
if 'spike_generator' == self.type_model:
for id in ids:
seed = random_integers(0, 10**5)
spikeTimes = misc.inh_poisson_spikes(rates,
times,
t_stop=t_stop,
n_rep=1,
seed=seed)
if any(spikeTimes):
my_nest.SetStatus([id], params={'spike_times': spikeTimes})
# MIP
elif 'mip_generator' == self.type_model:
c = df['p_copy']
seed = random_integers(0, 10**6)
new_ids = []
t_starts = times
t_stops = times[1:] + [t_stop]
for id in ids:
i = 0
for r, start, stop in rates, t_starts, t_stops:
r_mother = r / c
params = {
'rate': r_mother,
'start': start,
'stop': stop,
'p_copy': c,
'mother_seed': seed
}
if i == 0:
my_nest.SetStatus(id, params)
else:
new_id = my_nest.Create('mip_generator', 1, params)
new_ids.append(new_id)
self.ids.append(new_ids)
# Poisson generator
elif self.type_model in ['my_poisson_generator', 'poisson_generator']:
t_starts = times
t_stops = list(times[1:]) + list([t_stop])
params = [{
'rate': v[0],
'start': v[1],
'stop': v[2]
} for v in zip(rates, t_starts, t_stops)]
if len(params) == 1:
source_nodes = my_nest.Create('poisson_generator', len(params),
params[0]) * len(ids)
else:
source_nodes = my_nest.Create('poisson_generator', len(params),
params) * len(ids)
target_nodes = numpy.array([[id_] * len(rates) for id_ in ids])
target_nodes = list(
numpy.reshape(target_nodes, len(rates) * len(ids), order='C'))
# pp(my_nest.GetStatus([2]))
my_nest.Connect(source_nodes, target_nodes)
generators = []
if hash(tuple(ids)) in self.ids_generator.keys():
generators = self.ids_generator[hash(tuple(idx))]
generators = list(set(source_nodes).union(generators))
self.ids_generator[hash(tuple(idx))] = sorted(generators)
self.local_ids = list(self.ids) # Nedd to put on locals also
elif 'poisson_generator_dynamic' == self.type_model:
source_nodes = my_nest.Create(self.type_model, 1, {
'timings': times,
'rates': rates
}) * len(ids)
target_nodes = ids
my_nest.Connect(source_nodes, target_nodes)
generators = []
if hash(tuple(ids)) in self.ids_generator.keys():
generators = self.ids_generator[hash(tuple(idx))]
generators = list(set(source_nodes).union(generators))
self.ids_generator[hash(tuple(idx))] = sorted(generators)
# v=my_nest.GetStatus(ids, 'local')
# self.local_ids=[_id for _id in zip(ids,v) if # Nedd to put on locals also
else:
msg = 'type_model ' + self.type_model + ' is not accounted for in set_spike_times'
raise ValueError(msg)