def __init__(self, neurons, input, spikes = None, traces = None, dt = defaultclock.dt,
slices = 1, overlap = 0*ms, groups = 1,ntrials=1):
self.neurons = neurons # number of particles on the node
self.input = input # a IxT array
self.spikes = spikes # a list of spikes [(i,t)...]
self.traces = traces # a KxT array
self.slices = slices
self.overlap = overlap
self.groups = groups
self.ntrials=ntrials
self.dt = dt
# ensure 2 dimensions
if self.input.ndim == 1:
self.input = self.input.reshape((1,-1))
if self.traces is not None:
if self.traces.ndim == 1:
self.traces = self.traces.reshape((1,-1))
self.inputs_count = self.input.shape[0]
self.T = self.input.shape[1] # number of steps
self.duration = self.T*self.dt
self.subpopsize = self.neurons/self.groups # number of neurons per group: nodesize/groups
self.input = self.input[:,0:self.slices * (self.T / self.slices)] # makes sure that len(input) is a multiple of slices
self.sliced_steps = self.T / self.slices # timesteps per slice
self.overlap_steps = int(self.overlap / self.dt) # timesteps during the overlap
self.total_steps = self.sliced_steps + self.overlap_steps # total number of timesteps
self.sliced_duration = self.overlap + self.duration / self.slices # duration of the vectorized simulation
self.N = self.neurons * self.slices # TOTAL number of neurons on this node
self.input = hstack((zeros((self.inputs_count, self.overlap_steps)), self.input)) # add zeros at the beginning because there is no overlap from the previous slice
def transform_spikes(self, spikes):
# from standard structure to inline structure
i, t = zip(*spikes)
i = array(i)
t = array(t)
alls = []
n = 0
pointers = []
model_target = []
for j in xrange(self.groups):
s = sort(t[i == j])
s = hstack((-1 * second, s, self.duration + 1 * second))
model_target.extend([j] * self.subpopsize)
alls.append(s)
pointers.append(n)
n += len(s)
pointers = array(pointers, dtype=int)
model_target = array(hstack(model_target), dtype=int)
spikes_inline = hstack(alls)
spikes_offset = pointers[model_target]
return spikes_inline, spikes_offset
def inject_input(self):
# Injects current in consecutive subgroups, where I_offset have the same value
# on successive intervals
I_offset = self.inputs_offset
k = -1
for i in hstack((nonzero(diff(I_offset))[0], len(I_offset) - 1)):
I_offset_subgroup_value = I_offset[i]
I_offset_subgroup_length = i - k
sliced_subgroup = self.group.subgroup(I_offset_subgroup_length)
input_sliced_values = self.inputs_inline[I_offset_subgroup_value:I_offset_subgroup_value + self.total_steps]
sliced_subgroup.set_var_by_array(self.input_var, TimedArray(input_sliced_values, clock=self.group.clock))
k = i
def transform_spikes(self, spikes):
# from standard structure to inline structure
i, t = zip(*spikes)
i = array(i)
t = array(t)
alls = []
n = 0
pointers = []
model_target = []
for j in xrange(self.groups):
s = sort(t[i == j])
s = hstack((-1 * second, s, self.duration + 1 * second))
model_target.extend([j] * self.subpopsize)
alls.append(s)
pointers.append(n)
n += len(s)
pointers = array(pointers, dtype=int)
model_target = array(hstack(model_target), dtype=int)
spikes_inline = hstack(alls)
spikes_offset = pointers[model_target]
return spikes_inline, spikes_offset
def transform_trials(self, spikes):
# from standard structure to inline structure
i, t = zip(*spikes)
i = array(i)
t = array(t)
alls = []
n = 0
pointers = []
model_target = []
pointers.append(0)
for j in xrange(self.ntrials):
s = sort(t[i == j])
s = hstack((-1 * second, s, self.duration + 1 * second))
alls.append(s)
pointers.append(pointers[j]+len(s))
pointers.pop()
spikes_inline = hstack(alls)
# print pointers
# print nonzero(spikes_inline==-1)
# show()
return spikes_inline, pointers
