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)