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)