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 05/12/23 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 ).

regions

region

populations

basePopulation

projections

projection

synapticConnections

explicitConnection

electricalProjection

electricalProjection

continuousProjection

continuousProjection

explicitInputs

explicitInput

inputs

inputList

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

Go to the libNeuroML documentation

from neuroml import Network

variable = 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,
)
<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 ).

temperature

temperature

basePopulation#

extends baseStandalone

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

component

baseCell

notes

notes

annotation

annotation

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.

size

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

Dimensionless

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

Go to the libNeuroML documentation

from neuroml import Population

variable = 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,
)
<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.

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.

instances

instance

instance#

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

location

location

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

Go to the libNeuroML documentation

from neuroml import Instance

variable = 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,
)
<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.

x

Dimensionless

y

Dimensionless

z

Dimensionless

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

Go to the libNeuroML documentation

from neuroml import Location

variable = Location(
    x: 'a float (required)' = None,
    y: 'a float (required)' = None,
    z: 'a float (required)' = None,
)
<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…

rectangularExtent

rectangularExtent

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

Go to the libNeuroML documentation

from neuroml import Region

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

rectangularExtent#

For defining a 3D rectangular box.

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.

presynapticPopulation

postsynapticPopulation

synapse

baseSynapse

connections

connection

connectionsWD

connectionWD

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

Go to the libNeuroML documentation

from neuroml import Projection

variable = 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,
)
<projection id="Proj1" presynapticPopulation="Population1" postsynapticPopulation="Population1" synapse="AMPA">
           
        </projection>
<projection id="internal1" presynapticPopulation="iafCells" postsynapticPopulation="iafCells" synapse="syn1">
            <!--TODO: Fix! want to define synapse in here, so that multiple synapses per connection can be defined
            <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.

targetPort

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.

destination

preFractionAlong

postFractionAlong

preSegmentId

postSegmentId

preCellId

postCellId

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

Go to the libNeuroML documentation

from neuroml import Connection

variable = 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',
)
<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.

destination

from

to

synapse

baseSynapse

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

Go to the libNeuroML documentation

from neuroml import SynapticConnection

variable = 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.

delay

time

weight

Dimensionless

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.

delay

time

weight

Dimensionless

destination

preFractionAlong

postFractionAlong

preSegmentId

postSegmentId

preCellId

postCellId

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

Go to the libNeuroML documentation

from neuroml import ConnectionWD

variable = 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,
)
<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.

synapse

gapJunction

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

Go to the libNeuroML documentation

from neuroml import ElectricalConnection

variable = 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,
)
<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.

preFractionAlong

postFractionAlong

preSegment

postSegment

preCell

postCell

synapse

gapJunction

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

Go to the libNeuroML documentation

from neuroml import ElectricalConnectionInstance

variable = 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,
)
<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.

weight

Dimensionless

preFractionAlong

postFractionAlong

preSegment

postSegment

preCell

postCell

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

Go to the libNeuroML documentation

from neuroml import ElectricalConnectionInstanceW

variable = 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.

presynapticPopulation

population

postsynapticPopulation

population

connections

electricalConnection

connectionInstances

electricalConnectionInstance

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

Go to the libNeuroML documentation

from neuroml import ElectricalProjection

variable = 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,
)
<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.

preComponent

baseGradedSynapse

postComponent

baseGradedSynapse

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

Go to the libNeuroML documentation

from neuroml import ContinuousConnection

variable = 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,
)
<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.

preFractionAlong

postFractionAlong

preSegment

postSegment

preCell

postCell

preComponent

baseGradedSynapse

postComponent

baseGradedSynapse

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

Go to the libNeuroML documentation

from neuroml import ContinuousConnectionInstance

variable = 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.

weight

Dimensionless

preFractionAlong

postFractionAlong

preSegment

postSegment

preCell

postCell

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

Go to the libNeuroML documentation

from neuroml import ContinuousConnectionInstanceW

variable = 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,
)
<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.

presynapticPopulation

population

postsynapticPopulation

population

connections

continuousConnection

connectionInstances

continuousConnectionInstance

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

Go to the libNeuroML documentation

from neuroml import ContinuousProjection

variable = 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,
)
<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.

destination

sourcePort

targetPort

target

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

Go to the libNeuroML documentation

from neuroml import ExplicitInput

variable = ExplicitInput(
    target: 'a Nml2PopulationReferencePath (required)' = None,
    input: 'a NmlId (required)' = None,
    destination: 'a NmlId (optional)' = None,
)
<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..

population

component

basePointCurrent

inputs

input

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

Go to the libNeuroML documentation

from neuroml import InputList

variable = 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,
)
<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 ).

segmentId

Optional specification of the segment to target, default 0

fractionAlong

Optional specification of the fraction along the specified segment, default 0.5

destination

target

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

Go to the libNeuroML documentation

from neuroml import Input

variable = 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,
)
<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.

weight

Dimensionless

destination

target

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

Go to the libNeuroML documentation

from neuroml import InputW

variable = 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,
)