def initialize(self, **kwds):
self.use_gpu = self.unit_type == 'GPU'
# Gets the key,value pairs in shared_data
for key, val in self.shared_data.iteritems():
setattr(self, key, val)
# Gets the key,value pairs in **kwds
for key, val in kwds.iteritems():
setattr(self, key, val)
# log_info(self.model)
self.model = cPickle.loads(self.model)
# log_info(self.model)
# if model is a string
if type(self.model) is str:
self.model = Equations(self.model)
self.total_steps = int(self.duration / self.dt)
self.neurons = self.nodesize
self.groups = self.groups
# Time slicing
self.input = self.input[0:self.slices * (
len(self.input) /
self.slices)] # makes sure that len(input) is a multiple of slices
self.duration = len(self.input) * self.dt # duration of the input
self.sliced_steps = len(
self.input) / 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 in this worker
self.input = hstack(
(zeros(self.overlap_steps), self.input)
) # add zeros at the beginning because there is no overlap from the previous slice
# Prepares data (generates I_offset, spiketimes, spiketimes_offset)
self.prepare_data()
# Add 'refractory' parameter on the CPU on the CPU only
if not self.use_gpu:
if self.max_refractory is not None:
refractory = 'refractory'
self.model.add_param('refractory', second)
else:
refractory = self.refractory
else:
if self.max_refractory is not None:
refractory = 0 * ms
else:
refractory = self.refractory
# Must recompile the Equations : the functions are not transfered after pickling/unpickling
self.model.compile_functions()
self.group = NeuronGroup(self.N,
model=self.model,
reset=self.reset,
threshold=self.threshold,
refractory=refractory,
max_refractory=self.max_refractory,
method=self.method,
clock=Clock(dt=self.dt))
if self.initial_values is not None:
for param, value in self.initial_values.iteritems():
self.group.state(param)[:] = value
# Injects current in consecutive subgroups, where I_offset have the same value
# on successive intervals
k = -1
for i in hstack(
(nonzero(diff(self.I_offset))[0], len(self.I_offset) - 1)):
I_offset_subgroup_value = self.I_offset[i]
I_offset_subgroup_length = i - k
sliced_subgroup = self.group.subgroup(I_offset_subgroup_length)
input_sliced_values = self.input[
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
if self.use_gpu:
# Select integration scheme according to method
if self.method == 'Euler': scheme = euler_scheme
elif self.method == 'RK': scheme = rk2_scheme
elif self.method == 'exponential_Euler': scheme = exp_euler_scheme
else:
raise Exception(
"The numerical integration method is not valid")
self.mf = GPUModelFitting(self.group,
self.model,
self.input,
self.I_offset,
self.spiketimes,
self.spiketimes_offset,
zeros(self.neurons),
0 * ms,
self.delta,
precision=self.precision,
scheme=scheme)
else:
self.cc = CoincidenceCounter(self.group,
self.spiketimes,
self.spiketimes_offset,
onset=self.onset,
delta=self.delta)
