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
