class NestCurrentSource(BaseCurrentSource):
"""Base class for a nest source of current to be injected into a neuron."""
def __init__(self, **parameters):
self._device = nest.Create(self.nest_name)
self.cell_list = []
self.parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1, ))
if parameters:
self.parameter_space.update(**parameters)
self.min_delay = state.min_delay
self.dt = state.dt
def inject_into(self, cells):
for id in cells:
if id.local and not id.celltype.injectable:
raise TypeError("Can't inject current into a spike source.")
if isinstance(cells, (Population, PopulationView, Assembly)):
self.cell_list = [cell for cell in cells]
else:
self.cell_list = cells
nest.Connect(self._device,
self.cell_list,
syn_spec={"delay": state.min_delay})
def _delay_correction(self, value):
"""
A change in a device requires a min_delay to take effect at the target
"""
corrected = value - self.min_delay
# set negative times to zero
if isinstance(value, numpy.ndarray):
corrected = numpy.where(corrected > 0, corrected, 0.0)
else:
corrected = max(corrected, 0.0)
return corrected
def record(self):
self.i_multimeter = nest.Create('multimeter',
params={
'record_from': ['I'],
'interval': state.dt
})
nest.Connect(self.i_multimeter, self._device)
def _get_data(self):
events = nest.GetStatus(self.i_multimeter)[0]['events']
# Similar to recording.py: NEST does not record values at
# the zeroth time step, so we add them here.
t_arr = numpy.insert(numpy.array(events['times']), 0, 0.0)
i_arr = numpy.insert(numpy.array(events['I'] / 1000.0), 0, 0.0)
# NEST and pyNN have different concepts of current initiation times
# To keep this consistent across simulators, we will have current
# initiating at the electrode at t_start and effect on cell at next dt
# This requires padding min_delay equivalent period with 0's
pad_length = int(self.min_delay / self.dt)
i_arr = numpy.insert(i_arr[:-pad_length], 0, [0] * pad_length)
return t_arr, i_arr
def __init__(self, **parameters):
self._device = nest.Create(self.nest_name)
self.cell_list = []
parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1,))
parameter_space.update(**parameters)
parameter_space = self.translate(parameter_space)
self.set_native_parameters(parameter_space)
class BaseModelType(object):
"""Base class for standard and native cell and synapse model classes."""
default_parameters = {}
default_initial_values = {}
parameter_checks = {}
def __init__(self, **parameters):
"""
`parameters` should be a mapping object, e.g. a dict
"""
self.parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=None)
if parameters:
self.parameter_space.update(**parameters)
def __repr__(self):
# should really include the parameters explicitly, to be unambiguous
return "%s(<parameters>)" % self.__class__.__name__
@classmethod
def has_parameter(cls, name):
"""Does this model have a parameter with the given name?"""
return name in cls.default_parameters
@classmethod
def get_parameter_names(cls):
"""Return the names of the parameters of this model."""
return list(cls.default_parameters.keys())
def get_schema(self):
"""
Returns the model schema: i.e. a mapping of parameter names to allowed
parameter types.
"""
return dict((name, type(value))
for name, value in self.default_parameters.items())
def describe(self, template='modeltype_default.txt', engine='default'):
"""
Returns a human-readable description of the cell or synapse type.
The output may be customized by specifying a different template
togther with an associated template engine (see ``pyNN.descriptions``).
If template is None, then a dictionary containing the template context
will be returned.
"""
context = {
"name": self.__class__.__name__,
"default_parameters": self.default_parameters,
"default_initial_values": self.default_initial_values,
"parameters": self.parameter_space.
_parameters, # should add a describe() method to ParameterSpace
}
return descriptions.render(engine, template, context)
def parameter_space(self):
timing_parameters = self.timing_dependence.parameter_space
weight_parameters = self.weight_dependence.parameter_space
parameters = ParameterSpace({'weight': self.weight,
'delay': self.delay,
'dendritic_delay_fraction': self.dendritic_delay_fraction},
self.get_schema())
parameters.update(**timing_parameters)
parameters.update(**weight_parameters)
return parameters
def parameter_space(self):
timing_parameters = self.timing_dependence.parameter_space
weight_parameters = self.weight_dependence.parameter_space
parameters = ParameterSpace({'weight': self.weight,
'delay': self.delay,
'dendritic_delay_fraction': self.dendritic_delay_fraction},
self.get_schema())
parameters.update(**timing_parameters)
parameters.update(**weight_parameters)
return parameters
def __init__(self, **parameters):
super(StandardCurrentSource, self).__init__(**parameters)
self.cell_list = []
self.indices = []
simulator.state.current_sources.append(self)
parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1, ))
parameter_space.update(**parameters)
parameter_space = self.translate(parameter_space)
self.set_native_parameters(parameter_space)
def __init__(self, **parameters):
super(StandardCurrentSource, self).__init__(**parameters)
self.cell_list = []
self.indices = []
simulator.state.current_sources.append(self)
parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1,))
parameter_space.update(**parameters)
parameter_space = self.translate(parameter_space)
self.set_native_parameters(parameter_space)
class BaseModelType(object):
"""Base class for standard and native cell and synapse model classes."""
default_parameters = {}
default_initial_values = {}
parameter_checks = {}
def __init__(self, **parameters):
"""
`parameters` should be a mapping object, e.g. a dict
"""
self.parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=None)
if parameters:
self.parameter_space.update(**parameters)
def __repr__(self):
return "%s(<parameters>)" % self.__class__.__name__ # should really include the parameters explicitly, to be unambiguous
@classmethod
def has_parameter(cls, name):
"""Does this model have a parameter with the given name?"""
return name in cls.default_parameters
@classmethod
def get_parameter_names(cls):
"""Return the names of the parameters of this model."""
return list(cls.default_parameters.keys())
def get_schema(self):
"""
Returns the model schema: i.e. a mapping of parameter names to allowed
parameter types.
"""
return dict((name, type(value))
for name, value in self.default_parameters.items())
def describe(self, template='modeltype_default.txt', engine='default'):
"""
Returns a human-readable description of the cell or synapse type.
The output may be customized by specifying a different template
togther with an associated template engine (see ``pyNN.descriptions``).
If template is None, then a dictionary containing the template context
will be returned.
"""
context = {
"name": self.__class__.__name__,
"default_parameters": self.default_parameters,
"default_initial_values": self.default_initial_values,
"parameters": self.parameter_space._parameters, # should add a describe() method to ParameterSpace
}
return descriptions.render(engine, template, context)
class NestCurrentSource(BaseCurrentSource):
"""Base class for a nest source of current to be injected into a neuron."""
def __init__(self, **parameters):
self._device = nest.Create(self.nest_name)
self.cell_list = []
self.parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1,))
if parameters:
self.parameter_space.update(**parameters)
self.min_delay = state.min_delay
self.dt = state.dt
def inject_into(self, cells):
for id in cells:
if id.local and not id.celltype.injectable:
raise TypeError("Can't inject current into a spike source.")
if isinstance(cells, (Population, PopulationView, Assembly)):
self.cell_list = [cell for cell in cells]
else:
self.cell_list = cells
nest.Connect(self._device, self.cell_list, syn_spec={"delay": state.min_delay})
def _delay_correction(self, value):
"""
A change in a device requires a min_delay to take effect at the target
"""
corrected = value - self.min_delay
# set negative times to zero
if isinstance(value, numpy.ndarray):
corrected = numpy.where(corrected > 0, corrected, 0.0)
else:
corrected = max(corrected, 0.0)
return corrected
def record(self):
self.i_multimeter = nest.Create('multimeter', params={'record_from': ['I'], 'interval': state.dt})
nest.Connect(self.i_multimeter, self._device)
def _get_data(self):
events = nest.GetStatus(self.i_multimeter)[0]['events']
# Similar to recording.py: NEST does not record values at
# the zeroth time step, so we add them here.
t_arr = numpy.insert(numpy.array(events['times']), 0, 0.0)
i_arr = numpy.insert(numpy.array(events['I']/1000.0), 0, 0.0)
# NEST and pyNN have different concepts of current initiation times
# To keep this consistent across simulators, we will have current
# initiating at the electrode at t_start and effect on cell at next dt
# This requires padding min_delay equivalent period with 0's
pad_length = int(self.min_delay/self.dt)
i_arr = numpy.insert(i_arr[:-pad_length], 0, [0]*pad_length)
return t_arr, i_arr
def __init__(self, **parameters):
self._devices = []
self.cell_list = []
self._amplitudes = None
self._times = None
self._h_iclamps = {}
parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1, ))
parameter_space.update(**parameters)
parameter_space = self.translate(parameter_space)
self.set_native_parameters(parameter_space)
def __init__(self, **parameters):
self._devices = []
self.cell_list = []
self._amplitudes = None
self._times = None
self._h_iclamps = {}
parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1,))
parameter_space.update(**parameters)
parameter_space = self.translate(parameter_space)
self.set_native_parameters(parameter_space)
def __init__(self, **parameters):
super(StandardCurrentSource, self).__init__(**parameters)
global current_sources
self.cell_list = []
self.indices = []
self.ind = len(current_sources) # Todo use self.indices instead...
current_sources.append(self)
parameter_space = ParameterSpace(self.default_parameters,
self.get_schema(),
shape=(1,))
parameter_space.update(**parameters)
parameter_space = self.translate(parameter_space)
self.set_native_parameters(parameter_space)
