def __init__(self, synapses):
Variable.__init__(self, Unit(1), value=self, constant=True)
self.source = synapses.source
self.target = synapses.target
source_len = len(synapses.source)
target_len = len(synapses.target)
self.synapses = weakref.proxy(synapses)
dtype = smallest_inttype(MAX_SYNAPSES)
self.synaptic_pre = DynamicArray1D(0, dtype=dtype)
self.synaptic_post = DynamicArray1D(0, dtype=dtype)
self.pre_synaptic = [
DynamicArray1D(0, dtype=dtype) for _ in xrange(source_len)
]
self.post_synaptic = [
DynamicArray1D(0, dtype=dtype) for _ in xrange(target_len)
]
self._registered_variables = []
self.variables = {
'i': DynamicArrayVariable('i', Unit(1), self.synaptic_pre),
'j': DynamicArrayVariable('j', Unit(1), self.synaptic_post)
}
self.i = IndexView(self.synaptic_pre, self)
self.j = IndexView(self.synaptic_post, self)
self.k = SynapseIndexView(self)
def reinit(self):
'''
Clears all recorded rates
'''
self._rate = DynamicArray1D(
0,
use_numpy_resize=True,
dtype=brian_prefs['core.default_scalar_dtype'])
self._t = DynamicArray1D(0,
use_numpy_resize=True,
dtype=getattr(self.clock.t, 'dtype',
np.dtype(type(self.clock.t))))
def create_all_to_all(N):
'''
Return a tuple containing `synapses` and `delays` in the form that is needed
for the `SpikeQueue` initializer.
Every synapse has a delay depending on the presynaptic neuron.
'''
data = np.repeat(np.arange(N), N)
delays = DynamicArray1D(data.shape, dtype=np.int32)
delays[:] = data
synapses = [DynamicArray1D(N, dtype=np.int32) for _ in xrange(N)]
for i in xrange(N):
synapses[i][:] = np.arange(N) + i * N
return synapses, delays
def reinit(self):
self._values = dict((v, DynamicArray((0, len(self.indices)),
use_numpy_resize=True,
dtype=self.source.variables[v].dtype))
for v in self.record_variables)
self._t = DynamicArray1D(0, use_numpy_resize=True,
dtype=brian_prefs['core.default_scalar_dtype'])
def test_dynamic_array_1d_shrink():
for numpy_resize in [True, False]:
da = DynamicArray1D(10, use_numpy_resize=numpy_resize)
da[:] = np.arange(10)
da.shrink(5)
assert len(da) == 5
assert all(da[:] == np.arange(5))
# After using shrink, the underlying array should have changed
assert len(da._data) == 5
def test_dynamic_array_2d_access():
da = DynamicArray1D((10, 20))
da[:, :] = np.arange(200).reshape((10, 20))
assert da[5, 10] == 5 * 20 + 10
assert da.shape == (10, 20)
assert len(str(da))
assert len(repr(da))
da[:] += 1
da.data[:] += 1
assert_equal(da[:, :], np.arange(200).reshape((10, 20)) + 2)
def add_array(self, var):
# This creates the actual numpy arrays (or DynamicArrayVariable objects)
if isinstance(var, DynamicArrayVariable):
if var.ndim == 1:
arr = DynamicArray1D(var.size, dtype=var.dtype)
else:
arr = DynamicArray(var.size, dtype=var.dtype)
else:
arr = np.empty(var.size, dtype=var.dtype)
self.arrays[var] = arr
def create_all_to_all(N, dt):
'''
Return a tuple containing `synapses` and `delays` in the form that is needed
for the `SpikeQueue` initializer.
Every synapse has a delay depending on the presynaptic neuron.
'''
data = np.repeat(np.arange(N, dtype=np.int32), N)
delays = DynamicArray1D(data.shape, dtype=np.float64)
delays[:] = data * dt
synapses = data
return synapses, delays
def test_dynamic_array_1d_access():
da = DynamicArray1D(10)
da[:] = np.arange(10)
assert da[7] == 7
assert len(da) == 10
assert da.shape == (10, )
assert len(str(da))
assert len(repr(da))
da[:] += 1
da.data[:] += 1
assert all(da[:] == (np.arange(10) + 2))
def test_dynamic_array_1d_resize_down_up():
for numpy_resize in [True, False]:
da = DynamicArray1D(10, use_numpy_resize=numpy_resize)
da[:] = np.arange(10)
da.resize(5)
assert len(da) == 5
assert da.shape == (5, )
assert all(da[:5] == np.arange(5))
da.resize(10)
assert len(da) == 10
assert da.shape == (10, )
assert all(da[:5] == np.arange(5))
assert all(da[5:] == 0)
def _allocate_memory(self, dtype=None):
# Allocate memory (TODO: this should be refactored somewhere at some point)
arrayvarnames = set(eq.varname for eq in self.equations.itervalues()
if eq.type in (DIFFERENTIAL_EQUATION, PARAMETER))
if self.event_driven is not None:
# Only differential equations are event-driven
arrayvarnames |= set(eq.varname
for eq in self.event_driven.itervalues())
arrays = {}
for name in arrayvarnames:
if isinstance(dtype, dict):
curdtype = dtype[name]
else:
curdtype = dtype
if curdtype is None:
curdtype = brian_prefs['core.default_scalar_dtype']
arrays[name] = DynamicArray1D(0)
logger.debug("NeuronGroup memory allocated successfully.")
return arrays
def __init__(self, synapses, code, prepost, objname=None):
self.code = code
if prepost == 'pre':
self.source = synapses.source
self.target = synapses.target
self.synapse_indices = synapses.item_mapping.pre_synaptic
elif prepost == 'post':
self.source = synapses.target
self.target = synapses.source
self.synapse_indices = synapses.item_mapping.post_synaptic
else:
raise ValueError('prepost argument has to be either "pre" or '
'"post"')
self.synapses = synapses
if objname is None:
objname = prepost + '*'
GroupCodeRunner.__init__(self,
synapses,
'synapses',
code=code,
when=(synapses.clock, 'synapses'),
name=synapses.name + '_' + objname)
self._delays = DynamicArray1D(synapses.N, dtype=np.float64)
# Register the object with the `SynapticIndex` object so it gets
# automatically resized
synapses.item_mapping.register_variable(self._delays)
self.queue = SpikeQueue()
self.spiking_synapses = []
self.variables = {
'_spiking_synapses':
AttributeVariable(Unit(1),
self,
'spiking_synapses',
constant=False),
'_source_offset':
Variable(Unit(1), self.source.offset, constant=True),
'_target_offset':
Variable(Unit(1), self.target.offset, constant=True),
'delay':
DynamicArrayVariable('delay',
second,
self._delays,
group_name=self.name,
constant=True)
}
# Re-extract the last part of the name from the full name
self.objname = self.name[len(synapses.name) + 1:]
#: The simulation dt (necessary for the delays)
self.dt = self.synapses.clock.dt_
self.item_mapping = synapses.item_mapping
self.indices = self.synapses.indices
# Enable access to the delay attribute via the specifier
Group.__init__(self)
