def __init__(self, n, equations, **parameters): self.start_time = simplify(parameters["start_time"]) self.firing_rate = parameters["firing_rate"] self.duration = simplify(parameters["duration"]) brian2.PoissonGroup.__init__(self, n, rates=self.firing_rate, clock=simulator.state.network.clock) if is_listlike(self.start_time): self.variables.add_array('start_time', size=n, dimensions=second.dim) else: self.variables.add_constant('start_time', value=float(self.start_time), dimensions=second.dim) if is_listlike(self.duration) or is_listlike(self.start_time): self.variables.add_array('end_time', size=n, dimensions=second.dim) self.end_time = self.start_time + self.duration else: self.variables.add_constant('end_time', value=float(self.start_time + self.duration), dimensions=second.dim) self.events = { 'spike': '(t >= start_time) and (t <= end_time) and (rand() < rates * dt)' }
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ ids = self.local_cells.tolist() if hasattr(self.celltype, "uses_parrot") and self.celltype.uses_parrot: ids = [id.source for id in ids] if "spike_times" in names: parameter_dict = { "spike_times": [Sequence(value) for value in nest.GetStatus(ids, names)] } else: parameter_dict = {} for name in names: # one name at a time, since some parameter values may be tuples val = np.array(nest.GetStatus(ids, name)) if isinstance(val[0], tuple) or len(val.shape) == 2: val = np.array([ArrayParameter(v) for v in val]) val = LazyArray(simplify(val), shape=(self.local_size, ), dtype=ArrayParameter) parameter_dict[name] = val else: parameter_dict[name] = simplify(val) ps = ParameterSpace(parameter_dict, shape=(self.local_size, )) return ps
def _set_parameters(self, parameter_space): """parameter_space should contain native parameters""" parameter_space.evaluate(simplify=False) for name, value in parameter_space.items(): if (name == "tau_refrac"): value = simplify(value) self.brian2_group.tau_refrac = value elif (name == "v_reset"): value = simplify(value) self.brian2_group.v_reset = value else: setattr(self.brian2_group, name, value)
def _set_attributes(self, parameter_space): if "tau_minus" in parameter_space.keys() and not parameter_space["tau_minus"].is_homogeneous: raise ValueError("tau_minus cannot be heterogeneous " "within a single Projection with NEST.") # only columns for connections that exist on this machine parameter_space.evaluate(mask=(slice(None), self.post._mask_local)) sources = np.unique(self._sources).tolist() if self._common_synapse_property_names is None: self._identify_common_synapse_properties() for postsynaptic_cell, connection_parameters in zip(self.post.local_cells, parameter_space.columns()): connections = nest.GetConnections(source=sources, target=[postsynaptic_cell], synapse_model=self.nest_synapse_model, synapse_label=self.nest_synapse_label) if connections: source_mask = self.pre.id_to_index([x[0] for x in connections]) for name, value in connection_parameters.items(): if name == "weight" and self.receptor_type == 'inhibitory' and self.post.conductance_based: value *= -1 # NEST uses negative values for inhibitory weights, even if these are conductances if name == "tau_minus": # set on the post-synaptic cell nest.SetStatus(self.post.local_cells.astype(int).tolist(), {"tau_minus": simplify(value)}) elif name not in self._common_synapse_property_names: value = make_sli_compatible(value) if len(source_mask) > 1: nest.SetStatus(connections, name, value[source_mask]) elif isinstance(value, np.ndarray): # OneToOneConnector nest.SetStatus(connections, name, value[source_mask]) else: nest.SetStatus(connections, name, value) else: self._set_common_synapse_property(name, value)
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: parameter_dict[name] = simplify(self._parameters[name]) return ParameterSpace(parameter_dict, shape=(self.size,))
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: parameter_dict[name] = simplify(self._parameters[name]) return ParameterSpace(parameter_dict, shape=(self.local_size, ))
def _get_parameters(self, *names): """Return a ParameterSpace containing native parameters""" parameter_space = {} for name in names: value = simplify(self.celltype.parameter_space[name]) if isinstance(value, np.ndarray): value = value[self.mask] parameter_space[name] = value return ParameterSpace(parameter_space, shape=(self.size, ))
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: if name == 'spike_times': # hack parameter_dict[name] = [Sequence(getattr(id._cell, name)) for id in self] else: val = numpy.array([getattr(id._cell, name) for id in self]) if isinstance(val[0], tuple) or len(val.shape) == 2: val = numpy.array([ArrayParameter(v) for v in val]) val = LazyArray(simplify(val), shape=(self.local_size,), dtype=ArrayParameter) parameter_dict[name] = val else: parameter_dict[name] = simplify(val) parameter_dict[name] = simplify(val) return ParameterSpace(parameter_dict, shape=(self.local_size,))
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: value = simplify(getattr(self.brian_group, name)) parameter_dict[name] = value return ParameterSpace(parameter_dict, shape=(self.size,))
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: value = simplify(getattr(self.brian_group, name)) parameter_dict[name] = value return ParameterSpace(parameter_dict, shape=(self.size, ))
def _get_parameters(self, *names): """Return a ParameterSpace containing native parameters""" parameter_space = {} for name in names: value = self.celltype.parameter_space[name] value = simplify(value) # lazyarray cannot handle np.bool_ if isinstance(value, np.bool_): value = bool(value) parameter_space[name] = value return ParameterSpace(parameter_space, shape=(self.size, ))
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: value = self.parent._parameters[name] if isinstance(value, numpy.ndarray): value = value[self.mask] parameter_dict[name] = simplify(value) return ParameterSpace(parameter_dict, shape=(self.size,)) # or local size?
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: value = getattr(self.brian2_group, name) if hasattr(value, "shape") and value.shape: value = value[self.mask] parameter_dict[name] = simplify(value) return ParameterSpace(parameter_dict, shape=(self.size,))
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: value = simplify(getattr(self.brian_group, name)) if isinstance(value, numpy.ndarray): value = value[self.mask] parameter_dict[name] = value return ParameterSpace(parameter_dict, shape=(self.size, ))
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: if name == "spike_times": # hack parameter_dict[name] = [Sequence(getattr(id._cell, name)) for id in self] else: parameter_dict[name] = simplify(numpy.array([getattr(id._cell, name) for id in self])) return ParameterSpace(parameter_dict, shape=(self.local_size,))
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: value = simplify(getattr(self.brian_group, name)) if isinstance(value, numpy.ndarray): value = value[self.mask] parameter_dict[name] = value return ParameterSpace(parameter_dict, shape=(self.size,))
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: if name == 'spike_times': # hack parameter_dict[name] = [Sequence(getattr(id._cell, name)) for id in self] else: parameter_dict[name] = simplify(numpy.array([getattr(id._cell, name) for id in self])) return ParameterSpace(parameter_dict, shape=(self.local_size,))
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ parameter_dict = {} for name in names: value = self.parent._parameters[name] if isinstance(value, np.ndarray): value = value[self.mask] parameter_dict[name] = simplify(value) return ParameterSpace(parameter_dict, shape=(self.size,)) # or local size?
def __init__(self, n, equations, **parameters): threshold = brian.SimpleFunThreshold(self.check_threshold) period = simplify(parameters['tau_refrac']) assert not hasattr(period, "__len__"), "Brian does not support heterogenerous refractory periods with CustomRefractoriness" reset = brian.SimpleCustomRefractoriness( AdaptiveReset(parameters.pop('v_reset'), parameters.pop('b')), period=period*second) refractory = None BaseNeuronGroup.__init__(self, n, equations, threshold, reset, refractory, **parameters)
def __init__(self, n, equations, **parameters): threshold = brian.SimpleFunThreshold(self.check_threshold) period = simplify(parameters['tau_refrac']) assert not hasattr( period, "__len__" ), "Brian does not support heterogenerous refractory periods with CustomRefractoriness" reset = brian.SimpleCustomRefractoriness(AdaptiveReset( parameters.pop('v_reset'), parameters.pop('b')), period=period * second) refractory = None BaseNeuronGroup.__init__(self, n, equations, threshold, reset, refractory, **parameters)
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ ids = self.local_cells.tolist() if hasattr(self.celltype, "uses_parrot") and self.celltype.uses_parrot: ids = [id.source for id in ids] parameter_array = numpy.array(nest.GetStatus(ids, names)) parameter_dict = dict((name, simplify(parameter_array[:, col])) for col, name in enumerate(names)) if "spike_times" in parameter_dict: # hack parameter_dict["spike_times"] = [Sequence(value) for value in parameter_dict["spike_times"]] return ParameterSpace(parameter_dict, shape=(self.local_size,))
def _get_parameters(self, *names): """ return a ParameterSpace containing native parameters """ ids = self.local_cells.tolist() if hasattr(self.celltype, "uses_parrot") and self.celltype.uses_parrot: ids = [id.source for id in ids] if "spike_times" in names: parameter_dict = {"spike_times": [Sequence(value) for value in nest.GetStatus(ids, names)]} else: parameter_dict = {} for name in names: # one name at a time, since some parameter values may be tuples val = numpy.array(nest.GetStatus(ids, name)) if isinstance(val[0], tuple) or len(val.shape) == 2: val = numpy.array([ArrayParameter(v) for v in val]) val = LazyArray(simplify(val), shape=(self.local_size,), dtype=ArrayParameter) parameter_dict[name] = val else: parameter_dict[name] = simplify(val) ps = ParameterSpace(parameter_dict, shape=(self.local_size,)) return ps
def _set_tau_refrac(self, value): self._refractory = simplify(value)