def createNeurone(name, component_info, rng, parameters):
"""
Returns daetoolsComponent object based on the supplied daetoolsComponentInfo object.
There are some special cases which are handled individually such as:
* SpikeSourcePoisson
:param name: string
:param component_info: AL Component object
:param rng: numpy.random.RandomState object
:param parameters: python dictionary 'name' : value
:rtype: daetoolsComponent object
:raises: RuntimeError
"""
neurone = None
"""
ACHTUNG, ACHTUNG!!
We should handle components' with names that mean something. How can we know that
the spike_source_poisson component should be treated differently by a simulator?
The same stands for other types of components.
"""
if component_info.name == 'spike_source_poisson':
if 'rate' in parameters:
# Create daetools quantity and scale it to 'Hz'
rate = pyUnits.quantity(parameters['rate'][0], parameters['rate'][1]).scaleTo(pyUnits.Hz)
#print('spike_source_poisson.rate = %s' % rate)
else:
raise RuntimeError('The SpikeSourcePoisson component: must have [rate] parameter')
if 'duration' in parameters:
# Create daetools quantity and scale it to 's'
duration = pyUnits.quantity(parameters['duration'][0], parameters['duration'][1]).scaleTo(pyUnits.s)
#print('spike_source_poisson.duration = %s' % duration)
else:
raise RuntimeError('The SpikeSourcePoisson component: must have [duration] parameter')
if 't0' in parameters:
# Create daetools quantity and scale it to 's'
t0 = pyUnits.quantity(parameters['t0'][0], parameters['t0'][1]).scaleTo(pyUnits.s)
#print('spike_source_poisson.t0 = %s' % t0)
else:
t0 = 0.0
# Should be rate [Hz] * duration [s]
lambda_ = rate.value * duration.value
spiketimes = createPoissonSpikeTimes(rate, duration, t0, rng, lambda_, rng)
neurone = daetoolsSpikeSource(spiketimes, name, None, '')
else:
neurone = daetoolsComponent(component_info, fixObjectName(name), None, '')
neurone.Nitems = 1
neurone.initialize()
spike_event_port = neurone.getOutletEventPort()
neurone.on_spike_out_action = daetoolsOnSpikeOutAction(neurone, spike_event_port)
neurone.ON_EVENT(spike_event_port, userDefinedActions = [neurone.on_spike_out_action])
return neurone
def __init__(self, name, ul_population, network, population_id):
"""
:param name: string
:param ul_population: UL Population object
:param network: daetoolsPointNeuroneNetwork object
:param population_id: integer
:rtype:
:raises: RuntimeError
"""
self._name = fixObjectName(name)
self._population_id = population_id
self._parameters = network.getComponentParameters(
ul_population.prototype.name)
_component_info = network.getComponentInfo(
ul_population.prototype.name)
self.neurones = [
createNeurone(
'p{0}({1:0>4})'.format(self._population_id, i), # Name
_component_info, # daetoolsComponentInfo object
network.globalRandomNumberGenerator, # RNG
self._parameters # dict with init. parameters
) for i in xrange(0, ul_population.number)
]
def __init__(self, ul_model):
"""
:param ul_model: UL Model object
:raises: RuntimeError
"""
self._name = fixObjectName(ul_model.name)
self._components = {}
self._groups = {}
self._rngs = {}
for name, ul_component in ul_model.components.iteritems():
self._components[name] = creatALFromULComponent(ul_component, self._rngs)
for name, ul_group in ul_model.groups.iteritems():
self._groups[name] = daetoolsGroup(name, ul_group, self)
def __init__(self, ul_model):
"""
:param ul_model: UL Model object
:raises: RuntimeError
"""
self._name = fixObjectName(ul_model.name)
self._components = {}
self._groups = {}
self._rngs = {}
for name, ul_component in ul_model.components.iteritems():
self._components[name] = creatALFromULComponent(
ul_component, self._rngs)
for name, ul_group in ul_model.groups.iteritems():
self._groups[name] = daetoolsGroup(name, ul_group, self)
def __init__(self, name, ul_group, network):
"""
:param name: string
:param ul_group: UL Group object
:param network: daetoolsPointNeuroneNetwork object
:rtype:
:raises: RuntimeError
"""
self._name = fixObjectName(name)
self._populations = {}
self._projections = {}
for i, (name, ul_population) in enumerate(ul_group.populations.iteritems()):
self._populations[name] = daetoolsPopulation(name, ul_population, network, i)
for i, (name, ul_projection) in enumerate(ul_group.projections.items()):
self._projections[name] = daetoolsProjection(name, ul_projection, self, network)
def __init__(self, name, ul_group, network):
"""
:param name: string
:param ul_group: UL Group object
:param network: daetoolsPointNeuroneNetwork object
:rtype:
:raises: RuntimeError
"""
self._name = fixObjectName(name)
self._populations = {}
self._projections = {}
for i, (name,
ul_population) in enumerate(ul_group.populations.iteritems()):
self._populations[name] = daetoolsPopulation(
name, ul_population, network, i)
for i, (name,
ul_projection) in enumerate(ul_group.projections.items()):
self._projections[name] = daetoolsProjection(
name, ul_projection, self, network)
def __init__(self, name, ul_population, network, population_id):
"""
:param name: string
:param ul_population: UL Population object
:param network: daetoolsPointNeuroneNetwork object
:param population_id: integer
:rtype:
:raises: RuntimeError
"""
self._name = fixObjectName(name)
self._population_id = population_id
self._parameters = network.getComponentParameters(ul_population.prototype.name)
_component_info = network.getComponentInfo(ul_population.prototype.name)
self.neurones = [
createNeurone(
'p{0}({1:0>4})'.format(self._population_id, i), # Name
_component_info, # daetoolsComponentInfo object
network.globalRandomNumberGenerator, # RNG
self._parameters # dict with init. parameters
) for i in xrange(0, ul_population.number)
]
def __init__(self, name, ul_projection, group, network):
"""
:param name: string
:param ul_projection: UL Projection object
:param group: daetoolsGroup object
:param network: daetoolsPointNeuroneNetwork object
:rtype:
:raises: RuntimeError
"""
self.name = fixObjectName(name)
self.minimal_delay = 1.0e10
if not isinstance(ul_projection.source.prototype, nineml.user_layer.SpikingNodeType):
raise RuntimeError('Currently, only populations of spiking neurones (not groups) are supported')
if not isinstance(ul_projection.target.prototype, nineml.user_layer.SpikingNodeType):
raise RuntimeError('Currently, only populations of spiking neurones (not groups) are supported')
source_population = group.getPopulation(ul_projection.source.name)
target_population = group.getPopulation(ul_projection.target.name)
psr_parameters = network.getComponentParameters(ul_projection.synaptic_response.name)
connection_rule = network.getALComponent(ul_projection.rule.name)
connection_rule_parameters = network.getComponentParameters(ul_projection.rule.name)
connection_type = network.getALComponent(ul_projection.connection_type.name)
psr_component_info = network.getComponentInfo(ul_projection.synaptic_response.name)
source_name = fixObjectName(ul_projection.source.name)
target_name = fixObjectName(ul_projection.target.name)
synapse_name = fixObjectName(ul_projection.synaptic_response.name)
self._synapses = [
daetoolsComponent(
psr_component_info,
's(p{0},p{1})'.format(source_population._population_id, target_population._population_id),
target_population.getNeurone(i),
''
) for i in xrange(0, ul_projection.target.number)
]
for i, neurone in enumerate(target_population.neurones):
neurone.incoming_synapses.append( (self._synapses[i], psr_parameters) )
if 'weight' in psr_parameters:
paramWeight = psr_parameters['weight']
psr_weight_units = paramWeight[1]
else:
raise RuntimeError('Could not find a parameter with the name [weight] in the synapse {0}'.format(model.Name))
#print('connection_rule_parameters: %s' % connection_rule_parameters)
if 'weight' in connection_rule_parameters:
connrule_weight_units = connection_rule_parameters['weight'][1]
else:
raise RuntimeError('Could not find a parameter with the name [weight] in the connection rule {0}'.format(model.Name))
if 'delay' in connection_rule_parameters:
connrule_delay_units = connection_rule_parameters['delay'][1]
else:
raise RuntimeError('Could not find a parameter with the name [delay] in the connection rule {0}'.format(model.Name))
# Create an object that supports the Geometry interface
geometry = geometryFromProjection(ul_projection)
#print('Metric({0},{1}) = {2}'.format(0, 15, geometry.metric(0, 15)))
# Create an object that supports the ConnectionGenerator interface and set-up connections
mask = connection_generator.Mask([(0, ul_projection.source.number - 1)], [(0, ul_projection.target.number - 1)])
cgi = connectionGeneratorFromProjection(ul_projection, geometry)
cgi.setMask(mask)
self.createConnections(cgi, source_population, target_population, psr_weight_units, connrule_weight_units, connrule_delay_units)
# Now we are done with connections. Initialize synapses
for i, neurone in enumerate(target_population.neurones):
synapse = self._synapses[i]
synapse.initialize()
neurone.connectAnaloguePorts(synapse, neurone)
def createNeurone(name, component_info, rng, parameters):
"""
Returns daetoolsComponent object based on the supplied daetoolsComponentInfo object.
There are some special cases which are handled individually such as:
* SpikeSourcePoisson
:param name: string
:param component_info: AL Component object
:param rng: numpy.random.RandomState object
:param parameters: python dictionary 'name' : value
:rtype: daetoolsComponent object
:raises: RuntimeError
"""
neurone = None
"""
ACHTUNG, ACHTUNG!!
We should handle components' with names that mean something. How can we know that
the spike_source_poisson component should be treated differently by a simulator?
The same stands for other types of components.
"""
if component_info.name == 'spike_source_poisson':
if 'rate' in parameters:
# Create daetools quantity and scale it to 'Hz'
rate = pyUnits.quantity(parameters['rate'][0],
parameters['rate'][1]).scaleTo(pyUnits.Hz)
#print('spike_source_poisson.rate = %s' % rate)
else:
raise RuntimeError(
'The SpikeSourcePoisson component: must have [rate] parameter')
if 'duration' in parameters:
# Create daetools quantity and scale it to 's'
duration = pyUnits.quantity(parameters['duration'][0],
parameters['duration'][1]).scaleTo(
pyUnits.s)
#print('spike_source_poisson.duration = %s' % duration)
else:
raise RuntimeError(
'The SpikeSourcePoisson component: must have [duration] parameter'
)
if 't0' in parameters:
# Create daetools quantity and scale it to 's'
t0 = pyUnits.quantity(parameters['t0'][0],
parameters['t0'][1]).scaleTo(pyUnits.s)
#print('spike_source_poisson.t0 = %s' % t0)
else:
t0 = 0.0
# Should be rate [Hz] * duration [s]
lambda_ = rate.value * duration.value
spiketimes = createPoissonSpikeTimes(rate, duration, t0, rng, lambda_,
rng)
neurone = daetoolsSpikeSource(spiketimes, name, None, '')
else:
neurone = daetoolsComponent(component_info, fixObjectName(name), None,
'')
neurone.Nitems = 1
neurone.initialize()
spike_event_port = neurone.getOutletEventPort()
neurone.on_spike_out_action = daetoolsOnSpikeOutAction(
neurone, spike_event_port)
neurone.ON_EVENT(spike_event_port,
userDefinedActions=[neurone.on_spike_out_action])
return neurone
def __init__(self, name, ul_projection, group, network):
"""
:param name: string
:param ul_projection: UL Projection object
:param group: daetoolsGroup object
:param network: daetoolsPointNeuroneNetwork object
:rtype:
:raises: RuntimeError
"""
self.name = fixObjectName(name)
self.minimal_delay = 1.0e10
if not isinstance(ul_projection.source.prototype,
nineml.user_layer.SpikingNodeType):
raise RuntimeError(
'Currently, only populations of spiking neurones (not groups) are supported'
)
if not isinstance(ul_projection.target.prototype,
nineml.user_layer.SpikingNodeType):
raise RuntimeError(
'Currently, only populations of spiking neurones (not groups) are supported'
)
source_population = group.getPopulation(ul_projection.source.name)
target_population = group.getPopulation(ul_projection.target.name)
psr_parameters = network.getComponentParameters(
ul_projection.synaptic_response.name)
connection_rule = network.getALComponent(ul_projection.rule.name)
connection_rule_parameters = network.getComponentParameters(
ul_projection.rule.name)
connection_type = network.getALComponent(
ul_projection.connection_type.name)
psr_component_info = network.getComponentInfo(
ul_projection.synaptic_response.name)
source_name = fixObjectName(ul_projection.source.name)
target_name = fixObjectName(ul_projection.target.name)
synapse_name = fixObjectName(ul_projection.synaptic_response.name)
self._synapses = [
daetoolsComponent(
psr_component_info,
's(p{0},p{1})'.format(source_population._population_id,
target_population._population_id),
target_population.getNeurone(i), '')
for i in xrange(0, ul_projection.target.number)
]
for i, neurone in enumerate(target_population.neurones):
neurone.incoming_synapses.append(
(self._synapses[i], psr_parameters))
if 'weight' in psr_parameters:
paramWeight = psr_parameters['weight']
psr_weight_units = paramWeight[1]
else:
raise RuntimeError(
'Could not find a parameter with the name [weight] in the synapse {0}'
.format(model.Name))
#print('connection_rule_parameters: %s' % connection_rule_parameters)
if 'weight' in connection_rule_parameters:
connrule_weight_units = connection_rule_parameters['weight'][1]
else:
raise RuntimeError(
'Could not find a parameter with the name [weight] in the connection rule {0}'
.format(model.Name))
if 'delay' in connection_rule_parameters:
connrule_delay_units = connection_rule_parameters['delay'][1]
else:
raise RuntimeError(
'Could not find a parameter with the name [delay] in the connection rule {0}'
.format(model.Name))
# Create an object that supports the Geometry interface
geometry = geometryFromProjection(ul_projection)
#print('Metric({0},{1}) = {2}'.format(0, 15, geometry.metric(0, 15)))
# Create an object that supports the ConnectionGenerator interface and set-up connections
mask = connection_generator.Mask(
[(0, ul_projection.source.number - 1)],
[(0, ul_projection.target.number - 1)])
cgi = connectionGeneratorFromProjection(ul_projection, geometry)
cgi.setMask(mask)
self.createConnections(cgi, source_population, target_population,
psr_weight_units, connrule_weight_units,
connrule_delay_units)
# Now we are done with connections. Initialize synapses
for i, neurone in enumerate(target_population.neurones):
synapse = self._synapses[i]
synapse.initialize()
neurone.connectAnaloguePorts(synapse, neurone)