def build_parameter_set(parameters, shape=None, dimensionless=False): parameter_list = [] for name, value in parameters.items(): if isinstance(value, larray): value.shape = shape if value.is_homogeneous: value = value.evaluate(simplify=True) if isinstance(value, Sequence): value = value.value.tolist() elif isinstance(value, bool): value = int(value) elif isinstance(value, random.RandomDistribution): rand_distr = value value = nineml.RandomDistributionComponent( name="%s(%s)" % (rand_distr.name, ",".join(str(p) for p in rand_distr.parameters)), definition=nineml.Definition(random_distribution_url_map[rand_distr.name], "random"), parameters=build_parameter_set(map_random_distribution_parameters(rand_distr.name, rand_distr.parameters), dimensionless=True)) else: raise Exception("not supported") else: if isinstance(value, bool): value = int(value) if dimensionless: unit = "dimensionless" elif isinstance(value, basestring): unit = None else: unit = infer_units(name) parameter_list.append(nineml.Property(name, value, unit)) return nineml.PropertySet(*parameter_list)
def to_nineml(self, label): connector_parameters = {} for name in self.__class__.parameter_names: connector_parameters[name] = getattr(self, name) connection_rule = nineml.ConnectionRuleComponent( name="connection rule for projection %s" % label, definition=nineml.Definition(self.definition_url, "connection_generator"), parameters=build_parameter_set(connector_parameters)) return connection_rule
def spiking_component_to_nineml(self, label, shape, inline_definition=False): """ Return a 9ML user layer Component describing the neuron type. (mathematical model + parameterization). """ if inline_definition: definition = self.spiking_component_type_to_nineml() else: definition = self.spiking_component_definition_url return nineml.SpikingNodeType( name="neuron type for population %s" % label, definition=nineml.Definition(definition, "dynamics"), parameters=build_parameter_set(self.spiking_component_parameters, shape))
def synaptic_receptor_component_to_nineml(self, receptor_type, label, shape, inline_definition=False): """ Return a 9ML user layer Component describing the post-synaptic mechanism (mathematical model + parameterization). Note that we use the name "receptor" as a shorthand for "receptor, ion channel and any associated signalling mechanisms". """ if inline_definition: definition = self.synaptic_receptor_component_type_to_nineml(receptor_type) else: definition = self.synaptic_receptor_component_definition_urls[receptor_type] return nineml.SynapseType( name="%s post-synaptic response for %s" % (receptor_type, label), definition=nineml.Definition(definition, "dynamics"), parameters=build_parameter_set(self.synaptic_receptor_parameters[receptor_type], shape))
def to_nineml(self): if self.structure: structure = nineml.Structure( name="structure for %s" % self.label, definition=nineml.Definition( "%s/networkstructures/%s.xml" % (catalog_url, self.structure.__class__.__name__), "structure"), parameters=build_parameter_set( self.structure.get_parameters())) else: structure = None population = nineml.Population( name=self.label, number=len(self), prototype=self.celltype.to_nineml(self.label, (self.size, ))[0], positions=nineml.PositionList(structure=structure)) return population
def to_nineml(self): safe_label = self.label.replace(u"→", "---") connection_rule = self._connector.to_nineml(safe_label) connection_type = nineml.ConnectionType( name="connection type for projection %s" % safe_label, definition=nineml.Definition("%s/connectiontypes/static_synapse.xml" % catalog_url, "dynamics"), parameters=build_parameter_set(self.synapse_type.native_parameters, self.shape)) synaptic_responses = self.post.get_synaptic_response_components(self.receptor_type) synaptic_response, = synaptic_responses projection = nineml.Projection( name=safe_label, source=self.pre.to_nineml(), # or just pass ref, and then resolve later? target=self.post.to_nineml(), rule=connection_rule, synaptic_response=synaptic_response, connection_type=connection_type) return projection
def to_nineml(self): return nineml.CurrentSourceType( name="current source %d" % self.__class__.counter, definition=nineml.Definition("%s/currentsources/%s" % (catalog_url, self.definition_file), "dynamics"), parameters=build_parameter_set(self.parameters))
def to_nineml(self): return nineml.ConnectionType( name="synapse type %d" % self.__class__.counter, definition=nineml.Definition("%s/connectiontypes/%s" % (catalog_url, self.definition_file), "dynamics"), parameters=build_parameter_set(self.parameters))