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