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:
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]
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)
