Networks

Networks#

Network descriptions for NeuroML 2. Describes network elements containing populations ( potentially of type populationList, and so specifying a list of cell locations ), projections ( i.e. lists of connections ) and inputs.

Original ComponentType definitions: Networks.xml. Schema against which NeuroML based on these should be valid: NeuroML_v2.3.xsd. Generated on 14/08/24 from this commit. Please file any issues or questions at the issue tracker here.

network#

extends baseStandalone

Network containing: populations ( potentially of type populationList, and so specifying a list of cell locations ); projections ( with lists of connections ) and/or explicitConnections; and inputLists ( with lists of inputs ) and/or explicitInputs. Note: often in NeuroML this will be of type networkWithTemperature if there are temperature dependent elements ( e.g. ion channels ).

Children list

regions		region
populations		basePopulation
projections		projection
synapticConnections		explicitConnection
electricalProjection		electricalProjection
continuousProjection		continuousProjection
explicitInputs		explicitInput
inputs		inputList

Schema

<xs:complexType name="Network">
  <xs:complexContent>
    <xs:extension base="Standalone">
      <xs:sequence>
        <xs:element name="space" type="Space" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="region" type="Region" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="extracellularProperties" type="ExtracellularPropertiesLocal" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="population" type="Population" maxOccurs="unbounded"/>
        <xs:element name="cellSet" type="CellSet" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="synapticConnection" type="SynapticConnection" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="projection" type="Projection" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="electricalProjection" type="ElectricalProjection" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="continuousProjection" type="ContinuousProjection" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="explicitInput" type="ExplicitInput" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="inputList" type="InputList" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="type" type="networkTypes" use="optional"/>
      <xs:attribute name="temperature" type="Nml2Quantity_temperature" use="optional"/>
      <xs:attribute name="neuroLexId" type="NeuroLexId" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import Network
from neuroml.utils import component_factory

variable = component_factory(
    Network,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    type: 'a networkTypes (optional)' = None,
    temperature: 'a Nml2Quantity_temperature (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    spaces: 'list of Space(s) (optional)' = None,
    regions: 'list of Region(s) (optional)' = None,
    extracellular_properties: 'list of ExtracellularPropertiesLocal(s) (optional)' = None,
    populations: 'list of Population(s) (required)' = None,
    cell_sets: 'list of CellSet(s) (optional)' = None,
    synaptic_connections: 'list of SynapticConnection(s) (optional)' = None,
    projections: 'list of Projection(s) (optional)' = None,
    electrical_projections: 'list of ElectricalProjection(s) (optional)' = None,
    continuous_projections: 'list of ContinuousProjection(s) (optional)' = None,
    explicit_inputs: 'list of ExplicitInput(s) (optional)' = None,
    input_lists: 'list of InputList(s) (optional)' = None,
)

Usage: XML

<network id="net1">
    <population id="iafPop1" component="iaf" size="1"/>
    <population id="iafPop2" component="iaf" size="1"/>
    <population id="iafPop3" component="iaf" size="1"/>
    <continuousProjection id="testLinearGradedConn" presynapticPopulation="iafPop1" postsynapticPopulation="iafPop2">
        <continuousConnection id="0" preCell="0" postCell="0" preComponent="silent1" postComponent="gs1"/>
    </continuousProjection>
    <continuousProjection id="testGradedConn" presynapticPopulation="iafPop1" postsynapticPopulation="iafPop3">
        <continuousConnection id="0" preCell="0" postCell="0" preComponent="silent2" postComponent="gs2"/>
    </continuousProjection>
    <explicitInput target="iafPop1[0]" input="pulseGen1" destination="synapses"/>
    <explicitInput target="iafPop1[0]" input="pulseGen2" destination="synapses"/>
    <explicitInput target="iafPop1[0]" input="pulseGen3" destination="synapses"/>
</network>

<network id="net2">
    <population id="hhPop1" component="hhcell" size="1" type="populationList">
        <instance id="0">
            <location x="0" y="0" z="0"/>
        </instance>
    </population>
    <population id="hhPop2" component="hhcell" size="1" type="populationList">
        <instance id="0">
            <location x="100" y="0" z="0"/>
        </instance>
    </population>
    <continuousProjection id="testGradedConn" presynapticPopulation="hhPop1" postsynapticPopulation="hhPop2">
        <continuousConnectionInstanceW id="0" preCell="../hhPop1/0/hhcell" postCell="../hhPop2/0/hhcell" preComponent="silent1" postComponent="gs1" weight="1"/>
    </continuousProjection>
    <inputList id="i1" component="pulseGen1" population="hhPop1">
        <input id="0" target="../hhPop1/0/hhcell" destination="synapses"/>
    </inputList>
</network>

<network id="PyrCellNet">
    <population id="Population1" component="PyrCell" extracellularProperties="extracellular" size="9"> 
        </population>
    <projection id="Proj1" presynapticPopulation="Population1" postsynapticPopulation="Population1" synapse="AMPA">
           
        </projection>
</network>

networkWithTemperature#

extends network

Same as network, but with an explicit temperature for temperature dependent elements ( e.g. ion channels ).

Parameters

temperature

temperature

basePopulation#

extends baseStandalone

A population of multiple instances of a specific component, which anything which extends baseCell.

Component References

component

baseCell

Child list

notes		notes
annotation		annotation

Children list

property

property

population#

extends basePopulation

A population of components, with just one parameter for the size, i.e. number of components to create. Note: quite often this is used with type= populationList which means the size is determined by the number of instances ( with locations ) in the list. The size attribute is still set, and there will be a validation error if this does not match the number in the list.

Parameters

size

Number of instances of this Component to create when the population is instantiated

Dimensionless

Schema

<xs:complexType name="Population">
  <xs:complexContent>
    <xs:extension base="Standalone">
      <xs:choice>
        <xs:element name="layout" type="Layout" minOccurs="0"/>
        <xs:element name="instance" type="Instance" maxOccurs="unbounded"/>
      </xs:choice>
      <xs:attribute name="component" type="NmlId" use="required"/>
      <xs:attribute name="size" type="NonNegativeInteger" use="optional"/>
      <xs:attribute name="type" type="populationTypes" use="optional"/>
      <xs:attribute name="extracellularProperties" type="NmlId" use="optional"/>
      <xs:attribute name="neuroLexId" type="NeuroLexId" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import Population
from neuroml.utils import component_factory

variable = component_factory(
    Population,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    component: 'a NmlId (required)' = None,
    size: 'a NonNegativeInteger (optional)' = None,
    type: 'a populationTypes (optional)' = None,
    extracellular_properties: 'a NmlId (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    layout: 'a Layout (optional)' = None,
    instances: 'list of Instance(s) (required)' = None,
)

Usage: XML

<population id="iafPop1" component="iaf" size="1"/>

<population id="iafPop2" component="iaf" size="1"/>

<population id="iafPop3" component="iaf" size="1"/>

populationList#

extends basePopulation

An explicit list of instances ( with locations ) of components in the population.

Text fields

size

Note: the size of the populationList to create is set by the number of explicitly defined instances. The size attribute is still set, and there will be a validation error if this does not match the number in the list.

Children list

instances

instance

instance#

Specifies a single instance of a component in a population ( placed at location ).

Child list

location

location

Schema

<xs:complexType name="Instance">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:sequence>
        <xs:element name="location" type="Location"/>
      </xs:sequence>
      <xs:attribute name="id" type="xs:nonNegativeInteger"/>
      <xs:attribute name="i" type="xs:nonNegativeInteger"/>
      <xs:attribute name="j" type="xs:nonNegativeInteger"/>
      <xs:attribute name="k" type="xs:nonNegativeInteger"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import Instance
from neuroml.utils import component_factory

variable = component_factory(
    Instance,
    id: 'a nonNegativeInteger (optional)' = None,
    i: 'a nonNegativeInteger (optional)' = None,
    j: 'a nonNegativeInteger (optional)' = None,
    k: 'a nonNegativeInteger (optional)' = None,
    location: 'a Location (required)' = None,
)

Usage: XML

<instance id="0">
    <location x="0" y="0" z="0"/>
</instance>

<instance id="0">
    <location x="100" y="0" z="0"/>
</instance>

<instance id="0">
    <location x="0" y="0" z="0"/>
</instance>

location#

Specifies the ( x, y, z ) location of a single instance of a component in a population.

Parameters

x		Dimensionless
y		Dimensionless
z		Dimensionless

Schema

<xs:complexType name="Location">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="x" type="xs:float" use="required"/>
      <xs:attribute name="y" type="xs:float" use="required"/>
      <xs:attribute name="z" type="xs:float" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import Location
from neuroml.utils import component_factory

variable = component_factory(
    Location,
    x: 'a float (required)' = None,
    y: 'a float (required)' = None,
    z: 'a float (required)' = None,
)

Usage: XML

<location x="0" y="0" z="0"/>

<location x="100" y="0" z="0"/>

<location x="0" y="0" z="0"/>

region#

Initial attempt to specify 3D region for placing cells. Work in progress…

Child list

rectangularExtent

rectangularExtent

Schema

<xs:complexType name="Region">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:any processContents="skip" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="space" type="NmlId" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import Region
from neuroml.utils import component_factory

variable = component_factory(
    Region,
    id: 'a NmlId (required)' = None,
    spaces: 'a NmlId (optional)' = None,
    anytypeobjs_=None,
)

rectangularExtent#

For defining a 3D rectangular box.

Parameters

xLength		Dimensionless
xStart		Dimensionless
yLength		Dimensionless
yStart		Dimensionless
zLength		Dimensionless
zStart		Dimensionless

projection#

Projection from one population, presynapticPopulation to another, postsynapticPopulation, through synapse. Contains lists of connection or connectionWD elements.

Paths

presynapticPopulation
postsynapticPopulation

Component References

synapse

baseSynapse

Children list

connections		connection
connectionsWD		connectionWD

Schema

<xs:complexType name="Projection">
  <xs:complexContent>
    <xs:extension base="BaseProjection">
      <xs:sequence>
        <xs:element name="connection" type="Connection" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="connectionWD" type="ConnectionWD" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="synapse" type="NmlId" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import Projection
from neuroml.utils import component_factory

variable = component_factory(
    Projection,
    id: 'a NmlId (required)' = None,
    presynaptic_population: 'a NmlId (required)' = None,
    postsynaptic_population: 'a NmlId (required)' = None,
    synapse: 'a NmlId (required)' = None,
    connections: 'list of Connection(s) (optional)' = None,
    connection_wds: 'list of ConnectionWD(s) (optional)' = None,
)

Usage: XML

<projection id="Proj1" presynapticPopulation="Population1" postsynapticPopulation="Population1" synapse="AMPA">
           
        </projection>

<projection id="internal1" presynapticPopulation="iafCells" postsynapticPopulation="iafCells" synapse="syn1">
            <synapseComponent component="syn1"/>-->
    <connection id="0" preCellId="../iafCells/0/iaf" postCellId="../iafCells/1/iaf"/>
</projection>

<projection id="internal2" presynapticPopulation="iafCells" postsynapticPopulation="iafCells" synapse="syn2">
    <connection id="0" preCellId="../iafCells/0/iaf" postCellId="../iafCells/2/iaf"/>
</projection>

explicitConnection#

Explicit event connection between components.

Text fields

targetPort

Paths

from
to

connection#

Event connection directly between named components, which gets processed via a new instance of a synapse component which is created on the target component. Normally contained inside a projection element.

Text fields

destination
preFractionAlong
postFractionAlong
preSegmentId
postSegmentId

Paths

preCellId
postCellId

Schema

<xs:complexType name="Connection">
  <xs:complexContent>
    <xs:extension base="BaseConnectionOldFormat">
            </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import Connection
from neuroml.utils import component_factory

variable = component_factory(
    Connection,
    id: 'a NonNegativeInteger (required)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    pre_cell_id: 'a Nml2PopulationReferencePath (required)' = None,
    pre_segment_id: 'a NonNegativeInteger (optional)' = '0',
    pre_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    post_cell_id: 'a Nml2PopulationReferencePath (required)' = None,
    post_segment_id: 'a NonNegativeInteger (optional)' = '0',
    post_fraction_along: 'a ZeroToOne (optional)' = '0.5',
)

Usage: XML

<connection id="0" preCellId="../iafCells/0/iaf" postCellId="../iafCells/1/iaf"/>

<connection id="0" preCellId="../iafCells/0/iaf" postCellId="../iafCells/2/iaf"/>

<connection id="0" preCellId="../pop0/0/MultiCompCell" postCellId="../pop0/1/MultiCompCell" preSegmentId="0" preFractionAlong="0.5" postSegmentId="0" postFractionAlong="0.5"/>

synapticConnection#

extends explicitConnection

Explicit event connection between named components, which gets processed via a new instance of a synapse component which is created on the target component.

Text fields

destination

Paths

from
to

Component References

synapse

baseSynapse

Schema

<xs:complexType name="SynapticConnection">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="neuroLexId" type="NeuroLexId" use="optional"/>
      <xs:attribute name="from" type="Nml2PopulationReferencePath" use="required"/>
      <xs:attribute name="to" type="Nml2PopulationReferencePath" use="required"/>
      <xs:attribute name="synapse" type="NmlId" use="required"/>
      <xs:attribute name="destination" type="NmlId" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import SynapticConnection
from neuroml.utils import component_factory

variable = component_factory(
    SynapticConnection,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    from_: 'a Nml2PopulationReferencePath (required)' = None,
    to: 'a Nml2PopulationReferencePath (required)' = None,
    synapse: 'a NmlId (required)' = None,
    destination: 'a NmlId (optional)' = None,
)

synapticConnectionWD#

extends synapticConnection

Explicit event connection between named components, which gets processed via a new instance of a synapse component which is created on the target component, includes setting of weight and delay for the synaptic connection.

Parameters

delay		time
weight		Dimensionless

Paths

from
to

connectionWD#

extends connection

Event connection between named components, which gets processed via a new instance of a synapse component which is created on the target component, includes setting of weight and delay for the synaptic connection.

Parameters

delay		time
weight		Dimensionless

Text fields

destination
preFractionAlong
postFractionAlong
preSegmentId
postSegmentId

Paths

preCellId
postCellId

Schema

<xs:complexType name="ConnectionWD">
  <xs:complexContent>
    <xs:extension base="BaseConnectionOldFormat">
      <xs:attribute name="weight" type="xs:float" use="required"/>
      <xs:attribute name="delay" type="Nml2Quantity_time" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import ConnectionWD
from neuroml.utils import component_factory

variable = component_factory(
    ConnectionWD,
    id: 'a NonNegativeInteger (required)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    pre_cell_id: 'a Nml2PopulationReferencePath (required)' = None,
    pre_segment_id: 'a NonNegativeInteger (optional)' = '0',
    pre_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    post_cell_id: 'a Nml2PopulationReferencePath (required)' = None,
    post_segment_id: 'a NonNegativeInteger (optional)' = '0',
    post_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    weight: 'a float (required)' = None,
    delay: 'a Nml2Quantity_time (required)' = None,
)

Usage: XML

<connectionWD id="0" preCellId="../pop_EIF_cond_exp_isfa_ista[0]" postCellId="../pop_target[0]" weight="0.01" delay="10ms"/>

<connectionWD id="0" preCellId="../pop_EIF_cond_alpha_isfa_ista[0]" postCellId="../pop_target[1]" weight="0.005" delay="20ms"/>

<connectionWD id="0" preCellId="../pop_IF_curr_alpha[0]" postCellId="../pop_target[2]" weight="1" delay="30ms"/>

electricalConnection#

To enable connections between populations through gap junctions.

Component References

synapse

gapJunction

Schema

<xs:complexType name="ElectricalConnection">
  <xs:complexContent>
    <xs:extension base="BaseConnectionNewFormat">
      <xs:attribute name="synapse" type="NmlId" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import ElectricalConnection
from neuroml.utils import component_factory

variable = component_factory(
    ElectricalConnection,
    id: 'a NonNegativeInteger (required)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    pre_cell: 'a string (required)' = None,
    pre_segment: 'a NonNegativeInteger (optional)' = '0',
    pre_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    post_cell: 'a string (required)' = None,
    post_segment: 'a NonNegativeInteger (optional)' = '0',
    post_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    synapse: 'a NmlId (required)' = None,
    extensiontype_=None,
)

Usage: XML

<electricalConnection id="0" preCell="0" postCell="0" synapse="gj1"/>

electricalConnectionInstance#

To enable connections between populations through gap junctions. Populations need to be of type populationList and contain instance and location elements.

Text fields

preFractionAlong
postFractionAlong
preSegment
postSegment

Paths

preCell
postCell

Component References

synapse

gapJunction

Schema

<xs:complexType name="ElectricalConnectionInstance">
  <xs:complexContent>
    <xs:extension base="ElectricalConnection"/>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import ElectricalConnectionInstance
from neuroml.utils import component_factory

variable = component_factory(
    ElectricalConnectionInstance,
    id: 'a NonNegativeInteger (required)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    pre_cell: 'a string (required)' = None,
    pre_segment: 'a NonNegativeInteger (optional)' = '0',
    pre_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    post_cell: 'a string (required)' = None,
    post_segment: 'a NonNegativeInteger (optional)' = '0',
    post_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    synapse: 'a NmlId (required)' = None,
    extensiontype_=None,
)

Usage: XML

<electricalConnectionInstance id="0" preCell="../iafPop1/0/iaf" postCell="../iafPop2/0/iaf" preSegment="0" preFractionAlong="0.5" postSegment="0" postFractionAlong="0.5" synapse="gj1"/>

electricalConnectionInstanceW#

extends electricalConnectionInstance

To enable connections between populations through gap junctions. Populations need to be of type populationList and contain instance and location elements. Includes setting of weight for the connection.

Parameters

weight

Dimensionless

Text fields

preFractionAlong
postFractionAlong
preSegment
postSegment

Paths

preCell
postCell

Schema

<xs:complexType name="ElectricalConnectionInstanceW">
  <xs:complexContent>
    <xs:extension base="ElectricalConnectionInstance">
      <xs:attribute name="weight" type="xs:float" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import ElectricalConnectionInstanceW
from neuroml.utils import component_factory

variable = component_factory(
    ElectricalConnectionInstanceW,
    id: 'a NonNegativeInteger (required)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    pre_cell: 'a string (required)' = None,
    pre_segment: 'a NonNegativeInteger (optional)' = '0',
    pre_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    post_cell: 'a string (required)' = None,
    post_segment: 'a NonNegativeInteger (optional)' = '0',
    post_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    synapse: 'a NmlId (required)' = None,
    weight: 'a float (required)' = None,
)

electricalProjection#

A projection between presynapticPopulation to another postsynapticPopulation through gap junctions.

Component References

presynapticPopulation		population
postsynapticPopulation		population

Children list

connections		electricalConnection
connectionInstances		electricalConnectionInstance

Schema

<xs:complexType name="ElectricalProjection">
  <xs:complexContent>
    <xs:extension base="BaseProjection">
      <xs:sequence>
        <xs:element name="electricalConnection" type="ElectricalConnection" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="electricalConnectionInstance" type="ElectricalConnectionInstance" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="electricalConnectionInstanceW" type="ElectricalConnectionInstanceW" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import ElectricalProjection
from neuroml.utils import component_factory

variable = component_factory(
    ElectricalProjection,
    id: 'a NmlId (required)' = None,
    presynaptic_population: 'a NmlId (required)' = None,
    postsynaptic_population: 'a NmlId (required)' = None,
    electrical_connections: 'list of ElectricalConnection(s) (optional)' = None,
    electrical_connection_instances: 'list of ElectricalConnectionInstance(s) (optional)' = None,
    electrical_connection_instance_ws: 'list of ElectricalConnectionInstanceW(s) (optional)' = None,
)

Usage: XML

<electricalProjection id="testGJconn" presynapticPopulation="iafPop1" postsynapticPopulation="iafPop2">
    <electricalConnectionInstance id="0" preCell="../iafPop1/0/iaf" postCell="../iafPop2/0/iaf" preSegment="0" preFractionAlong="0.5" postSegment="0" postFractionAlong="0.5" synapse="gj1"/>
</electricalProjection>

<electricalProjection id="testGJconn" presynapticPopulation="iafPop1" postsynapticPopulation="iafPop2">
    <electricalConnection id="0" preCell="0" postCell="0" synapse="gj1"/>
</electricalProjection>

continuousConnection#

An instance of a connection in a continuousProjection between presynapticPopulation to another postsynapticPopulation through a preComponent at the start and postComponent at the end. Can be used for analog synapses.

Component References

preComponent		baseGradedSynapse
postComponent		baseGradedSynapse

Schema

<xs:complexType name="ContinuousConnection">
  <xs:complexContent>
    <xs:extension base="BaseConnectionNewFormat">
      <xs:attribute name="preComponent" type="NmlId" use="required"/>
      <xs:attribute name="postComponent" type="NmlId" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import ContinuousConnection
from neuroml.utils import component_factory

variable = component_factory(
    ContinuousConnection,
    id: 'a NonNegativeInteger (required)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    pre_cell: 'a string (required)' = None,
    pre_segment: 'a NonNegativeInteger (optional)' = '0',
    pre_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    post_cell: 'a string (required)' = None,
    post_segment: 'a NonNegativeInteger (optional)' = '0',
    post_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    pre_component: 'a NmlId (required)' = None,
    post_component: 'a NmlId (required)' = None,
    extensiontype_=None,
)

Usage: XML

<continuousConnection id="0" preCell="0" postCell="0" preComponent="silent1" postComponent="gs1"/>

<continuousConnection id="0" preCell="0" postCell="0" preComponent="silent2" postComponent="gs2"/>

continuousConnectionInstance#

An instance of a connection in a continuousProjection between presynapticPopulation to another postsynapticPopulation through a preComponent at the start and postComponent at the end. Populations need to be of type populationList and contain instance and location elements. Can be used for analog synapses.

Text fields

preFractionAlong
postFractionAlong
preSegment
postSegment

Paths

preCell
postCell

Component References

preComponent		baseGradedSynapse
postComponent		baseGradedSynapse

Schema

<xs:complexType name="ContinuousConnectionInstance">
  <xs:complexContent>
    <xs:extension base="ContinuousConnection"/>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import ContinuousConnectionInstance
from neuroml.utils import component_factory

variable = component_factory(
    ContinuousConnectionInstance,
    id: 'a NonNegativeInteger (required)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    pre_cell: 'a string (required)' = None,
    pre_segment: 'a NonNegativeInteger (optional)' = '0',
    pre_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    post_cell: 'a string (required)' = None,
    post_segment: 'a NonNegativeInteger (optional)' = '0',
    post_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    pre_component: 'a NmlId (required)' = None,
    post_component: 'a NmlId (required)' = None,
    extensiontype_=None,
)

continuousConnectionInstanceW#

extends continuousConnectionInstance

An instance of a connection in a continuousProjection between presynapticPopulation to another postsynapticPopulation through a preComponent at the start and postComponent at the end. Populations need to be of type populationList and contain instance and location elements. Can be used for analog synapses. Includes setting of weight for the connection.

Parameters

weight

Dimensionless

Text fields

preFractionAlong
postFractionAlong
preSegment
postSegment

Paths

preCell
postCell

Schema

<xs:complexType name="ContinuousConnectionInstanceW">
  <xs:complexContent>
    <xs:extension base="ContinuousConnectionInstance">
      <xs:attribute name="weight" type="xs:float" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import ContinuousConnectionInstanceW
from neuroml.utils import component_factory

variable = component_factory(
    ContinuousConnectionInstanceW,
    id: 'a NonNegativeInteger (required)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    pre_cell: 'a string (required)' = None,
    pre_segment: 'a NonNegativeInteger (optional)' = '0',
    pre_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    post_cell: 'a string (required)' = None,
    post_segment: 'a NonNegativeInteger (optional)' = '0',
    post_fraction_along: 'a ZeroToOne (optional)' = '0.5',
    pre_component: 'a NmlId (required)' = None,
    post_component: 'a NmlId (required)' = None,
    weight: 'a float (required)' = None,
)

Usage: XML

<continuousConnectionInstanceW id="0" preCell="../hhPop1/0/hhcell" postCell="../hhPop2/0/hhcell" preComponent="silent1" postComponent="gs1" weight="1"/>

continuousProjection#

A projection between presynapticPopulation and postsynapticPopulation through components preComponent at the start and postComponent at the end of a continuousConnection or continuousConnectionInstance. Can be used for analog synapses.

Component References

presynapticPopulation		population
postsynapticPopulation		population

Children list

connections		continuousConnection
connectionInstances		continuousConnectionInstance

Schema

<xs:complexType name="ContinuousProjection">
  <xs:complexContent>
    <xs:extension base="BaseProjection">
      <xs:sequence>
        <xs:element name="continuousConnection" type="ContinuousConnection" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="continuousConnectionInstance" type="ContinuousConnectionInstance" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="continuousConnectionInstanceW" type="ContinuousConnectionInstanceW" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import ContinuousProjection
from neuroml.utils import component_factory

variable = component_factory(
    ContinuousProjection,
    id: 'a NmlId (required)' = None,
    presynaptic_population: 'a NmlId (required)' = None,
    postsynaptic_population: 'a NmlId (required)' = None,
    continuous_connections: 'list of ContinuousConnection(s) (optional)' = None,
    continuous_connection_instances: 'list of ContinuousConnectionInstance(s) (optional)' = None,
    continuous_connection_instance_ws: 'list of ContinuousConnectionInstanceW(s) (optional)' = None,
)

Usage: XML

<continuousProjection id="testLinearGradedConn" presynapticPopulation="iafPop1" postsynapticPopulation="iafPop2">
    <continuousConnection id="0" preCell="0" postCell="0" preComponent="silent1" postComponent="gs1"/>
</continuousProjection>

<continuousProjection id="testGradedConn" presynapticPopulation="iafPop1" postsynapticPopulation="iafPop3">
    <continuousConnection id="0" preCell="0" postCell="0" preComponent="silent2" postComponent="gs2"/>
</continuousProjection>

<continuousProjection id="testGradedConn" presynapticPopulation="hhPop1" postsynapticPopulation="hhPop2">
    <continuousConnectionInstanceW id="0" preCell="../hhPop1/0/hhcell" postCell="../hhPop2/0/hhcell" preComponent="silent1" postComponent="gs1" weight="1"/>
</continuousProjection>

explicitInput#

An explicit input ( anything which extends basePointCurrent ) to a target cell in a population.

Text fields

destination
sourcePort
targetPort

Paths

target

Component References

input

basePointCurrent

Schema

<xs:complexType name="ExplicitInput">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="target" type="Nml2PopulationReferencePath" use="required"/>
      <xs:attribute name="input" type="NmlId" use="required"/>
      <xs:attribute name="destination" type="NmlId"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import ExplicitInput
from neuroml.utils import component_factory

variable = component_factory(
    ExplicitInput,
    target: 'a Nml2PopulationReferencePath (required)' = None,
    input: 'a NmlId (required)' = None,
    destination: 'a NmlId (optional)' = None,
)

Usage: XML

<explicitInput target="iafPop1[0]" input="pulseGen1" destination="synapses"/>

<explicitInput target="iafPop1[0]" input="pulseGen2" destination="synapses"/>

<explicitInput target="iafPop1[0]" input="pulseGen3" destination="synapses"/>

inputList#

An explicit list of inputs to a population..

Text fields

population

Component References

component

basePointCurrent

Children list

inputs

input

Schema

<xs:complexType name="InputList">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="input" type="Input" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="inputW" type="InputW" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="population" type="NmlId" use="required"/>
      <xs:attribute name="component" type="NmlId" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import InputList
from neuroml.utils import component_factory

variable = component_factory(
    InputList,
    id: 'a NonNegativeInteger (required)' = None,
    populations: 'a NmlId (required)' = None,
    component: 'a NmlId (required)' = None,
    input: 'list of Input(s) (optional)' = None,
    input_ws: 'list of InputW(s) (optional)' = None,
)

Usage: XML

<inputList id="i1" component="pulseGen1" population="hhPop1">
    <input id="0" target="../hhPop1/0/hhcell" destination="synapses"/>
</inputList>

<inputList id="i1" component="pulseGen1" population="iafPop1">
    <input id="0" target="../iafPop1/0/iaf" destination="synapses"/>
</inputList>

<inputList id="i2" component="pulseGen2" population="iafPop2">
    <input id="0" target="../iafPop2/0/iaf" destination="synapses"/>
</inputList>

input#

Specifies a single input to a target, optionally giving the segmentId ( default 0 ) and fractionAlong the segment ( default 0.5 ).

Text fields

segmentId	Optional specification of the segment to target, default 0
fractionAlong	Optional specification of the fraction along the specified segment, default 0.5
destination

Paths

target

Schema

<xs:complexType name="Input">
  <xs:complexContent>
    <xs:extension base="BaseNonNegativeIntegerId">
      <xs:attribute name="target" type="Nml2PopulationReferencePath" use="required"/>
      <xs:attribute name="destination" type="NmlId" use="required"/>
      <xs:attribute name="segmentId" type="NonNegativeInteger"/>
      <xs:attribute name="fractionAlong" type="ZeroToOne"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import Input
from neuroml.utils import component_factory

variable = component_factory(
    Input,
    id: 'a NonNegativeInteger (required)' = None,
    target: 'a Nml2PopulationReferencePath (required)' = None,
    destination: 'a NmlId (required)' = None,
    segment_id: 'a NonNegativeInteger (optional)' = None,
    fraction_along: 'a ZeroToOne (optional)' = None,
    extensiontype_=None,
)

Usage: XML

<input id="0" target="../hhPop1/0/hhcell" destination="synapses"/>

<input id="0" target="../iafPop1/0/iaf" destination="synapses"/>

<input id="0" target="../iafPop2/0/iaf" destination="synapses"/>

inputW#

extends input

Specifies input lists. Can set weight to scale individual inputs.

Parameters

weight

Dimensionless

Text fields

destination

Paths

target

Schema

<xs:complexType name="InputW">
  <xs:complexContent>
    <xs:extension base="Input">
      <xs:attribute name="weight" type="xs:float" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

Go to the libNeuroML documentation

from neuroml import InputW
from neuroml.utils import component_factory

variable = component_factory(
    InputW,
    id: 'a NonNegativeInteger (required)' = None,
    target: 'a Nml2PopulationReferencePath (required)' = None,
    destination: 'a NmlId (required)' = None,
    segment_id: 'a NonNegativeInteger (optional)' = None,
    fraction_along: 'a ZeroToOne (optional)' = None,
    weight: 'a float (required)' = None,
)