def __init__(self, network, parentRegion = None, ontologyTerm = None, *args, **keywords): """ Regions represent a physical subset of a nervous system. They can also be hierarchical with regions nested within other regions. Regions can also be associated with an entry in one of the :class:`ontologies <Library.Ontology.Ontology>` in the library. You create a region by messaging a network: >>> region1 = network.createRegion(...) """ if ontologyTerm is not None: if 'name' not in keywords: keywords['name'] = ontologyTerm.name if 'abbreviation' not in keywords and ontologyTerm.abbreviation is not None: keywords['abbreviation'] = ontologyTerm.abbreviation NeuroObject.__init__(self, network, *args, **keywords) self.parentRegion = None self.subRegions = [] self.ontologyTerm = ontologyTerm self.arborizations = [] self.pathways = [] self.neurons = [] if parentRegion is not None: parentRegion._addSubRegion(self)
def __init__(self, region1 , region2, region1Projects = None, region1Activation = None, region2Projects = None, region2Activation = None, *args, **keywords): """ Pathways connect pairs of :class:`regions <Network.Region.Region>`. They consist of bundles of :class:`neurites <Network.Neurite.Neurite>` which can be optionally specified. You create a pathway by :meth:`messaging <Network.Region.Region.projectToRegion>` one of the regions: >>> pathway_1_2 = region1.projectToRegion(region2) """ NeuroObject.__init__(self, region1.network, *args, **keywords) self._neurites = [] self.region1 = region1 self.region1Projects = region1Projects self.region1Activation = region1Activation self.region2 = region2 self.region2Projects = region2Projects self.region2Activation = region2Activation
def _includeInScript(self, atTopLevel = False): # If this neurite is just a dummy neurite used to support a simple arborization, innervation, gap junction or synapse then it does not need to be created. from neuron import Neuron connections = self.connections() if not self._needsScriptRef() and isinstance(self.root, Neuron) and len(connections) == 2: connections.remove(self.root) if isinstance(connections[0], (Arborization, Innervation, GapJunction, Synapse)): return False return NeuroObject._includeInScript(self)
def _defaultVisualizationParams(cls): params = NeuroObject._defaultVisualizationParams() params['shape'] = 'Capsule' params['size'] = (.05, .1, .02) params['color'] = (0.75, 0.5, 0.5) try: params['texture'] = neuroptikon.library.texture('Stripes') except: pass params['textureScale'] = 20.0 return params
def outputs(self, recurse = True): """ Return a list of all objects that receive information from this neurite and optionally any extending neurites. The list may contain any number of :class:`arborizations <Network.Arborization.Arborization>`, :class:`gap junctions <Network.GapJunction.GapJunction>`, :class:`innervations <Network.Innervation.Innervation>` or :class:`synapses <Network.Synapse.Synapse>`. """ outputs = NeuroObject.outputs(self, recurse) + self.gapJunctions(False) + self.innervations(False) + self.synapses(includePost = False, recurse = False) if self.arborization is not None and self.arborization.sendsOutput: outputs += [self.arborization] return outputs
def inputs(self, recurse = True): """ Return a list of all objects that send information into this neurite and optionally any extending neurites. The list may contain any number of :class:`arborizations <Network.Arborization.Arborization>`, :class:`gap junctions <Network.GapJunction.GapJunction>`, :class:`stimuli <Network.Stimulus.Stimulus>` or :class:`synapses <Network.Synapse.Synapse>`. """ inputs = NeuroObject.inputs(self, recurse) + self.gapJunctions(False) + self.synapses(includePre = False, recurse = False) if self.arborization is not None and self.arborization.receivesInput: inputs += [self.arborization] return inputs
def __init__(self, network, root, pathway = None, *args, **keywords): """ Neurites represent projections from :class:`neurons <Network.Neuron.Neuron>` or other neurites. You create a neurite by messaging a :meth:`neuron <Network.Neuron.Neuron.extendNeurite>` or :meth:`neurite <Network.Neurite.Neurite.extendNeurite>`: >>> neurite1 = neuron.extendNeurite(...) >>> neurite2 = neurite1.extendNeurite(...) """ NeuroObject.__init__(self, network, *args, **keywords) self.root = root self._neurites = [] self.arborization = None self._synapses = [] self._gapJunctions = [] self._innervations = [] self._pathway = pathway if pathway is not None: pathway.addNeurite(self)
def __init__(self, network, preSynapticNeurite=None, postSynapticPartners=[], activation=None, *args, **keywords): """ A Synapse object represents a chemical synapse between a single pre-synaptic neurite and one or more post-synaptic neurites. Instances of this class are created by using the synapseOn method of :meth:`Neuron <Network.Neuron.Neuron.synapseOn>` and :meth:`Neurite <Network.Neurite.Neurite.synapseOn>` objects. A synapse's activation attribute should be one of None (meaning unknown), 'excitatory' or 'inhibitory'. >>> neuron1.synapseOn(neuron2, activation = 'excitatory') """ NeuroObject.__init__(self, network, *args, **keywords) self.preSynapticNeurite = preSynapticNeurite self.postSynapticPartners = postSynapticPartners self.activation = activation
def _creationScriptParams(self, scriptRefs): args, keywords = NeuroObject._creationScriptParams(self, scriptRefs) args.insert(0, scriptRefs[self.region2.networkId]) if self.region1Projects != True: keywords['knownProjection'] = str(self.region1Projects) elif self.region2Activation is not None: keywords['activation'] = self.region2Activation if self.region2Projects != None: keywords['bidirectional'] = str(self.region2Projects) elif self.region1Activation is not None: keywords['backActivation'] = self.region1Activation return (args, keywords)
def outputs(self, recurse = True): outputs = NeuroObject.outputs(self, recurse) for pathway in self.pathways: if pathway.region1 == self and pathway.region1Projects or pathway.region2 == self and pathway.region2Projects: outputs.append(pathway) for arborization in self.arborizations: if arborization.receivesInput: outputs.append(arborization) if recurse: for subRegion in self.subRegions: outputs += subRegion.outputs() return outputs
def _toXMLElement(self, parentElement): synapseElement = NeuroObject._toXMLElement(self, parentElement) ElementTree.SubElement(synapseElement, 'PreSynapticNeuriteId').text = str( self.preSynapticNeurite.networkId) for partner in self.postSynapticPartners: ElementTree.SubElement(synapseElement, 'PostSynapticPartnerId').text = str( partner.networkId) if self.activation is not None: ElementTree.SubElement(synapseElement, 'Activation').text = self.activation return synapseElement
def _creationScriptParams(self, scriptRefs): args, keywords = NeuroObject._creationScriptParams(self, scriptRefs) postRefs = [] for postPartner in self.postSynapticPartners: if postPartner in scriptRefs: postRefs.append(scriptRefs[postPartner.networkId]) else: postRefs.append(scriptRefs[postPartner.root.networkId]) if len(postRefs) == 1: args.insert(0, postRefs[0]) else: args.insert(0, '(' + ', '.join(postRefs) + ')') return (args, keywords)
def _toXMLElement(self, parentElement): pathwayElement = NeuroObject._toXMLElement(self, parentElement) pathwayElement.set('region1Id', str(self.region1.networkId)) if self.region1Projects != None: pathwayElement.set('region1Projects', str(self.region1Projects).lower()) if self.region1Projects and self.region2Activation is not None: pathwayElement.set('region2Activation', self.region2Activation) pathwayElement.set('region2Id', str(self.region2.networkId)) if self.region2Projects != None: pathwayElement.set('region2Projects', str(self.region2Projects).lower()) if self.region2Projects and self.region1Activation is not None: pathwayElement.set('region1Activation', self.region1Activation) return pathwayElement
def _toXMLElement(self, parentElement): #TODO need to add links and images when I get this working neuronElement = NeuroObject._toXMLElement(self, parentElement) if self.neuronClass is not None: ElementTree.SubElement(neuronElement, 'Class').text = self.neuronClass.identifier for neurotransmitter in self.neurotransmitters: ElementTree.SubElement(neuronElement, 'Neurotransmitter').text = neurotransmitter.identifier if self.activation is not None: ElementTree.SubElement(neuronElement, 'Activation').text = self.activation for function in self._functions: ElementTree.SubElement(neuronElement, 'Function').text = function if self.polarity is not None: ElementTree.SubElement(neuronElement, 'Polarity').text = self.polarity if self.region is not None: ElementTree.SubElement(neuronElement, 'SomaRegionId').text = str(self.region.networkId) for neurite in self._neurites: neurite._toXMLElement(neuronElement) return neuronElement
def _creationScriptParams(self, scriptRefs): args, keywords = NeuroObject._creationScriptParams(self, scriptRefs) if self.neuronClass is not None: keywords['neuronClass'] = 'library.neuronClass(\'' + self.neuronClass.identifier + '\')' if len(self.neurotransmitters) > 0: ntCalls = [] for neurotransmitter in self.neurotransmitters: ntCalls.append('library.neurotransmitter(\'' + neurotransmitter.identifier + '\')') keywords['neurotransmitters'] = '[' + ', '.join(ntCalls) + ']' if self.activation is not None: keywords['activation'] = '\'' + self.activation + '\'' # TODO: this should be 'NeuralActivation.' + self.activation if len(self._functions) > 0: keywords['functions'] = '[Neuron.Function.' + ', Neuron.Function.'.join(self._functions) + ']' if self.polarity is not None: keywords['polarity'] = 'Neuron.Polarity.' + self.polarity if self.region is not None: keywords['region'] = scriptRefs[self.region.networkId] return (args, keywords)
def _toXMLElement(self, parentElement): gapJunctionElement = NeuroObject._toXMLElement(self, parentElement) neurites = list(self._neurites) gapJunctionElement.set('neurite1Id', str(neurites[0].networkId)) gapJunctionElement.set('neurite2Id', str(neurites[1].networkId)) return gapJunctionElement
def outputs(self, recurse=True): return NeuroObject.outputs(self, recurse) + [self.muscle]
def dependentObjects(self): return NeuroObject.dependentObjects(self) + self.innervations()
def inputs(self, recurse=True): return NeuroObject.inputs(self, recurse) + self._innervations
def connections(self, recurse=True): return NeuroObject.connections(self, recurse) + self._innervations
def connections(self, recurse = True): return NeuroObject.connections(self, recurse) + [self.neurite, self.region]
def outputs(self, recurse = True): return NeuroObject.outputs(self, recurse) + self.postSynapticPartners
def connections(self, recurse = True): return NeuroObject.connections(self, recurse) + [self.preSynapticNeurite] + self.postSynapticPartners
def inputs(self, recurse = True): return NeuroObject.inputs(self, recurse) + [self.preSynapticNeurite]
def _defaultVisualizationParams(cls): params = NeuroObject._defaultVisualizationParams() params['size'] = (0.1, 0.1, 0.1) return params
def dependentObjects(self): return NeuroObject.dependentObjects(self) + self.subRegions + self.arborizations + self.pathways + self.neurons
def _creationScriptChildren(self): return NeuroObject._creationScriptChildren(self) + self.subRegions
def connections(self, recurse = True): return NeuroObject.connections(self, recurse) + list(self._neurites)
def _defaultVisualizationParams(cls): params = NeuroObject._defaultVisualizationParams() params['shape'] = 'Line' if hasattr(osgUtil, 'PolytopeIntersector') else 'Cylinder' params['color'] = (1.0, 0.5, 1.0) return params
def outputs(self, recurse = True): return NeuroObject.outputs(self, recurse) + list(self._neurites)
def connections(self, recurse = True): connections = NeuroObject.connections(self, recurse) + self.pathways + self.arborizations if recurse: for subRegion in self.subRegions: connections += subRegion.connections() return connections