Cells

from neuroml import BaseCell
from neuroml.utils import component_factory

variable = component_factory(
    BaseCell,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    extensiontype_=None,
)

baseSpikingCell#

extends baseCell

Base type of any cell which can emit spike events.

Event Ports

spike

Spike event

Direction: out

baseCellMembPot#

extends baseSpikingCell

Any spiking cell which has a membrane potential v with units of voltage ( as opposed to a dimensionless membrane potential used in baseCellMembPotDL ).

Exposures

v

Membrane potential

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

baseCellMembPotDL#

extends baseSpikingCell

Any spiking cell which has a dimensioness membrane potential, V ( as opposed to a membrane potential units of voltage, baseCellMembPot ).

Exposures

V

Membrane potential

Dimensionless

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

baseChannelPopulation#

extends baseVoltageDepPointCurrent

Base type for any current produced by a population of channels, all of which are of type ionChannel.

Component References

ionChannel

baseIonChannel

Exposures

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

Requirements

v

The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepPointCurrent)

channelPopulation#

extends baseChannelPopulation

Population of a number of ohmic ion channels. These each produce a conductance channelg across a reversal potential erev, giving a total current i. Note that active membrane currents are more frequently specified as a density over an area of the cell using channelDensity.

Parameters

erev	The reversal potential of the current produced	voltage
number	The number of channels present. This will be multiplied by the time varying conductance of the individual ion channel (which extends baseIonChannel) to produce the total conductance	Dimensionless

Constants

vShift = 0mV

Set to a constant 0mV here to allow ion channels which use _vShift in their rate variable expressions to be used with channelPopulation, not just with channelDensityVShift (where _vShift would be explicitly set)

Text fields

ion

Which ion flows through the channel. Note: ideally this needs to be a property of ionChannel only, but it’s here as it makes it easier to select channelPopulations transmitting specific ions.

Exposures

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

Requirements

v

The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepPointCurrent)

Dynamics

Structure: CHILD INSTANCE: ionChannel
Derived Variables: channelg = ionChannel->g; geff = channelg * number; i = geff * (erev - v) (exposed as i)

Schema

<xs:complexType name="ChannelPopulation">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="variableParameter" type="VariableParameter" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="ionChannel" type="NmlId" use="required"/>
      <xs:attribute name="number" type="NonNegativeInteger" use="required"/>
      <xs:attribute name="erev" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="segmentGroup" type="NmlId" use="optional" default="all"/>
      <xs:attribute name="segment" type="NonNegativeInteger" use="optional"/>
      <xs:attribute name="ion" type="NmlId" use="required">
        <xs:annotation>
            </xs:annotation>
      </xs:attribute>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import ChannelPopulation
from neuroml.utils import component_factory

variable = component_factory(
    ChannelPopulation,
    id: 'a NmlId (required)' = None,
    ion_channel: 'a NmlId (required)' = None,
    number: 'a NonNegativeInteger (required)' = None,
    erev: 'a Nml2Quantity_voltage (required)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
    segments: 'a NonNegativeInteger (optional)' = None,
    ion: 'a NmlId (required)' = None,
    variable_parameters: 'list of VariableParameter(s) (optional)' = None,
)

Usage: XML

<channelPopulation id="naChansDend" ionChannel="NaConductance" segment="2" number="120000" erev="50mV" ion="na"/>

channelPopulationNernst#

extends baseChannelPopulation

Population of a number of channels with a time varying reversal potential erev determined by Nernst equation. Note: hard coded for Ca only!

Parameters

number

The number of channels present. This will be multiplied by the time varying conductance of the individual ion channel (which extends baseIonChannel) to produce the total conductance

Dimensionless

Constants

R = 8.3144621 J_per_K_per_mol		idealGasConstantDims
zCa = 2		Dimensionless
F = 96485.3 C_per_mol		charge_per_mole
vShift = 0mV	Set to a constant 0mV here to allow ion channels which use _vShift in their rate variable expressions to be used with channelPopulation, not just with channelDensityVShift (where _vShift would be explicitly set)	voltage

Text fields

ion

Which ion flows through the channel. Note: ideally this needs to be a property of ionChannel only, but it’s here as it makes it easier to select channelPopulations transmitting specific ions.

Exposures

erev	The reversal potential of the current produced, calculated from _caConcExt and _caConc	voltage
i	The total (usually time varying) current produced by this ComponentType (from basePointCurrent)	current

Requirements

caConc	The internal Ca2+ concentration, as calculated/exposed by the parent Component	concentration
caConcExt	The external Ca2+ concentration, as calculated/exposed by the parent Component	concentration
temperature	The temperature to use in the calculation of _erev. Note this is generally exposed by a networkWithTemperature.	temperature
v	The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepPointCurrent)	voltage

Dynamics

Structure: CHILD INSTANCE: ionChannel
Derived Variables: singleChannelConductance = ionChannel->g; totalConductance = singleChannelConductance * number; erev = (R * temperature / (zCa * F)) * log(caConcExt / caConc) (exposed as erev); i = totalConductance * (erev - v) (exposed as i)

baseChannelDensity#

Base type for a current of density iDensity distributed on an area of a cell, flowing through the specified ionChannel. Instances of this ( normally channelDensity ) are specified in the membraneProperties of the cell.

Component References

ionChannel

baseIonChannel

Exposures

iDensity

Requirements

v

baseChannelDensityCond#

extends baseChannelDensity

Base type for distributed conductances on an area of a cell producing a ( not necessarily ohmic ) current.

Parameters

condDensity

Exposures

gDensity		conductanceDensity
iDensity	(from baseChannelDensity)	currentDensity

Requirements

v

(from baseChannelDensity)

variableParameter#

Specifies a parameter ( e.g. condDensity ) which can vary its value across a segmentGroup. The value is calculated from value attribute of the inhomogeneousValue subelement. This element is normally a child of channelDensityNonUniform, channelDensityNonUniformNernst or channelDensityNonUniformGHK and is used to calculate the value of the conductance, etc. which will vary on different parts of the cell. The segmentGroup specified here needs to define an inhomogeneousParameter ( referenced from inhomogeneousParameter in the inhomogeneousValue ), which calculates a variable ( e.g. p ) varying across the cell ( e.g. based on the path length from soma ), which is then used in the value attribute of the inhomogeneousValue ( so for example condDensity = f( p ) ).

Text fields

parameter
segmentGroup

Child list

inhomogeneousValue

inhomogeneousValue

Schema

<xs:complexType name="VariableParameter">
  <xs:sequence>
    <xs:element name="inhomogeneousValue" type="InhomogeneousValue" minOccurs="0"/>
  </xs:sequence>
  <xs:attribute name="parameter" type="xs:string" use="required"/>
  <xs:attribute name="segmentGroup" type="xs:string" use="required"/>
</xs:complexType>

Usage: Python

from neuroml import VariableParameter
from neuroml.utils import component_factory

variable = component_factory(
    VariableParameter,
    parameter: 'a string (required)' = None,
    segment_groups: 'a string (required)' = None,
    inhomogeneous_value: 'a InhomogeneousValue (optional)' = None,
)

Usage: XML

<variableParameter parameter="condDensity" segmentGroup="dendrite_group">
    <inhomogeneousValue inhomogeneousParameter="dendrite_group_x1" value="5e-7 * exp(-p/200)"/>
</variableParameter>

inhomogeneousValue#

Specifies the value of an inhomogeneousParameter. For usage see variableParameter.

Text fields

inhomogeneousParameter
value

Schema

<xs:complexType name="InhomogeneousValue">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="inhomogeneousParameter" type="xs:string" use="required"/>
      <xs:attribute name="value" type="xs:string" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import InhomogeneousValue
from neuroml.utils import component_factory

variable = component_factory(
    InhomogeneousValue,
    inhomogeneous_parameters: 'a string (required)' = None,
    value: 'a string (required)' = None,
)

Usage: XML

<inhomogeneousValue inhomogeneousParameter="dendrite_group_x1" value="5e-7 * exp(-p/200)"/>

channelDensityNonUniformNernst#

extends baseChannelDensity

Specifies a time varying conductance density, which is distributed on a region of the cell, and whose reversal potential is calculated from the Nernst equation. Hard coded for Ca only!. The conductance density of the channel is not uniform, but is set using the variableParameter. Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON.

Constants

ZERO_CURR_DENS = 0 A_per_m2

Text fields

segmentGroup
ion	Which ion flows through the channel. Note: ideally this needs to be a property of ionChannel only, but it’s here as it makes it easier to select channelPopulations transmitting specific ions.

Child list

variableParameter

variableParameter

Exposures

iDensity

(from baseChannelDensity)

Requirements

v

(from baseChannelDensity)

Dynamics

Structure: CHILD INSTANCE: ionChannel
Derived Variables: iDensity = ZERO_CURR_DENS (exposed as iDensity)

Schema

<xs:complexType name="ChannelDensityNonUniformNernst">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="variableParameter" type="VariableParameter" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="ionChannel" type="NmlId" use="required"/>
      <xs:attribute name="ion" type="NmlId" use="required">
        <xs:annotation>
            </xs:annotation>
      </xs:attribute>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import ChannelDensityNonUniformNernst
from neuroml.utils import component_factory

variable = component_factory(
    ChannelDensityNonUniformNernst,
    id: 'a NmlId (required)' = None,
    ion_channel: 'a NmlId (required)' = None,
    ion: 'a NmlId (required)' = None,
    variable_parameters: 'list of VariableParameter(s) (optional)' = None,
)

channelDensityNonUniformGHK#

extends baseChannelDensity

Specifies a time varying conductance density, which is distributed on a region of the cell, and whose current is calculated from the Goldman-Hodgkin-Katz equation. Hard coded for Ca only!. The conductance density of the channel is not uniform, but is set using the variableParameter. Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON.

Constants

ZERO_CURR_DENS = 0 A_per_m2

Text fields

segmentGroup
ion	Which ion flows through the channel. Note: ideally this needs to be a property of ionChannel only, but it’s here as it makes it easier to select channelPopulations transmitting specific ions.

Child list

variableParameter

variableParameter

Exposures

iDensity

(from baseChannelDensity)

Requirements

v

(from baseChannelDensity)

Dynamics

Structure: CHILD INSTANCE: ionChannel
Derived Variables: iDensity = ZERO_CURR_DENS (exposed as iDensity)

Schema

<xs:complexType name="ChannelDensityNonUniformGHK">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="variableParameter" type="VariableParameter" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="ionChannel" type="NmlId" use="required"/>
      <xs:attribute name="ion" type="NmlId" use="required">
        <xs:annotation>
            </xs:annotation>
      </xs:attribute>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import ChannelDensityNonUniformGHK
from neuroml.utils import component_factory

variable = component_factory(
    ChannelDensityNonUniformGHK,
    id: 'a NmlId (required)' = None,
    ion_channel: 'a NmlId (required)' = None,
    ion: 'a NmlId (required)' = None,
    variable_parameters: 'list of VariableParameter(s) (optional)' = None,
)

channelDensity#

extends baseChannelDensityCond

Specifies a time varying ohmic conductance density, gDensity, which is distributed on an area of the cell ( specified in membraneProperties ) with fixed reversal potential erev producing a current density iDensity.

Parameters

condDensity	(from baseChannelDensityCond)	conductanceDensity
erev	The reversal potential of the current produced	voltage

Constants

vShift = 0mV

Set to a constant 0mV here to allow ion channels which use _vShift in their rate variable expressions to be used with channelDensity, not just with channelDensityVShift (where _vShift would be explicitly set)

Text fields

segmentGroup	Which segmentGroup the channelDensity is placed on. If this is missing, it implies it is placed on all _segment_s of the cell
ion	Which ion flows through the channel. Note: ideally this needs to be a property of ionChannel only, but it’s here as it makes it easier to select channelPopulations transmitting specific ions.

Exposures

gDensity	(from baseChannelDensityCond)	conductanceDensity
iDensity	(from baseChannelDensity)	currentDensity

Requirements

v

(from baseChannelDensity)

Dynamics

Structure: CHILD INSTANCE: ionChannel
Derived Variables: channelf = ionChannel->fopen; gDensity = condDensity * channelf (exposed as gDensity); iDensity = gDensity * (erev - v) (exposed as iDensity)

Schema

<xs:complexType name="ChannelDensity">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="variableParameter" type="VariableParameter" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="ionChannel" type="NmlId" use="required"/>
      <xs:attribute name="condDensity" type="Nml2Quantity_conductanceDensity" use="optional"/>
      <xs:attribute name="erev" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="segmentGroup" type="NmlId" use="optional" default="all"/>
      <xs:attribute name="segment" type="NonNegativeInteger" use="optional"/>
      <xs:attribute name="ion" type="NmlId" use="required">
        <xs:annotation>
            </xs:annotation>
      </xs:attribute>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import ChannelDensity
from neuroml.utils import component_factory

variable = component_factory(
    ChannelDensity,
    id: 'a NmlId (required)' = None,
    ion_channel: 'a NmlId (required)' = None,
    cond_density: 'a Nml2Quantity_conductanceDensity (optional)' = None,
    erev: 'a Nml2Quantity_voltage (required)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
    segments: 'a NonNegativeInteger (optional)' = None,
    ion: 'a NmlId (required)' = None,
    variable_parameters: 'list of VariableParameter(s) (optional)' = None,
    extensiontype_=None,
)

Usage: XML

<channelDensity id="pasChans" ionChannel="pas" condDensity="3.0 S_per_m2" erev="-70mV" ion="non_specific"/>

<channelDensity id="naChansSoma" ionChannel="NaConductance" segmentGroup="soma_group" condDensity="120.0 mS_per_cm2" erev="50mV" ion="na"/>

<channelDensity id="naChans" ionChannel="HH_Na" segmentGroup="soma_group" condDensity="120.0 mS_per_cm2" ion="na" erev="50mV"/>

channelDensityVShift#

extends channelDensity

Same as channelDensity, but with a vShift parameter to change voltage activation of gates. The exact usage of vShift in expressions for rates is determined by the individual gates.

Parameters

condDensity	(from baseChannelDensityCond)	conductanceDensity
erev	The reversal potential of the current produced (from channelDensity)	voltage
vShift		voltage

Text fields

segmentGroup	Which segmentGroup the channelDensity is placed on. If this is missing, it implies it is placed on all _segment_s of the cell
ion	Which ion flows through the channel. Note: ideally this needs to be a property of ionChannel only, but it’s here as it makes it easier to select channelPopulations transmitting specific ions.

Exposures

gDensity	(from baseChannelDensityCond)	conductanceDensity
iDensity	(from baseChannelDensity)	currentDensity

Requirements

v

(from baseChannelDensity)

Schema

<xs:complexType name="ChannelDensityVShift">
  <xs:complexContent>
    <xs:extension base="ChannelDensity">
      <xs:attribute name="vShift" type="Nml2Quantity_voltage" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import ChannelDensityVShift
from neuroml.utils import component_factory

variable = component_factory(
    ChannelDensityVShift,
    id: 'a NmlId (required)' = None,
    ion_channel: 'a NmlId (required)' = None,
    cond_density: 'a Nml2Quantity_conductanceDensity (optional)' = None,
    erev: 'a Nml2Quantity_voltage (required)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
    segments: 'a NonNegativeInteger (optional)' = None,
    ion: 'a NmlId (required)' = None,
    variable_parameters: 'list of VariableParameter(s) (optional)' = None,
    v_shift: 'a Nml2Quantity_voltage (required)' = None,
)

channelDensityNernst#

extends baseChannelDensityCond

Specifies a time varying conductance density, gDensity, which is distributed on an area of the cell, producing a current density iDensity and whose reversal potential is calculated from the Nernst equation. Hard coded for Ca only! See OpenSourceBrain/ghk-nernst.

Parameters

condDensity

(from baseChannelDensityCond)

Constants

R = 8.3144621 J_per_K_per_mol		idealGasConstantDims
zCa = 2		Dimensionless
F = 96485.3 C_per_mol		charge_per_mole

Text fields

segmentGroup	Which segmentGroup the channelDensityNernst is placed on. If this is missing, it implies it is placed on all _segment_s of the cell
ion	Which ion flows through the channel. Note: ideally this needs to be a property of ionChannel only, but it’s here as it makes it easier to select channelPopulations transmitting specific ions.

Exposures

erev	The reversal potential of the current produced, calculated from caConcExt and caConc	voltage
gDensity	(from baseChannelDensityCond)	conductanceDensity
iDensity	(from baseChannelDensity)	currentDensity

Requirements

caConc		concentration
caConcExt		concentration
temperature		temperature
v	(from baseChannelDensity)	voltage

Dynamics

Structure: CHILD INSTANCE: ionChannel
Derived Variables: channelf = ionChannel->fopen
Conditional Derived Variables: IF caConcExt > 0 THEN; gDensity = condDensity * channelf (exposed as gDensity); IF caConcExt <= 0 THEN; gDensity = 0 (exposed as gDensity); IF caConcExt > 0 THEN; erev = (R * temperature / (zCa * F)) * log(caConcExt / caConc) (exposed as erev); IF caConcExt <= 0 THEN; erev = 0 (exposed as erev); IF caConcExt > 0 THEN; iDensity = gDensity * (erev - v) (exposed as iDensity); IF caConcExt <= 0 THEN; iDensity = 0 (exposed as iDensity)

Schema

<xs:complexType name="ChannelDensityNernst">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="variableParameter" type="VariableParameter" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="ionChannel" type="NmlId" use="required"/>
      <xs:attribute name="condDensity" type="Nml2Quantity_conductanceDensity" use="optional"/>
      <xs:attribute name="segmentGroup" type="NmlId" use="optional" default="all"/>
      <xs:attribute name="segment" type="NmlId" use="optional"/>
      <xs:attribute name="ion" type="NmlId" use="required">
        <xs:annotation>
            </xs:annotation>
      </xs:attribute>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import ChannelDensityNernst
from neuroml.utils import component_factory

variable = component_factory(
    ChannelDensityNernst,
    id: 'a NmlId (required)' = None,
    ion_channel: 'a NmlId (required)' = None,
    cond_density: 'a Nml2Quantity_conductanceDensity (optional)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
    segments: 'a NonNegativeInteger (optional)' = None,
    ion: 'a NmlId (required)' = None,
    variable_parameters: 'list of VariableParameter(s) (optional)' = None,
    extensiontype_=None,
)

channelDensityNernstCa2#

extends baseChannelDensityCond

This component is similar to the original component type channelDensityNernst but it is changed in order to have a reversal potential that depends on a second independent Ca++ pool ( ca2 ). See OpenSourceBrain/ghk-nernst.

Parameters

condDensity

(from baseChannelDensityCond)

Constants

R = 8.3144621 J_per_K_per_mol		idealGasConstantDims
zCa = 2		Dimensionless
F = 96485.3 C_per_mol		charge_per_mole

Text fields

segmentGroup	Which segmentGroup the channelDensityNernstCa2 is placed on. If this is missing, it implies it is placed on all _segment_s of the cell
ion	Which ion flows through the channel. Note: ideally this needs to be a property of ionChannel only, but it’s here as it makes it easier to select channelPopulations transmitting specific ions.

Exposures

erev	The reversal potential of the current produced	voltage
gDensity	(from baseChannelDensityCond)	conductanceDensity
iDensity	(from baseChannelDensity)	currentDensity

Requirements

caConc2		concentration
caConcExt2		concentration
temperature		temperature
v	(from baseChannelDensity)	voltage

Dynamics

Structure: CHILD INSTANCE: ionChannel
Derived Variables: channelf = ionChannel->fopen
Conditional Derived Variables: IF caConcExt2 > 0 THEN; gDensity = condDensity * channelf (exposed as gDensity); IF caConcExt2 <= 0 THEN; gDensity = 0 (exposed as gDensity); IF caConcExt2 > 0 THEN; erev = (R * temperature / (zCa * F)) * log(caConcExt2 / caConc2) (exposed as erev); IF caConcExt2 <= 0 THEN; erev = 0 (exposed as erev); IF caConcExt2 > 0 THEN; iDensity = gDensity * (erev - v) (exposed as iDensity); IF caConcExt2 <= 0 THEN; iDensity = 0 (exposed as iDensity)

Schema

<xs:complexType name="ChannelDensityNernstCa2">
  <xs:complexContent>
    <xs:extension base="ChannelDensityNernst">
      </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import ChannelDensityNernstCa2
from neuroml.utils import component_factory

variable = component_factory(
    ChannelDensityNernstCa2,
    id: 'a NmlId (required)' = None,
    ion_channel: 'a NmlId (required)' = None,
    cond_density: 'a Nml2Quantity_conductanceDensity (optional)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
    segments: 'a NonNegativeInteger (optional)' = None,
    ion: 'a NmlId (required)' = None,
    variable_parameters: 'list of VariableParameter(s) (optional)' = None,
)

channelDensityGHK#

extends baseChannelDensity

Specifies a time varying conductance density, gDensity, which is distributed on an area of the cell, producing a current density iDensity and whose reversal potential is calculated from the Goldman Hodgkin Katz equation. Hard coded for Ca only! See OpenSourceBrain/ghk-nernst.

Parameters

permeability

permeability

Constants

R = 8.3144621 J_per_K_per_mol		idealGasConstantDims
zCa = 2		Dimensionless
F = 96485.3 C_per_mol		charge_per_mole

Text fields

segmentGroup	Which segmentGroup the channelDensityGHK is placed on. If this is missing, it implies it is placed on all _segment_s of the cell
ion	Which ion flows through the channel. Note: ideally this needs to be a property of ionChannel only, but it’s here as it makes it easier to select channelPopulations transmitting specific ions.

Exposures

iDensity

(from baseChannelDensity)

Requirements

caConc		concentration
caConcExt		concentration
temperature		temperature
v	(from baseChannelDensity)	voltage

Dynamics

Structure: CHILD INSTANCE: ionChannel
Derived Variables: K = (zCa * F) / (R * temperature); expKv = exp(-1 * K * v); channelf = ionChannel->fopen
Conditional Derived Variables: IF caConcExt > 0 THEN; iDensity = -1 * channelf * permeability * zCa * F * K * v * ( caConc - (caConcExt * expKv) ) / (1 - expKv) (exposed as iDensity); IF caConcExt <= 0 THEN; iDensity = 0 (exposed as iDensity)

Schema

<xs:complexType name="ChannelDensityGHK">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:attribute name="ionChannel" type="NmlId" use="required"/>
      <xs:attribute name="permeability" type="Nml2Quantity_permeability" use="required"/>
      <xs:attribute name="segmentGroup" type="NmlId" use="optional" default="all"/>
      <xs:attribute name="segment" type="NmlId" use="optional"/>
      <xs:attribute name="ion" type="NmlId" use="required">
        <xs:annotation>
            </xs:annotation>
      </xs:attribute>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import ChannelDensityGHK
from neuroml.utils import component_factory

variable = component_factory(
    ChannelDensityGHK,
    id: 'a NmlId (required)' = None,
    ion_channel: 'a NmlId (required)' = None,
    permeability: 'a Nml2Quantity_permeability (required)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
    segments: 'a NonNegativeInteger (optional)' = None,
    ion: 'a NmlId (required)' = None,
)

channelDensityGHK2#

extends baseChannelDensityCond

Time varying conductance density, gDensity, which is distributed on an area of the cell, producing a current density iDensity. Modified version of Jaffe et al. 1994 ( used also in Lawrence et al. 2006 ). See OpenSourceBrain/ghk-nernst.

Parameters

condDensity

(from baseChannelDensityCond)

Constants

VOLT_SCALE = 1 mV		voltage
CONC_SCALE = 1 mM		concentration
TEMP_SCALE = 1 K		temperature

Text fields

segmentGroup	Which segmentGroup the channelDensityGHK2 is placed on. If this is missing, it implies it is placed on all _segment_s of the cell
ion	Which ion flows through the channel. Note: ideally this needs to be a property of ionChannel only, but it’s here as it makes it easier to select channelPopulations transmitting specific ions.

Exposures

gDensity	(from baseChannelDensityCond)	conductanceDensity
iDensity	(from baseChannelDensity)	currentDensity

Requirements

caConc		concentration
caConcExt		concentration
temperature		temperature
v	(from baseChannelDensity)	voltage

Dynamics

Structure: CHILD INSTANCE: ionChannel
Derived Variables: V = v / VOLT_SCALE; ca_conc_i = caConc / CONC_SCALE; ca_conc_ext = caConcExt / CONC_SCALE; T = temperature / TEMP_SCALE; channelf = ionChannel->fopen; gDensity = condDensity * channelf (exposed as gDensity); tmp = (25 * T) / (293.15 * 2)
Conditional Derived Variables: IF V/tmp = 0. THEN; pOpen = tmp * 1e-3 * (1 - ((ca_conc_i/ca_conc_ext) * exp(V/tmp))) * (1 - (V/tmp)/2); IF V/tmp != 0. THEN; pOpen = tmp * 1e-3 * (1 - ((ca_conc_i/ca_conc_ext) * exp(V/tmp))) * ((V/tmp) / (exp(V/tmp) - 1)); IF ca_conc_ext > 0 THEN; iDensity = gDensity * pOpen (exposed as iDensity); IF ca_conc_ext <= 0 THEN; iDensity = 0 (exposed as iDensity)

Schema

<xs:complexType name="ChannelDensityGHK2">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:attribute name="ionChannel" type="NmlId" use="required"/>
      <xs:attribute name="condDensity" type="Nml2Quantity_conductanceDensity" use="optional"/>
      <xs:attribute name="segmentGroup" type="NmlId" use="optional" default="all"/>
      <xs:attribute name="segment" type="NmlId" use="optional"/>
      <xs:attribute name="ion" type="NmlId" use="required">
        <xs:annotation>
            </xs:annotation>
      </xs:attribute>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import ChannelDensityGHK2
from neuroml.utils import component_factory

variable = component_factory(
    ChannelDensityGHK2,
    id: 'a NmlId (required)' = None,
    ion_channel: 'a NmlId (required)' = None,
    cond_density: 'a Nml2Quantity_conductanceDensity (optional)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
    segments: 'a NonNegativeInteger (optional)' = None,
    ion: 'a NmlId (required)' = None,
)

pointCellCondBased#

extends baseCellMembPotCap

Simple model of a conductance based cell, with no separate morphology element, just an absolute capacitance C, and a set of channel populations. Note: use of cell is generally preferable ( and more widely supported ), even for a single compartment cell.

Parameters

C	Total capacitance of the cell membrane (from baseCellMembPotCap)	capacitance
thresh	The voltage threshold above which the cell is considered to be _spiking	voltage
v0	The initial membrane potential of the cell	voltage

Children list

populations

baseChannelPopulation

Exposures

iMemb	Total current crossing the cell membrane (from baseCellMembPotCap)	current
iSyn	Total current due to synaptic inputs (from baseCellMembPotCap)	current
v	Membrane potential (from baseCellMembPot)	voltage

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Attachments

synapses

Dynamics

State Variables: v: voltage (exposed as v); spiking: Dimensionless
On Start: v = v0; spiking = 0
On Conditions: IF v > thresh AND spiking < 0.5 THEN; spiking = 1; EVENT OUT on port: spike; IF v < thresh THEN; spiking = 0
Derived Variables: iChannels = populations[*]->i(reduce method: add); iSyn = synapses[*]->i(reduce method: add) (exposed as iSyn); iMemb = iChannels + iSyn (exposed as iMemb)
Time Derivatives: d v /dt = iMemb / C

pointCellCondBasedCa#

extends baseCellMembPotCap

TEMPORARY: Point cell with conductances and Ca concentration info. Not yet fully tested!!!

Parameters

C	Total capacitance of the cell membrane (from baseCellMembPotCap)	capacitance
thresh	The voltage threshold above which the cell is considered to be _spiking	voltage
v0	The initial membrane potential of the cell	voltage

Children list

populations		baseChannelPopulation
concentrationModels		concentrationModel

Exposures

caConc		concentration
iCa		current
iMemb	Total current crossing the cell membrane (from baseCellMembPotCap)	current
iSyn	Total current due to synaptic inputs (from baseCellMembPotCap)	current
v	Membrane potential (from baseCellMembPot)	voltage

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Attachments

synapses

Dynamics

State Variables: v: voltage (exposed as v); spiking: Dimensionless
On Start: v = v0; spiking = 0
On Conditions: IF v > thresh AND spiking < 0.5 THEN; spiking = 1; EVENT OUT on port: spike; IF v < thresh THEN; spiking = 0
Derived Variables: iChannels = populations[*]->i(reduce method: add); iCa = populations[ion=‘ca’]->i(reduce method: add) (exposed as iCa); caConc = concentrationModels[species=‘ca’]->concentration(reduce method: add) (exposed as caConc); iSyn = synapses[*]->i(reduce method: add) (exposed as iSyn); iMemb = iChannels + iSyn (exposed as iMemb)
Time Derivatives: d v /dt = iMemb / C

distal#

extends point3DWithDiam

Point on a segment furthest from the soma. Should always be present in the description of a segment, unlike proximal.

Parameters

diameter	Diameter of the ppoint. Note: no dimension used, see description of point3DWithDiam for details. (from point3DWithDiam)	Dimensionless
x	x coordinate of the point. Note: no dimension used, see description of point3DWithDiam for details. (from point3DWithDiam)	Dimensionless
y	y coordinate of the ppoint. Note: no dimension used, see description of point3DWithDiam for details. (from point3DWithDiam)	Dimensionless
z	z coordinate of the ppoint. Note: no dimension used, see description of point3DWithDiam for details. (from point3DWithDiam)	Dimensionless

Derived parameters

radius

A dimensional quantity given by half the _diameter. (from point3DWithDiam)

radius = MICRON * diameter / 2

xLength

A version of _x with dimension length. (from point3DWithDiam)

xLength = MICRON * x

yLength

A version of _y with dimension length. (from point3DWithDiam)

yLength = MICRON * y

zLength

A version of _z with dimension length. (from point3DWithDiam)

zLength = MICRON * z

Usage: XML

<distal x="10" y="0" z="0" diameter="10"/>

<distal x="20" y="0" z="0" diameter="3"/>

<distal x="30" y="0" z="0" diameter="1"/>

proximal#

extends point3DWithDiam

Point on a segment closest to the soma. Note, the proximal point can be omitted, and in this case is defined as being the point fractionAlong between the proximal and distal point of the parent, i.e. if fractionAlong = 1 ( as it is by default ) it will be the distal on the parent, or if fractionAlong = 0, it will be the proximal point. If between 0 and 1, it is the linear interpolation between the two points.

Parameters

diameter	Diameter of the ppoint. Note: no dimension used, see description of point3DWithDiam for details. (from point3DWithDiam)	Dimensionless
x	x coordinate of the point. Note: no dimension used, see description of point3DWithDiam for details. (from point3DWithDiam)	Dimensionless
y	y coordinate of the ppoint. Note: no dimension used, see description of point3DWithDiam for details. (from point3DWithDiam)	Dimensionless
z	z coordinate of the ppoint. Note: no dimension used, see description of point3DWithDiam for details. (from point3DWithDiam)	Dimensionless

Derived parameters

radius

A dimensional quantity given by half the _diameter. (from point3DWithDiam)

radius = MICRON * diameter / 2

xLength

A version of _x with dimension length. (from point3DWithDiam)

xLength = MICRON * x

yLength

A version of _y with dimension length. (from point3DWithDiam)

yLength = MICRON * y

zLength

A version of _z with dimension length. (from point3DWithDiam)

zLength = MICRON * z

Usage: XML

<proximal x="0" y="0" z="0" diameter="10"/>

<proximal x="25" y="0" z="0" diameter="0.1"/>

<proximal x="0" y="0" z="0" diameter="10"/>

parent#

Specifies the segment which is this segment’s parent. The fractionAlong specifies where it is connected, usually 1 ( the default value ), meaning the distal point of the parent, or 0, meaning the proximal point. If it is between these, a linear interpolation between the 2 points should be used.

Text fields

segment	The id of the parent segment
fractionAlong	The fraction along the the parent segment at which this segment is attached. For usage see proximal

Schema

<xs:complexType name="SegmentParent">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="segment" type="NonNegativeInteger" use="required"/>
      <xs:attribute name="fractionAlong" type="ZeroToOne" use="optional" default="1"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: XML

<parent segment="0"/>

<parent segment="1"/>

<parent segment="2" fractionAlong="0.5"/>

segment#

A segment defines the smallest unit within a possibly branching structure ( morphology ), such as a dendrite or axon. Its id should be a nonnegative integer ( usually soma/root = 0 ). Its end points are given by the proximal and distal points. The proximal point can be omitted, usually because it is the same as a point on the parent segment, see proximal for details. parent specifies the parent segment. The first segment of a cell ( with no parent ) usually represents the soma. The shape is normally a cylinder ( radii of the proximal and distal equal, but positions different ) or a conical frustum ( radii and positions different ). If the x, y, x positions of the proximal and distal are equal, the segment can be interpreted as a sphere, and in this case the radii of these points must be equal. NOTE: LEMS does not yet support multicompartmental modelling, so the Dynamics here is only appropriate for single compartment modelling.

Constants

LEN = 1m

Text fields

name

An optional name for the segment. Convenient for providing a suitable variable name for generated code, e.g. soma, dend0

Child list

parent		parent
distal		distal
proximal		proximal

Exposures

length		length
radDist		length
surfaceArea		area

Dynamics

Derived Variables: radDist = distal->radius (exposed as radDist); dx = distal->xLength; dy = distal->yLength; dz = distal->zLength; px = proximal->xLength; py = proximal->yLength; pz = proximal->zLength; length = sqrt(((dx - px) * (dx - px) + (dy - py) * (dy - py) + (dz - pz) * (dz - pz))/(LEN * LEN)) * LEN (exposed as length)
Conditional Derived Variables: IF length = 0 * LEN THEN; surfaceArea = 4 * radDist * radDist * 3.14159265 (exposed as surfaceArea); IF length > 0 * LEN THEN; surfaceArea = 2 * radDist * 3.14159265 * length (exposed as surfaceArea)

Schema

<xs:complexType name="Segment">
  <xs:complexContent>
    <xs:extension base="BaseNonNegativeIntegerId">
      <xs:sequence>
        <xs:element name="parent" type="SegmentParent" minOccurs="0"/>
        <xs:element name="proximal" type="Point3DWithDiam" minOccurs="0"/>
        <xs:element name="distal" type="Point3DWithDiam" minOccurs="1"/>
      </xs:sequence>
      <xs:attribute name="name" type="xs:string" use="optional"/>
      <xs:attribute name="neuroLexId" type="NeuroLexId" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import Segment
from neuroml.utils import component_factory

variable = component_factory(
    Segment,
    id: 'a NonNegativeInteger (required)' = None,
    name: 'a string (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    parent: 'a SegmentParent (optional)' = None,
    proximal: 'a Point3DWithDiam (optional)' = None,
    distal: 'a Point3DWithDiam (required)' = None,
)

Usage: XML

<segment id="3" name="Spine1">
    <parent segment="2" fractionAlong="0.5"/>
    <proximal x="25" y="0" z="0" diameter="0.1"/>
    <distal x="25" y="0.2" z="0" diameter="0.1"/>
</segment>

<segment id="0" name="Soma">
    <proximal x="0" y="0" z="0" diameter="10"/>
    <distal x="10" y="0" z="0" diameter="10"/>
</segment>

<segment id="1" name="Dendrite1">
    <parent segment="0"/>
    <distal x="20" y="0" z="0" diameter="3"/>
</segment>

segmentGroup#

A method to describe a group of segments in a morphology, e.g. soma_group, dendrite_group, axon_group. While a name is useful to describe the group, the neuroLexId attribute can be used to explicitly specify the meaning of the group, e.g. sao1044911821 for ‘Neuronal Cell Body’, sao1211023249 for ‘Dendrite’. The segments in this group can be specified as: a list of individual member segments; a path, all of the segments along which should be included; a subTree of the cell to include; other segmentGroups to include ( so all segments from those get included here ). An inhomogeneousParameter can be defined on the region of the cell specified by this group ( see variableParameter for usage ).

Text fields

neuroLexId

An id string for pointing to an entry in the NeuroLex ontology. Use of this attribute is a shorthand for a full RDF based reference to the MIRIAM Resource urn:miriam:neurolex, with an bqbiol:is qualifier.

Child list

notes		notes
annotation		annotation

Children list

property		property
members		member
paths		path
subTrees		subTree
includes		include
inhomogeneousParameter		inhomogeneousParameter

Schema

<xs:complexType name="SegmentGroup">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="property" type="Property" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="annotation" type="Annotation" minOccurs="0"/>
        <xs:element name="member" type="Member" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="include" type="Include" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="path" type="Path" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="subTree" type="SubTree" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="inhomogeneousParameter" type="InhomogeneousParameter" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="neuroLexId" type="NeuroLexId" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import SegmentGroup
from neuroml.utils import component_factory

variable = component_factory(
    SegmentGroup,
    id: 'a NonNegativeInteger (required)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    members: 'list of Member(s) (optional)' = None,
    includes: 'list of Include(s) (optional)' = None,
    paths: 'list of Path(s) (optional)' = None,
    sub_trees: 'list of SubTree(s) (optional)' = None,
    inhomogeneous_parameters: 'list of InhomogeneousParameter(s) (optional)' = None,
)

Usage: XML

<segmentGroup id="dendrite_group" neuroLexId="sao1211023249">
    <member segment="1"/>
    <member segment="2"/>
    <member segment="3"/>
</segmentGroup>

<segmentGroup id="soma_group" neuroLexId="sao1044911821">
    <member segment="0"/>
</segmentGroup>

<segmentGroup id="spines" neuroLexId="sao1145756102">
    <member segment="3"/>
</segmentGroup>

member#

A single identified segment which is part of the segmentGroup.

Text fields

segment

Schema

<xs:complexType name="Member">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="segment" type="NonNegativeInteger" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import Member
from neuroml.utils import component_factory

variable = component_factory(
    Member,
    segments: 'a NonNegativeInteger (required)' = None,
)

Usage: XML

<member segment="0"/>

<member segment="1"/>

<member segment="2"/>

from#

In a path or subTree, specifies which segment ( inclusive ) from which to calculate the segmentGroup.

Text fields

segment

Schema

<xs:complexType name="SegmentEndPoint">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="segment" type="NonNegativeInteger" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: XML

<from segment="1"/>

<from segment="1"/>

to#

In a path, specifies which segment ( inclusive ) up to which to calculate the segmentGroup.

Text fields

segment

Schema

<xs:complexType name="SegmentEndPoint">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="segment" type="NonNegativeInteger" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: XML

<to segment="2"/>

include#

Include all members of another segmentGroup in this group.

Text fields

href
segmentGroup

Schema

<xs:complexType name="Include">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="segmentGroup" type="NmlId" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import Include
from neuroml.utils import component_factory

variable = component_factory(
    Include,
    segment_groups: 'a NmlId (required)' = None,
)

Usage: XML

<include href="NML2_SingleCompHHCell.nml"/>

<include href="NML2_SimpleIonChannel.nml"/>

<include href="NML2_SimpleIonChannel.nml"/>

path#

Include all the segments between those specified by from and to, inclusive.

Child list

from		from
to		to

Schema

<xs:complexType name="Path">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:sequence>
        <xs:element name="from" type="SegmentEndPoint" minOccurs="0"/>
        <xs:element name="to" type="SegmentEndPoint" minOccurs="0"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import Path
from neuroml.utils import component_factory

variable = component_factory(
    Path,
    from_: 'a SegmentEndPoint (optional)' = None,
    to: 'a SegmentEndPoint (optional)' = None,
)

Usage: XML

<path>
    <from segment="1"/>
    <to segment="2"/>
</path>

subTree#

Include all the segments distal to that specified by from in the segmentGroup.

Child list

from

from

Schema

<xs:complexType name="SubTree">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:choice>
        <xs:element name="from" type="SegmentEndPoint" minOccurs="0"/>
        <xs:element name="to" type="SegmentEndPoint" minOccurs="0"/>
      </xs:choice>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import SubTree
from neuroml.utils import component_factory

variable = component_factory(
    SubTree,
    from_: 'a SegmentEndPoint (optional)' = None,
    to: 'a SegmentEndPoint (optional)' = None,
)

Usage: XML

<subTree>
    <from segment="1"/>
</subTree>

inhomogeneousParameter#

An inhomogeneous parameter specified across the segmentGroup ( see variableParameter for usage ).

Text fields

variable
metric

Child list

proximal		proximalDetails
distal		distalDetails

Schema

<xs:complexType name="InhomogeneousParameter">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="proximal" type="ProximalDetails" minOccurs="0"/>
        <xs:element name="distal" type="DistalDetails" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="variable" type="xs:string" use="required"/>
      <xs:attribute name="metric" type="Metric" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import InhomogeneousParameter
from neuroml.utils import component_factory

variable = component_factory(
    InhomogeneousParameter,
    id: 'a NmlId (required)' = None,
    variable: 'a string (required)' = None,
    metric: 'a Metric (required)' = None,
    proximal: 'a ProximalDetails (optional)' = None,
    distal: 'a DistalDetails (optional)' = None,
)

Usage: XML

<inhomogeneousParameter id="dendrite_group_x2" variable="r" metric="Path Length from root">
    <proximal translationStart="0"/>
    <distal normalizationEnd="1"/>
</inhomogeneousParameter>

<inhomogeneousParameter id="dendrite_group_x1" variable="p" metric="Path Length from root"/>

proximalDetails#

What to do at the proximal point when creating an inhomogeneous parameter.

Text fields

translationStart

Schema

<xs:complexType name="ProximalDetails">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="translationStart" type="xs:double" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import ProximalDetails
from neuroml.utils import component_factory

variable = component_factory(
    ProximalDetails,
    translation_start: 'a double (required)' = None,
)

distalDetails#

What to do at the distal point when creating an inhomogeneous parameter.

Text fields

normalizationEnd

Schema

<xs:complexType name="DistalDetails">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="normalizationEnd" type="xs:double" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import DistalDetails
from neuroml.utils import component_factory

variable = component_factory(
    DistalDetails,
    normalization_end: 'a double (required)' = None,
)

morphology#

The collection of segments which specify the 3D structure of the cell, along with a number of segmentGroups.

Children list

segments		segment
segmentGroups		segmentGroup

Schema

<xs:complexType name="Morphology">
  <xs:complexContent>
    <xs:extension base="Standalone">
      <xs:sequence>
        <xs:element name="segment" type="Segment" maxOccurs="unbounded"/>
        <xs:element name="segmentGroup" type="SegmentGroup" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import Morphology
from neuroml.utils import component_factory

variable = component_factory(
    Morphology,
    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,
    segments: 'list of Segment(s) (required)' = None,
    segment_groups: 'list of SegmentGroup(s) (optional)' = None,
)

Usage: XML

<morphology id="SpikingCell_morphology">
    <segment id="0" name="Soma">
        <proximal x="0" y="0" z="0" diameter="10"/>
        <distal x="10" y="0" z="0" diameter="10"/>
    </segment>
    <segment id="1" name="Dendrite1">
        <parent segment="0"/>
        <distal x="20" y="0" z="0" diameter="3"/>
    </segment>
    <segment id="2" name="Dendrite2">
        <parent segment="1"/>
        <distal x="30" y="0" z="0" diameter="1"/>
    </segment>
    <segment id="3" name="Spine1">
        <parent segment="2" fractionAlong="0.5"/>
        <proximal x="25" y="0" z="0" diameter="0.1"/>
        <distal x="25" y="0.2" z="0" diameter="0.1"/>
    </segment>
    <segmentGroup id="soma_group" neuroLexId="sao1044911821">
        <member segment="0"/>
    </segmentGroup>
    <segmentGroup id="dendrite_group" neuroLexId="sao1211023249">
        <member segment="1"/>
        <member segment="2"/>
        <member segment="3"/>
    </segmentGroup>
    <segmentGroup id="spines" neuroLexId="sao1145756102">
        <member segment="3"/>
    </segmentGroup>
</morphology>

<morphology id="NeuroMorpho_PyrCell123">
    <segment id="0" name="Soma">
        <proximal x="0" y="0" z="0" diameter="10"/>
        <distal x="10" y="0" z="0" diameter="10"/>
    </segment>
</morphology>

<morphology id="SimpleCell_Morphology">
    <segment id="0" name="Soma">
        <proximal x="0" y="0" z="0" diameter="10"/>
        <distal x="10" y="0" z="0" diameter="10"/>
    </segment>
    <segment id="1" name="MainDendrite1">
        <parent segment="0"/>
        <proximal x="10" y="0" z="0" diameter="3"/>
        <distal x="20" y="0" z="0" diameter="3"/>
    </segment>
    <segment id="2" name="MainDendrite2">
        <parent segment="1"/>
        <distal x="30" y="0" z="0" diameter="1"/>
    </segment>
    <segmentGroup id="soma_group" neuroLexId="sao1044911821">
        <member segment="0"/>
    </segmentGroup>
    <segmentGroup id="dendrite_group" neuroLexId="sao1211023249">
        <member segment="1"/>
        <member segment="2"/>
        <inhomogeneousParameter id="dendrite_group_x1" variable="p" metric="Path Length from root"/>
        <inhomogeneousParameter id="dendrite_group_x2" variable="r" metric="Path Length from root">
            <proximal translationStart="0"/>
            <distal normalizationEnd="1"/>
        </inhomogeneousParameter>
    </segmentGroup>
</morphology>

specificCapacitance#

Capacitance per unit area.

Parameters

value

Text fields

segmentGroup

Exposures

specCap

Dynamics

Derived Variables: specCap = value (exposed as specCap)

Schema

<xs:complexType name="SpecificCapacitance">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="value" type="Nml2Quantity_specificCapacitance" use="required"/>
      <xs:attribute name="segmentGroup" type="NmlId" use="optional" default="all"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import SpecificCapacitance
from neuroml.utils import component_factory

variable = component_factory(
    SpecificCapacitance,
    value: 'a Nml2Quantity_specificCapacitance (required)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
)

Usage: XML

<specificCapacitance segmentGroup="soma_group" value="1.0 uF_per_cm2"/>

<specificCapacitance segmentGroup="dendrite_group" value="2.0 uF_per_cm2"/>

<specificCapacitance segmentGroup="soma_group" value="1.0 uF_per_cm2"/>

initMembPotential#

Explicitly set initial membrane potential for the cell.

Parameters

value

Schema

<xs:complexType name="InitMembPotential">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="value" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="segmentGroup" type="NmlId" use="optional" default="all"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import InitMembPotential
from neuroml.utils import component_factory

variable = component_factory(
    InitMembPotential,
    value: 'a Nml2Quantity_voltage (required)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
)

Usage: XML

<initMembPotential value="-65mV"/>

<initMembPotential value="-65mV"/>

spikeThresh#

Membrane potential at which to emit a spiking event. Note, usually the spiking event will not be emitted again until the membrane potential has fallen below this value and rises again to cross it in a positive direction.

Parameters

value

Schema

<xs:complexType name="SpikeThresh">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="value" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="segmentGroup" type="NmlId" use="optional" default="all"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import SpikeThresh
from neuroml.utils import component_factory

variable = component_factory(
    SpikeThresh,
    value: 'a Nml2Quantity_voltage (required)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
)

Usage: XML

<spikeThresh value="-20mV"/>

<spikeThresh value="-20mV"/>

membraneProperties#

Properties specific to the membrane, such as the populations of channels, channelDensities, specificCapacitance, etc.

Child list

initMembPotential		initMembPotential
spikeThresh		spikeThresh

Children list

specificCapacitances		specificCapacitance
populations		baseChannelPopulation
channelDensities		baseChannelDensity

Exposures

iCa		current
totChanCurrent		current
totSpecCap		specificCapacitance

Requirements

surfaceArea

area

Dynamics

Derived Variables: totSpecCap = specificCapacitances[*]->specCap(reduce method: add) (exposed as totSpecCap); totChanPopCurrent = populations[*]->i(reduce method: add); totChanDensCurrentDensity = channelDensities[*]->iDensity(reduce method: add); totChanCurrent = totChanPopCurrent + (totChanDensCurrentDensity * surfaceArea) (exposed as totChanCurrent); totChanPopCurrentCa = populations[ion=‘ca’]->i(reduce method: add); totChanDensCurrentDensityCa = channelDensities[ion=‘ca’]->iDensity(reduce method: add); iCa = totChanPopCurrentCa + (totChanDensCurrentDensityCa * surfaceArea) (exposed as iCa)

Schema

<xs:complexType name="MembraneProperties">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:sequence>
        <xs:element name="channelPopulation" type="ChannelPopulation" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="channelDensity" type="ChannelDensity" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="channelDensityVShift" type="ChannelDensityVShift" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="channelDensityNernst" type="ChannelDensityNernst" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="channelDensityGHK" type="ChannelDensityGHK" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="channelDensityGHK2" type="ChannelDensityGHK2" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="channelDensityNonUniform" type="ChannelDensityNonUniform" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="channelDensityNonUniformNernst" type="ChannelDensityNonUniformNernst" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="channelDensityNonUniformGHK" type="ChannelDensityNonUniformGHK" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="spikeThresh" type="SpikeThresh" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="specificCapacitance" type="SpecificCapacitance" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="initMembPotential" type="InitMembPotential" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import MembraneProperties
from neuroml.utils import component_factory

variable = component_factory(
    MembraneProperties,
    channel_populations: 'list of ChannelPopulation(s) (optional)' = None,
    channel_densities: 'list of ChannelDensity(s) (optional)' = None,
    channel_density_v_shifts: 'list of ChannelDensityVShift(s) (optional)' = None,
    channel_density_nernsts: 'list of ChannelDensityNernst(s) (optional)' = None,
    channel_density_ghks: 'list of ChannelDensityGHK(s) (optional)' = None,
    channel_density_ghk2s: 'list of ChannelDensityGHK2(s) (optional)' = None,
    channel_density_non_uniforms: 'list of ChannelDensityNonUniform(s) (optional)' = None,
    channel_density_non_uniform_nernsts: 'list of ChannelDensityNonUniformNernst(s) (optional)' = None,
    channel_density_non_uniform_ghks: 'list of ChannelDensityNonUniformGHK(s) (optional)' = None,
    spike_threshes: 'list of SpikeThresh(s) (required)' = None,
    specific_capacitances: 'list of SpecificCapacitance(s) (required)' = None,
    init_memb_potentials: 'list of InitMembPotential(s) (required)' = None,
    extensiontype_=None,
)

Usage: XML

<membraneProperties>
    <channelPopulation id="naChansDend" ionChannel="NaConductance" segment="2" number="120000" erev="50mV" ion="na"/>
    <channelDensity id="pasChans" ionChannel="pas" condDensity="3.0 S_per_m2" erev="-70mV" ion="non_specific"/>
    <channelDensity id="naChansSoma" ionChannel="NaConductance" segmentGroup="soma_group" condDensity="120.0 mS_per_cm2" erev="50mV" ion="na"/>
    <specificCapacitance segmentGroup="soma_group" value="1.0 uF_per_cm2"/>
    <specificCapacitance segmentGroup="dendrite_group" value="2.0 uF_per_cm2"/>
</membraneProperties>

<membraneProperties>
    <channelDensity id="naChans" ionChannel="HH_Na" segmentGroup="soma_group" condDensity="120.0 mS_per_cm2" ion="na" erev="50mV"/>
    <!-- Ions present inside the cell. Note: a fixed reversal potential is specified here  
            <reversalPotential species="na" value="50mV"/>
            <reversalPotential species="k" value="-77mV"/>-->
</membraneProperties>

<membraneProperties>
    <channelDensityNonUniform id="nonuniform_na_chans" ionChannel="NaConductance" erev="50mV" ion="na">
        <variableParameter parameter="condDensity" segmentGroup="dendrite_group">
            <inhomogeneousValue inhomogeneousParameter="dendrite_group_x1" value="5e-7 * exp(-p/200)"/>
        </variableParameter>
    </channelDensityNonUniform>
    <specificCapacitance segmentGroup="soma_group" value="1.0 uF_per_cm2"/>
</membraneProperties>

membraneProperties2CaPools#

extends membraneProperties

Variant of membraneProperties with 2 independent Ca pools.

Child list

initMembPotential		initMembPotential
spikeThresh		spikeThresh

Children list

specificCapacitances		specificCapacitance
populations		baseChannelPopulation
channelDensities		baseChannelDensity

Exposures

iCa	(from membraneProperties)	current
iCa2		current
totChanCurrent	(from membraneProperties)	current
totSpecCap	(from membraneProperties)	specificCapacitance

Requirements

surfaceArea		area
surfaceArea	(from membraneProperties)	area

Dynamics

Derived Variables: totSpecCap = specificCapacitances[*]->specCap(reduce method: add) (exposed as totSpecCap); totChanPopCurrent = populations[*]->i(reduce method: add); totChanDensCurrentDensity = channelDensities[*]->iDensity(reduce method: add); totChanCurrent = totChanPopCurrent + (totChanDensCurrentDensity * surfaceArea) (exposed as totChanCurrent); totChanPopCurrentCa = populations[ion=‘ca’]->i(reduce method: add); totChanDensCurrentDensityCa = channelDensities[ion=‘ca’]->iDensity(reduce method: add); iCa = totChanPopCurrentCa + (totChanDensCurrentDensityCa * surfaceArea) (exposed as iCa); totChanPopCurrentCa2 = populations[ion=‘ca2’]->i(reduce method: add); totChanDensCurrentDensityCa2 = channelDensities[ion=‘ca2’]->iDensity(reduce method: add); iCa2 = totChanPopCurrentCa2 + (totChanDensCurrentDensityCa2 * surfaceArea) (exposed as iCa2)

Schema

<xs:complexType name="MembraneProperties2CaPools">
  <xs:complexContent>
    <xs:extension base="MembraneProperties">
      <xs:sequence>
        <xs:element name="channelDensityNernstCa2" type="ChannelDensityNernstCa2" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import MembraneProperties2CaPools
from neuroml.utils import component_factory

variable = component_factory(
    MembraneProperties2CaPools,
    channel_populations: 'list of ChannelPopulation(s) (optional)' = None,
    channel_densities: 'list of ChannelDensity(s) (optional)' = None,
    channel_density_v_shifts: 'list of ChannelDensityVShift(s) (optional)' = None,
    channel_density_nernsts: 'list of ChannelDensityNernst(s) (optional)' = None,
    channel_density_ghks: 'list of ChannelDensityGHK(s) (optional)' = None,
    channel_density_ghk2s: 'list of ChannelDensityGHK2(s) (optional)' = None,
    channel_density_non_uniforms: 'list of ChannelDensityNonUniform(s) (optional)' = None,
    channel_density_non_uniform_nernsts: 'list of ChannelDensityNonUniformNernst(s) (optional)' = None,
    channel_density_non_uniform_ghks: 'list of ChannelDensityNonUniformGHK(s) (optional)' = None,
    spike_threshes: 'list of SpikeThresh(s) (required)' = None,
    specific_capacitances: 'list of SpecificCapacitance(s) (required)' = None,
    init_memb_potentials: 'list of InitMembPotential(s) (required)' = None,
    channel_density_nernst_ca2s: 'list of ChannelDensityNernstCa2(s) (optional)' = None,
)

biophysicalProperties#

The biophysical properties of the cell, including the membraneProperties and the intracellularProperties.

Child list

membraneProperties		membraneProperties
intracellularProperties		intracellularProperties

Exposures

totSpecCap

Dynamics

Derived Variables: totSpecCap = membraneProperties->totSpecCap (exposed as totSpecCap)

Schema

<xs:complexType name="BiophysicalProperties">
  <xs:complexContent>
    <xs:extension base="Standalone">
      <xs:sequence>
        <xs:element name="membraneProperties" type="MembraneProperties"/>
        <xs:element name="intracellularProperties" type="IntracellularProperties" minOccurs="0"/>
        <xs:element name="extracellularProperties" type="ExtracellularProperties" minOccurs="0"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import BiophysicalProperties
from neuroml.utils import component_factory

variable = component_factory(
    BiophysicalProperties,
    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,
    membrane_properties: 'a MembraneProperties (required)' = None,
    intracellular_properties: 'a IntracellularProperties (optional)' = None,
    extracellular_properties: 'a ExtracellularProperties (optional)' = None,
)

Usage: XML

<biophysicalProperties id="bio_cell">
    <membraneProperties>
        <channelPopulation id="naChansDend" ionChannel="NaConductance" segment="2" number="120000" erev="50mV" ion="na"/>
        <channelDensity id="pasChans" ionChannel="pas" condDensity="3.0 S_per_m2" erev="-70mV" ion="non_specific"/>
        <channelDensity id="naChansSoma" ionChannel="NaConductance" segmentGroup="soma_group" condDensity="120.0 mS_per_cm2" erev="50mV" ion="na"/>
        <specificCapacitance segmentGroup="soma_group" value="1.0 uF_per_cm2"/>
        <specificCapacitance segmentGroup="dendrite_group" value="2.0 uF_per_cm2"/>
    </membraneProperties>
    <intracellularProperties>
        <resistivity value="0.1 kohm_cm"/>
    </intracellularProperties>
</biophysicalProperties>

<biophysicalProperties id="PyrCellChanDist">
    <membraneProperties>
        <channelDensity id="naChans" ionChannel="HH_Na" segmentGroup="soma_group" condDensity="120.0 mS_per_cm2" ion="na" erev="50mV"/>
        <!-- Ions present inside the cell. Note: a fixed reversal potential is specified here  
            <reversalPotential species="na" value="50mV"/>
            <reversalPotential species="k" value="-77mV"/>-->
    </membraneProperties>
    <intracellularProperties>
        <resistivity value="0.1 kohm_cm"/>
        <!-- REMOVED UNTIL WE CHECK HOW THE USAGE OF LEMS IMPACTS THIS...
            <biochemistry reactionScheme="InternalCaDynamics"/>  Ref to earlier pathway -->
    </intracellularProperties>
</biophysicalProperties>

<biophysicalProperties id="biophys">
    <membraneProperties>
        <channelDensityNonUniform id="nonuniform_na_chans" ionChannel="NaConductance" erev="50mV" ion="na">
            <variableParameter parameter="condDensity" segmentGroup="dendrite_group">
                <inhomogeneousValue inhomogeneousParameter="dendrite_group_x1" value="5e-7 * exp(-p/200)"/>
            </variableParameter>
        </channelDensityNonUniform>
        <specificCapacitance segmentGroup="soma_group" value="1.0 uF_per_cm2"/>
    </membraneProperties>
    <intracellularProperties>
        <resistivity value="0.1 kohm_cm"/>
    </intracellularProperties>
</biophysicalProperties>

biophysicalProperties2CaPools#

The biophysical properties of the cell, including the membraneProperties2CaPools and the intracellularProperties2CaPools for a cell with two Ca pools.

Child list

membraneProperties2CaPools		membraneProperties2CaPools
intracellularProperties2CaPools		intracellularProperties2CaPools

Exposures

totSpecCap

Dynamics

Derived Variables: totSpecCap = membraneProperties2CaPools->totSpecCap (exposed as totSpecCap)

Schema

<xs:complexType name="BiophysicalProperties2CaPools">
  <xs:complexContent>
    <xs:extension base="Standalone">
      <xs:sequence>
        <xs:element name="membraneProperties2CaPools" type="MembraneProperties2CaPools"/>
        <xs:element name="intracellularProperties2CaPools" type="IntracellularProperties2CaPools" minOccurs="0"/>
        <xs:element name="extracellularProperties" type="ExtracellularProperties" minOccurs="0"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import BiophysicalProperties2CaPools
from neuroml.utils import component_factory

variable = component_factory(
    BiophysicalProperties2CaPools,
    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,
    membrane_properties2_ca_pools: 'a MembraneProperties2CaPools (required)' = None,
    intracellular_properties2_ca_pools: 'a IntracellularProperties2CaPools (optional)' = None,
    extracellular_properties: 'a ExtracellularProperties (optional)' = None,
)

intracellularProperties#

Biophysical properties related to the intracellular space within the cell, such as the resistivity and the list of ionic species present. caConc and caConcExt are explicitly exposed here to facilitate accessing these values from other Components, even though caConcExt is clearly not an intracellular property.

Children list

resistivity		resistivity
speciesList		species

Exposures

caConc		concentration
caConcExt		concentration

Dynamics

Derived Variables: caConc = speciesList[ion=‘ca’]->concentration(reduce method: add) (exposed as caConc); caConcExt = speciesList[ion=‘ca’]->extConcentration(reduce method: add) (exposed as caConcExt)

Schema

<xs:complexType name="IntracellularProperties">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:sequence>
        <xs:element name="species" type="Species" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="resistivity" type="Resistivity" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import IntracellularProperties
from neuroml.utils import component_factory

variable = component_factory(
    IntracellularProperties,
    species: 'list of Species(s) (optional)' = None,
    resistivities: 'list of Resistivity(s) (optional)' = None,
    extensiontype_=None,
)

Usage: XML

<intracellularProperties>
    <resistivity value="0.1 kohm_cm"/>
</intracellularProperties>

<intracellularProperties>
    <resistivity value="0.1 kohm_cm"/>
    <!-- REMOVED UNTIL WE CHECK HOW THE USAGE OF LEMS IMPACTS THIS...
            <biochemistry reactionScheme="InternalCaDynamics"/>  Ref to earlier pathway -->
</intracellularProperties>

<intracellularProperties>
    <resistivity value="0.1 kohm_cm"/>
</intracellularProperties>

intracellularProperties2CaPools#

extends intracellularProperties

Variant of intracellularProperties with 2 independent Ca pools.

Children list

speciesList		species
resistivity		resistivity

Exposures

caConc	(from intracellularProperties)	concentration
caConc2		concentration
caConcExt	(from intracellularProperties)	concentration
caConcExt2		concentration

Dynamics

Derived Variables: caConc2 = speciesList[ion=‘ca2’]->concentration(reduce method: add) (exposed as caConc2); caConcExt2 = speciesList[ion=‘ca2’]->extConcentration(reduce method: add) (exposed as caConcExt2); caConc = speciesList[ion=‘ca’]->concentration(reduce method: add) (exposed as caConc); caConcExt = speciesList[ion=‘ca’]->extConcentration(reduce method: add) (exposed as caConcExt)

Schema

<xs:complexType name="IntracellularProperties2CaPools">
  <xs:complexContent>
    <xs:extension base="IntracellularProperties">
      </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import IntracellularProperties2CaPools
from neuroml.utils import component_factory

variable = component_factory(
    IntracellularProperties2CaPools,
    species: 'list of Species(s) (optional)' = None,
    resistivities: 'list of Resistivity(s) (optional)' = None,
)

resistivity#

The resistivity, or specific axial resistance, of the cytoplasm.

Parameters

value

resistivity

Text fields

segmentGroup

Schema

<xs:complexType name="Resistivity">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="value" type="Nml2Quantity_resistivity" use="required"/>
      <xs:attribute name="segmentGroup" type="NmlId" use="optional" default="all"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import Resistivity
from neuroml.utils import component_factory

variable = component_factory(
    Resistivity,
    value: 'a Nml2Quantity_resistivity (required)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
)

Usage: XML

<resistivity value="0.1 kohm_cm"/>

<resistivity value="0.1 kohm_cm"/>

<resistivity value="0.1 kohm_cm"/>

concentrationModel#

Base for any model of an ion concentration which changes with time. Internal ( concentration ) and external ( extConcentration ) values for the concentration of the ion are given.

Text fields

ion

Exposures

concentration		concentration
extConcentration		concentration

Requirements

initialConcentration		concentration
initialExtConcentration		concentration
surfaceArea		area

Dynamics

State Variables: concentration: concentration (exposed as concentration); extConcentration: concentration (exposed as extConcentration)
On Start: concentration = initialConcentration; extConcentration = initialExtConcentration

decayingPoolConcentrationModel#

extends concentrationModel

Model of an intracellular buffering mechanism for ion ( currently hard Coded to be calcium, due to requirement for iCa ) which has a baseline level restingConc and tends to this value with time course decayConstant. The ion is assumed to occupy a shell inside the membrane of thickness shellThickness..

Parameters

decayConstant		time
restingConc		concentration
shellThickness		length

Constants

Faraday = 96485.3C_per_mol		charge_per_mole
AREA_SCALE = 1m2		area
LENGTH_SCALE = 1m		length

Text fields

ion

Exposures

concentration	(from concentrationModel)	concentration
extConcentration	(from concentrationModel)	concentration

Requirements

iCa		current
initialConcentration	(from concentrationModel)	concentration
initialExtConcentration	(from concentrationModel)	concentration
surfaceArea	(from concentrationModel)	area

Dynamics

State Variables: concentration: concentration (exposed as concentration); extConcentration: concentration (exposed as extConcentration)
On Start: concentration = initialConcentration; extConcentration = initialExtConcentration
On Conditions: IF concentration < 0 THEN; concentration = 0
Derived Variables: effectiveRadius = LENGTH_SCALE * sqrt(surfaceArea/(AREA_SCALE * (4 * 3.14159))); innerRadius = effectiveRadius - shellThickness; shellVolume = (4 * (effectiveRadius * effectiveRadius * effectiveRadius) * 3.14159 / 3) - (4 * (innerRadius * innerRadius * innerRadius) * 3.14159 / 3)
Time Derivatives: d concentration /dt = iCa / (2 * Faraday * shellVolume) - ((concentration - restingConc) / decayConstant)

Schema

<xs:complexType name="DecayingPoolConcentrationModel">
  <xs:complexContent>
    <xs:extension base="Standalone">
      <xs:attribute name="ion" type="NmlId" use="required">
        <xs:annotation>
            </xs:annotation>
      </xs:attribute>
      <xs:attribute name="restingConc" type="Nml2Quantity_concentration" use="required"/>
      <xs:attribute name="decayConstant" type="Nml2Quantity_time" use="required"/>
      <xs:attribute name="shellThickness" type="Nml2Quantity_length" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import DecayingPoolConcentrationModel
from neuroml.utils import component_factory

variable = component_factory(
    DecayingPoolConcentrationModel,
    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,
    ion: 'a NmlId (required)' = None,
    resting_conc: 'a Nml2Quantity_concentration (required)' = None,
    decay_constant: 'a Nml2Quantity_time (required)' = None,
    shell_thickness: 'a Nml2Quantity_length (required)' = None,
    extensiontype_=None,
)

fixedFactorConcentrationModel#

extends concentrationModel

Model of buffering of concentration of an ion ( currently hard coded to be calcium, due to requirement for iCa ) which has a baseline level restingConc and tends to this value with time course decayConstant. A fixed factor rho is used to scale the incoming current independently of the size of the compartment to produce a concentration change.

Parameters

decayConstant		time
restingConc		concentration
rho		rho_factor

Text fields

ion

Exposures

concentration	(from concentrationModel)	concentration
extConcentration	(from concentrationModel)	concentration

Requirements

iCa		current
initialConcentration	(from concentrationModel)	concentration
initialExtConcentration	(from concentrationModel)	concentration
surfaceArea		area
surfaceArea	(from concentrationModel)	area

Dynamics

State Variables: concentration: concentration (exposed as concentration); extConcentration: concentration (exposed as extConcentration)
On Start: concentration = initialConcentration; extConcentration = initialExtConcentration
On Conditions: IF concentration < 0 THEN; concentration = 0
Time Derivatives: d concentration /dt = (iCa/surfaceArea) * rho - ((concentration - restingConc) / decayConstant)

Schema

<xs:complexType name="FixedFactorConcentrationModel">
  <xs:complexContent>
    <xs:extension base="Standalone">
      <xs:attribute name="ion" type="NmlId" use="required">
        <xs:annotation>
            </xs:annotation>
      </xs:attribute>
      <xs:attribute name="restingConc" type="Nml2Quantity_concentration" use="required"/>
      <xs:attribute name="decayConstant" type="Nml2Quantity_time" use="required"/>
      <xs:attribute name="rho" type="Nml2Quantity_rhoFactor" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import FixedFactorConcentrationModel
from neuroml.utils import component_factory

variable = component_factory(
    FixedFactorConcentrationModel,
    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,
    ion: 'a NmlId (required)' = None,
    resting_conc: 'a Nml2Quantity_concentration (required)' = None,
    decay_constant: 'a Nml2Quantity_time (required)' = None,
    rho: 'a Nml2Quantity_rhoFactor (required)' = None,
)

fixedFactorConcentrationModelTraub#

extends concentrationModel

Model of buffering of concentration of an ion ( currently hard coded to be calcium, due to requirement for iCa ) which has a baseline level restingConc and tends to this value with time course 1 / beta. A fixed factor phi is used to scale the incoming current independently of the size of the compartment to produce a concentration change. Not recommended for use in models other than Traub et al. 2005!

Parameters

beta		per_time
phi		rho_factor
restingConc		concentration

Text fields

species

Exposures

concentration	(from concentrationModel)	concentration
extConcentration	(from concentrationModel)	concentration

Requirements

iCa		current
initialConcentration	(from concentrationModel)	concentration
initialExtConcentration	(from concentrationModel)	concentration
surfaceArea		area
surfaceArea	(from concentrationModel)	area

Dynamics

State Variables: concentration: concentration (exposed as concentration); extConcentration: concentration (exposed as extConcentration)
On Start: concentration = initialConcentration; extConcentration = initialExtConcentration
On Conditions: IF concentration < 0 THEN; concentration = 0
Time Derivatives: d concentration /dt = (iCa/surfaceArea) * 1e-9 * phi - ((concentration - restingConc) * beta)

species#

Description of a chemical species identified by ion, which has internal, concentration, and external, extConcentration values for its concentration.

Parameters

initialConcentration		concentration
initialExtConcentration		concentration

Text fields

ion
segmentGroup

Component References

concentrationModel

concentrationModel

Exposures

concentration		concentration
extConcentration		concentration

Dynamics

Structure: CHILD INSTANCE: concentrationModel
Derived Variables: concentration = concentrationModel->concentration (exposed as concentration); extConcentration = concentrationModel->extConcentration (exposed as extConcentration)

Schema

<xs:complexType name="Species">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:attribute name="concentrationModel" type="NmlId" use="required"/>
      <xs:attribute name="ion" type="NmlId" use="optional">
        <xs:annotation>
        </xs:annotation>
      </xs:attribute>
      <xs:attribute name="initialConcentration" type="Nml2Quantity_concentration" use="required"/>
      <xs:attribute name="initialExtConcentration" type="Nml2Quantity_concentration" use="required"/>
      <xs:attribute name="segmentGroup" type="NmlId" use="optional" default="all"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import Species
from neuroml.utils import component_factory

variable = component_factory(
    Species,
    id: 'a NmlId (required)' = None,
    concentration_model: 'a NmlId (required)' = None,
    ion: 'a NmlId (optional)' = None,
    initial_concentration: 'a Nml2Quantity_concentration (required)' = None,
    initial_ext_concentration: 'a Nml2Quantity_concentration (required)' = None,
    segment_groups: 'a NmlId (optional)' = 'all',
)

cell#

extends baseCellMembPot

Cell with segments specified in a morphology element along with details on its biophysicalProperties. NOTE: this can only be correctly simulated using jLEMS when there is a single segment in the cell, and v of this cell represents the membrane potential in that isopotential segment.

Text fields

neuroLexId

Child list

morphology	Should only be used if morphology element is outside the cell. This points to the id of the morphology.	morphology
biophysicalProperties	Should only be used if biophysicalProperties element is outside the cell. This points to the id of the biophysicalProperties	biophysicalProperties

Exposures

caConc		concentration
caConcExt		concentration
iCa		current
iChannels		current
iSyn		current
spiking		Dimensionless
surfaceArea		area
totSpecCap		specificCapacitance
v	Membrane potential (from baseCellMembPot)	voltage

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Attachments

synapses

Dynamics

State Variables: v: voltage (exposed as v); spiking: Dimensionless (exposed as spiking)
On Start: spiking = 0; v = initMembPot
On Conditions: IF v > thresh AND spiking < 0.5 THEN; spiking = 1; EVENT OUT on port: spike; IF v < thresh THEN; spiking = 0
Derived Variables: initMembPot = biophysicalProperties->membraneProperties->initMembPotential->value; thresh = biophysicalProperties->membraneProperties->spikeThresh->value; surfaceArea = morphology->segments[*]->surfaceArea(reduce method: add) (exposed as surfaceArea); totSpecCap = biophysicalProperties->totSpecCap (exposed as totSpecCap); totCap = totSpecCap * surfaceArea; iChannels = biophysicalProperties->membraneProperties->totChanCurrent (exposed as iChannels); iSyn = synapses[*]->i(reduce method: add) (exposed as iSyn); iCa = biophysicalProperties->membraneProperties->iCa (exposed as iCa); caConc = biophysicalProperties->intracellularProperties->caConc (exposed as caConc); caConcExt = biophysicalProperties->intracellularProperties->caConcExt (exposed as caConcExt)
Time Derivatives: d v /dt = (iChannels + iSyn) / totCap

Schema

<xs:complexType name="Cell">
  <xs:complexContent>
    <xs:extension base="BaseCell">
      <xs:sequence>
        <xs:element name="morphology" type="Morphology" minOccurs="0"/>
        <xs:element name="biophysicalProperties" type="BiophysicalProperties" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="morphology" type="NmlId" use="optional">
        <xs:annotation>
            </xs:annotation>
      </xs:attribute>
      <xs:attribute name="biophysicalProperties" type="NmlId" use="optional">
        <xs:annotation>
            </xs:annotation>
      </xs:attribute>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

biophysicalProperties2CaPools

from neuroml import Cell
from neuroml.utils import component_factory

variable = component_factory(
    Cell,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    morphology_attr: 'a NmlId (optional)' = None,
    biophysical_properties_attr: 'a NmlId (optional)' = None,
    morphology: 'a Morphology (optional)' = None,
    biophysical_properties: 'a BiophysicalProperties (optional)' = None,
    extensiontype_=None,
)

Usage: XML

<cell id="SpikingCell" metaid="HippoCA1Cell">
    <notes>A Simple Spiking cell for testing purposes</notes>
    <annotation>
        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:bqbiol="http://biomodels.net/biology-qualifiers/">
            <rdf:Description rdf:about="HippoCA1Cell">
                <bqbiol:is>
                    <rdf:Bag>
                        <rdf:li rdf:resource="urn:miriam:neurondb:258"/>
                    </rdf:Bag>
                </bqbiol:is>
            </rdf:Description>
        </rdf:RDF>
    </annotation>
    <morphology id="SpikingCell_morphology">
        <segment id="0" name="Soma">
            <proximal x="0" y="0" z="0" diameter="10"/>
            <distal x="10" y="0" z="0" diameter="10"/>
        </segment>
        <segment id="1" name="Dendrite1">
            <parent segment="0"/>
            <distal x="20" y="0" z="0" diameter="3"/>
        </segment>
        <segment id="2" name="Dendrite2">
            <parent segment="1"/>
            <distal x="30" y="0" z="0" diameter="1"/>
        </segment>
        <segment id="3" name="Spine1">
            <parent segment="2" fractionAlong="0.5"/>
            <proximal x="25" y="0" z="0" diameter="0.1"/>
            <distal x="25" y="0.2" z="0" diameter="0.1"/>
        </segment>
        <segmentGroup id="soma_group" neuroLexId="sao1044911821">
            <member segment="0"/>
        </segmentGroup>
        <segmentGroup id="dendrite_group" neuroLexId="sao1211023249">
            <member segment="1"/>
            <member segment="2"/>
            <member segment="3"/>
        </segmentGroup>
        <segmentGroup id="spines" neuroLexId="sao1145756102">
            <member segment="3"/>
        </segmentGroup>
    </morphology>
    <biophysicalProperties id="bio_cell">
        <membraneProperties>
            <channelPopulation id="naChansDend" ionChannel="NaConductance" segment="2" number="120000" erev="50mV" ion="na"/>
            <channelDensity id="pasChans" ionChannel="pas" condDensity="3.0 S_per_m2" erev="-70mV" ion="non_specific"/>
            <channelDensity id="naChansSoma" ionChannel="NaConductance" segmentGroup="soma_group" condDensity="120.0 mS_per_cm2" erev="50mV" ion="na"/>
            <specificCapacitance segmentGroup="soma_group" value="1.0 uF_per_cm2"/>
            <specificCapacitance segmentGroup="dendrite_group" value="2.0 uF_per_cm2"/>
        </membraneProperties>
        <intracellularProperties>
            <resistivity value="0.1 kohm_cm"/>
        </intracellularProperties>
    </biophysicalProperties>
</cell>

<cell id="PyrCell" morphology="NeuroMorpho_PyrCell123" biophysicalProperties="PyrCellChanDist"/>

<cell id="SimpleCell">
    <morphology id="SimpleCell_Morphology">
        <segment id="0" name="Soma">
            <proximal x="0" y="0" z="0" diameter="10"/>
            <distal x="10" y="0" z="0" diameter="10"/>
        </segment>
        <segment id="1" name="MainDendrite1">
            <parent segment="0"/>
            <proximal x="10" y="0" z="0" diameter="3"/>
            <distal x="20" y="0" z="0" diameter="3"/>
        </segment>
        <segment id="2" name="MainDendrite2">
            <parent segment="1"/>
            <distal x="30" y="0" z="0" diameter="1"/>
        </segment>
        <segmentGroup id="soma_group" neuroLexId="sao1044911821">
            <member segment="0"/>
        </segmentGroup>
        <segmentGroup id="dendrite_group" neuroLexId="sao1211023249">
            <member segment="1"/>
            <member segment="2"/>
            <inhomogeneousParameter id="dendrite_group_x1" variable="p" metric="Path Length from root"/>
            <inhomogeneousParameter id="dendrite_group_x2" variable="r" metric="Path Length from root">
                <proximal translationStart="0"/>
                <distal normalizationEnd="1"/>
            </inhomogeneousParameter>
        </segmentGroup>
    </morphology>
    <biophysicalProperties id="biophys">
        <membraneProperties>
            <channelDensityNonUniform id="nonuniform_na_chans" ionChannel="NaConductance" erev="50mV" ion="na">
                <variableParameter parameter="condDensity" segmentGroup="dendrite_group">
                    <inhomogeneousValue inhomogeneousParameter="dendrite_group_x1" value="5e-7 * exp(-p/200)"/>
                </variableParameter>
            </channelDensityNonUniform>
            <specificCapacitance segmentGroup="soma_group" value="1.0 uF_per_cm2"/>
        </membraneProperties>
        <intracellularProperties>
            <resistivity value="0.1 kohm_cm"/>
        </intracellularProperties>
    </biophysicalProperties>
</cell>

cell2CaPools#

extends cell

Variant of cell with two independent Ca2+ pools. Cell with segments specified in a morphology element along with details on its biophysicalProperties. NOTE: this can only be correctly simulated using jLEMS when there is a single segment in the cell, and v of this cell represents the membrane potential in that isopotential segment.

Text fields

neuroLexId

Child list

biophysicalProperties2CaPools

Exposures

caConc	(from cell)	concentration
caConc2		concentration
caConcExt	(from cell)	concentration
caConcExt2		concentration
iCa	(from cell)	current
iCa2		current
iChannels	(from cell)	current
iSyn	(from cell)	current
spiking	(from cell)	Dimensionless
surfaceArea	(from cell)	area
totSpecCap	(from cell)	specificCapacitance
v	Membrane potential (from baseCellMembPot)	voltage

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Attachments

synapses

Dynamics

State Variables: v: voltage (exposed as v); spiking: Dimensionless (exposed as spiking)
On Start: spiking = 0; v = initMembPot
On Conditions: IF v > thresh AND spiking < 0.5 THEN; spiking = 1; EVENT OUT on port: spike; IF v < thresh THEN; spiking = 0
Derived Variables: initMembPot = biophysicalProperties2CaPools->membraneProperties2CaPools->initMembPotential->value; thresh = biophysicalProperties2CaPools->membraneProperties2CaPools->spikeThresh->value; surfaceArea = morphology->segments[*]->surfaceArea(reduce method: add) (exposed as surfaceArea); totSpecCap = biophysicalProperties2CaPools->totSpecCap (exposed as totSpecCap); totCap = totSpecCap * surfaceArea; iChannels = biophysicalProperties2CaPools->membraneProperties2CaPools->totChanCurrent (exposed as iChannels); iSyn = synapses[*]->i(reduce method: add) (exposed as iSyn); iCa = biophysicalProperties2CaPools->membraneProperties2CaPools->iCa (exposed as iCa); caConc = biophysicalProperties2CaPools->intracellularProperties2CaPools->caConc (exposed as caConc); caConcExt = biophysicalProperties2CaPools->intracellularProperties2CaPools->caConcExt (exposed as caConcExt); iCa2 = biophysicalProperties2CaPools->membraneProperties2CaPools->iCa2 (exposed as iCa2); caConc2 = biophysicalProperties2CaPools->intracellularProperties2CaPools->caConc2 (exposed as caConc2); caConcExt2 = biophysicalProperties2CaPools->intracellularProperties2CaPools->caConcExt2 (exposed as caConcExt2)
Time Derivatives: d v /dt = (iChannels + iSyn) / totCap

Schema

<xs:complexType name="Cell2CaPools">
  <xs:complexContent>
    <xs:extension base="Cell">
      <xs:sequence>
        <xs:element name="biophysicalProperties2CaPools" type="BiophysicalProperties2CaPools" minOccurs="0"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import Cell2CaPools
from neuroml.utils import component_factory

variable = component_factory(
    Cell2CaPools,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    morphology_attr: 'a NmlId (optional)' = None,
    biophysical_properties_attr: 'a NmlId (optional)' = None,
    morphology: 'a Morphology (optional)' = None,
    biophysical_properties: 'a BiophysicalProperties (optional)' = None,
    biophysical_properties2_ca_pools: 'a BiophysicalProperties2CaPools (optional)' = None,
)

baseCellMembPotCap#

extends baseCellMembPot

Any cell with a membrane potential v with voltage units and a membrane capacitance C. Also defines exposed value iSyn for current due to external synapses and iMemb for total transmembrane current ( usually channel currents plus iSyn ).

Parameters

C

Total capacitance of the cell membrane

capacitance

Exposures

iMemb	Total current crossing the cell membrane	current
iSyn	Total current due to synaptic inputs	current
v	Membrane potential (from baseCellMembPot)	voltage

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Schema

<xs:complexType name="BaseCellMembPotCap">
  <xs:complexContent>
    <xs:extension base="BaseCell">
      <xs:attribute name="C" type="Nml2Quantity_capacitance" use="required">
        <xs:annotation>
          <xs:appinfo>
            <jxb:property name="Cap"/>
          </xs:appinfo>
        </xs:annotation>
      </xs:attribute>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import BaseCellMembPotCap
from neuroml.utils import component_factory

variable = component_factory(
    BaseCellMembPotCap,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    C: 'a Nml2Quantity_capacitance (required)' = None,
    extensiontype_=None,
)

baseIaf#

extends baseCellMembPot

Base ComponentType for an integrate and fire cell which emits a spiking event at membrane potential thresh and and resets to reset.

Parameters

reset	The value the membrane potential is reset to on spiking	voltage
thresh	The membrane potential at which to emit a spiking event and reset voltage	voltage

Exposures

v

Membrane potential (from baseCellMembPot)

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

iafTauCell#

extends baseIaf

Integrate and fire cell which returns to its leak reversal potential of leakReversal with a time constant tau.

Parameters

leakReversal		voltage
reset	The value the membrane potential is reset to on spiking (from baseIaf)	voltage
tau		time
thresh	The membrane potential at which to emit a spiking event and reset voltage (from baseIaf)	voltage

Exposures

v

Membrane potential (from baseCellMembPot)

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Dynamics

State Variables: v: voltage (exposed as v)
On Start: v = leakReversal
On Conditions: IF v > thresh THEN; v = reset; EVENT OUT on port: spike
Time Derivatives: d v /dt = (leakReversal - v) / tau

Schema

<xs:complexType name="IafTauCell">
  <xs:complexContent>
    <xs:extension base="BaseCell">
      <xs:attribute name="leakReversal" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="thresh" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="reset" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="tau" type="Nml2Quantity_time" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import IafTauCell
from neuroml.utils import component_factory

variable = component_factory(
    IafTauCell,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    leak_reversal: 'a Nml2Quantity_voltage (required)' = None,
    thresh: 'a Nml2Quantity_voltage (required)' = None,
    reset: 'a Nml2Quantity_voltage (required)' = None,
    tau: 'a Nml2Quantity_time (required)' = None,
    extensiontype_=None,
)

Usage: XML

<iafTauCell id="iafTau" leakReversal="-50mV" thresh="-55mV" reset="-70mV" tau="30ms"/>

iafTauRefCell#

extends iafTauCell

Integrate and fire cell which returns to its leak reversal potential of leakReversal with a time course tau. It has a refractory period of refract after spiking.

Parameters

leakReversal	(from iafTauCell)	voltage
refract		time
reset	The value the membrane potential is reset to on spiking (from baseIaf)	voltage
tau	(from iafTauCell)	time
thresh	The membrane potential at which to emit a spiking event and reset voltage (from baseIaf)	voltage

Exposures

v

Membrane potential (from baseCellMembPot)

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Dynamics

State Variables: v: voltage (exposed as v); lastSpikeTime: time
On Start: v = leakReversal
Regime: refractory (initial): On Entry; lastSpikeTime = t; v = reset; On Conditions; IF t > lastSpikeTime + refract THEN; TRANSITION to REGIME integrating
Regime: integrating (initial): On Conditions; IF v > thresh THEN; EVENT OUT on port: spike; TRANSITION to REGIME refractory; Time Derivatives; d v /dt = (leakReversal - v) / tau

Schema

<xs:complexType name="IafTauRefCell">
  <xs:complexContent>
    <xs:extension base="IafTauCell">
      <xs:attribute name="refract" type="Nml2Quantity_time" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import IafTauRefCell
from neuroml.utils import component_factory

variable = component_factory(
    IafTauRefCell,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    leak_reversal: 'a Nml2Quantity_voltage (required)' = None,
    thresh: 'a Nml2Quantity_voltage (required)' = None,
    reset: 'a Nml2Quantity_voltage (required)' = None,
    tau: 'a Nml2Quantity_time (required)' = None,
    refract: 'a Nml2Quantity_time (required)' = None,
)

Usage: XML

<iafTauRefCell id="iafTauRef" leakReversal="-50mV" thresh="-55mV" reset="-70mV" tau="30ms" refract="5ms"/>

baseIafCapCell#

extends baseCellMembPotCap

Base Type for all Integrate and Fire cells with a capacitance C, threshold thresh and reset membrane potential reset.

Parameters

C	Total capacitance of the cell membrane (from baseCellMembPotCap)	capacitance
reset		voltage
thresh		voltage

Exposures

iMemb	Total current crossing the cell membrane (from baseCellMembPotCap)	current
iSyn	Total current due to synaptic inputs (from baseCellMembPotCap)	current
v	Membrane potential (from baseCellMembPot)	voltage

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

iafCell#

extends baseIafCapCell

Integrate and fire cell with capacitance C, leakConductance and leakReversal.

Parameters

C	Total capacitance of the cell membrane (from baseCellMembPotCap)	capacitance
leakConductance		conductance
leakReversal		voltage
reset	(from baseIafCapCell)	voltage
thresh	(from baseIafCapCell)	voltage

Exposures

iMemb	Total current crossing the cell membrane (from baseCellMembPotCap)	current
iSyn	Total current due to synaptic inputs (from baseCellMembPotCap)	current
v	Membrane potential (from baseCellMembPot)	voltage

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Attachments

synapses

Dynamics

State Variables: v: voltage (exposed as v)
On Start: v = leakReversal
On Conditions: IF v > thresh THEN; v = reset; EVENT OUT on port: spike
Derived Variables: iSyn = synapses[*]->i(reduce method: add) (exposed as iSyn); iMemb = leakConductance * (leakReversal - v) + iSyn (exposed as iMemb)
Time Derivatives: d v /dt = iMemb / C

Schema

<xs:complexType name="IafCell">
  <xs:complexContent>
    <xs:extension base="BaseCell">
      <xs:attribute name="leakReversal" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="thresh" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="reset" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="C" type="Nml2Quantity_capacitance" use="required"/>
      <xs:attribute name="leakConductance" type="Nml2Quantity_conductance" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import IafCell
from neuroml.utils import component_factory

variable = component_factory(
    IafCell,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    leak_reversal: 'a Nml2Quantity_voltage (required)' = None,
    thresh: 'a Nml2Quantity_voltage (required)' = None,
    reset: 'a Nml2Quantity_voltage (required)' = None,
    C: 'a Nml2Quantity_capacitance (required)' = None,
    leak_conductance: 'a Nml2Quantity_conductance (required)' = None,
    extensiontype_=None,
)

Usage: XML

<iafCell id="iaf" leakReversal="-50mV" thresh="-55mV" reset="-70mV" C="0.2nF" leakConductance="0.01uS"/>

<iafCell id="iaf" leakConductance="0.2nS" leakReversal="-70mV" thresh="-55mV" reset="-70mV" C="3.2pF"/>

<iafCell id="iaf" leakConductance="0.2nS" leakReversal="-70mV" thresh="-55mV" reset="-70mV" C="3.2pF"/>

iafRefCell#

extends iafCell

Integrate and fire cell with capacitance C, leakConductance, leakReversal and refractory period refract.

Parameters

C	Total capacitance of the cell membrane (from baseCellMembPotCap)	capacitance
leakConductance	(from iafCell)	conductance
leakReversal	(from iafCell)	voltage
refract		time
reset	(from baseIafCapCell)	voltage
thresh	(from baseIafCapCell)	voltage

Exposures

iMemb	Total current crossing the cell membrane (from baseCellMembPotCap)	current
iSyn	Total current due to synaptic inputs (from baseCellMembPotCap)	current
v	Membrane potential (from baseCellMembPot)	voltage

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Attachments

synapses

Dynamics

State Variables: v: voltage (exposed as v); lastSpikeTime: time
On Start: v = leakReversal
Derived Variables: iSyn = synapses[*]->i(reduce method: add) (exposed as iSyn); iMemb = leakConductance * (leakReversal - v) + iSyn (exposed as iMemb)
Regime: refractory (initial): On Entry; lastSpikeTime = t; v = reset; On Conditions; IF t > lastSpikeTime + refract THEN; TRANSITION to REGIME integrating
Regime: integrating (initial): On Conditions; IF v > thresh THEN; EVENT OUT on port: spike; TRANSITION to REGIME refractory; Time Derivatives; d v /dt = iMemb / C

Schema

<xs:complexType name="IafRefCell">
  <xs:complexContent>
    <xs:extension base="IafCell">
      <xs:attribute name="refract" type="Nml2Quantity_time" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import IafRefCell
from neuroml.utils import component_factory

variable = component_factory(
    IafRefCell,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    leak_reversal: 'a Nml2Quantity_voltage (required)' = None,
    thresh: 'a Nml2Quantity_voltage (required)' = None,
    reset: 'a Nml2Quantity_voltage (required)' = None,
    C: 'a Nml2Quantity_capacitance (required)' = None,
    leak_conductance: 'a Nml2Quantity_conductance (required)' = None,
    refract: 'a Nml2Quantity_time (required)' = None,
)

Usage: XML

<iafRefCell id="iafRef" leakReversal="-50mV" thresh="-55mV" reset="-70mV" C="0.2nF" leakConductance="0.01uS" refract="5ms"/>

izhikevichCell#

extends baseCellMembPot

Cell based on the 2003 model of Izhikevich, see http://izhikevich.org/publications/spikes.htm.

Parameters

a	Time scale of the recovery variable U	Dimensionless
b	Sensitivity of U to the subthreshold fluctuations of the membrane potential V	Dimensionless
c	After-spike reset value of V	Dimensionless
d	After-spike increase to U	Dimensionless
thresh	Spike threshold	voltage
v0	Initial membrane potential	voltage

Constants

MSEC = 1ms		time
MVOLT = 1mV		voltage

Exposures

U	Membrane recovery variable	Dimensionless
v	Membrane potential (from baseCellMembPot)	voltage

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Attachments

synapses

basePointCurrentDL

Dynamics

State Variables: v: voltage (exposed as v); U: Dimensionless (exposed as U)
On Start: v = v0; U = v0 * b / MVOLT
On Conditions: IF v > thresh THEN; v = c * MVOLT; U = U + d; EVENT OUT on port: spike
Derived Variables: ISyn = synapses[*]->I(reduce method: add)
Time Derivatives: d v /dt = (0.04 * v^2 / MVOLT + 5 * v + (140.0 - U + ISyn) * MVOLT)/MSEC; d U /dt = a * (b * v / MVOLT - U) / MSEC

Schema

<xs:complexType name="IzhikevichCell">
  <xs:complexContent>
    <xs:extension base="BaseCell">
      <xs:attribute name="v0" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="thresh" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="a" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="b" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="c" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="d" type="Nml2Quantity_none" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import IzhikevichCell
from neuroml.utils import component_factory

variable = component_factory(
    IzhikevichCell,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    v0: 'a Nml2Quantity_voltage (required)' = None,
    thresh: 'a Nml2Quantity_voltage (required)' = None,
    a: 'a Nml2Quantity_none (required)' = None,
    b: 'a Nml2Quantity_none (required)' = None,
    c: 'a Nml2Quantity_none (required)' = None,
    d: 'a Nml2Quantity_none (required)' = None,
)

Usage: XML

<izhikevichCell id="izBurst" v0="-70mV" thresh="30mV" a="0.02" b="0.2" c="-50.0" d="2"/>

izhikevich2007Cell#

extends baseCellMembPotCap

Cell based on the modified Izhikevich model in Izhikevich 2007, Dynamical systems in neuroscience, MIT Press.

Parameters

C	Total capacitance of the cell membrane (from baseCellMembPotCap)	capacitance
a	Time scale of recovery variable u	per_time
b	Sensitivity of recovery variable u to subthreshold fluctuations of membrane potential v	conductance
c	After-spike reset value of v	voltage
d	After-spike increase to u	current
k		conductance_per_voltage
v0	Initial membrane potential	voltage
vpeak	Peak action potential value	voltage
vr	Resting membrane potential	voltage
vt	Spike threshold	voltage

Exposures

iMemb	Total current crossing the cell membrane (from baseCellMembPotCap)	current
iSyn	Total current due to synaptic inputs (from baseCellMembPotCap)	current
u	Membrane recovery variable	current
v	Membrane potential (from baseCellMembPot)	voltage

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Attachments

synapses

Dynamics

State Variables: v: voltage (exposed as v); u: current (exposed as u)
On Start: v = v0; u = 0
On Conditions: IF v > vpeak THEN; v = c; u = u + d; EVENT OUT on port: spike
Derived Variables: iSyn = synapses[*]->i(reduce method: add) (exposed as iSyn); iMemb = k * (v-vr) * (v-vt) + iSyn - u (exposed as iMemb)
Time Derivatives: d v /dt = iMemb / C; d u /dt = a * (b * (v-vr) - u)

Schema

<xs:complexType name="Izhikevich2007Cell">
  <xs:complexContent>
    <xs:extension base="BaseCellMembPotCap">
      <xs:attribute name="v0" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="k" type="Nml2Quantity_conductancePerVoltage" use="required"/>
      <xs:attribute name="vr" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="vt" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="vpeak" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="a" type="Nml2Quantity_pertime" use="required"/>
      <xs:attribute name="b" type="Nml2Quantity_conductance" use="required"/>
      <xs:attribute name="c" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="d" type="Nml2Quantity_current" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import Izhikevich2007Cell
from neuroml.utils import component_factory

variable = component_factory(
    Izhikevich2007Cell,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    C: 'a Nml2Quantity_capacitance (required)' = None,
    v0: 'a Nml2Quantity_voltage (required)' = None,
    k: 'a Nml2Quantity_conductancePerVoltage (required)' = None,
    vr: 'a Nml2Quantity_voltage (required)' = None,
    vt: 'a Nml2Quantity_voltage (required)' = None,
    vpeak: 'a Nml2Quantity_voltage (required)' = None,
    a: 'a Nml2Quantity_pertime (required)' = None,
    b: 'a Nml2Quantity_conductance (required)' = None,
    c: 'a Nml2Quantity_voltage (required)' = None,
    d: 'a Nml2Quantity_current (required)' = None,
)

Usage: XML

<izhikevich2007Cell id="iz2007RS" v0="-60mV" C="100 pF" k="0.7 nS_per_mV" vr="-60 mV" vt="-40 mV" vpeak="35 mV" a="0.03 per_ms" b="-2 nS" c="-50 mV" d="100 pA"/>

adExIaFCell#

extends baseCellMembPotCap

Model based on Brette R and Gerstner W ( 2005 ) Adaptive Exponential Integrate-and-Fire Model as an Effective Description of Neuronal Activity. J Neurophysiol 94:3637-3642.

Parameters

C	Total capacitance of the cell membrane (from baseCellMembPotCap)	capacitance
EL	Leak reversal potential	voltage
VT	Spike threshold	voltage
a	Sub-threshold adaptation variable	conductance
b	Spike-triggered adaptation variable	current
delT	Slope factor	voltage
gL	Leak conductance	conductance
refract	Refractory period	time
reset	Reset potential	voltage
tauw	Adaptation time constant	time
thresh	Spike detection threshold	voltage

Exposures

iMemb	Total current crossing the cell membrane (from baseCellMembPotCap)	current
iSyn	Total current due to synaptic inputs (from baseCellMembPotCap)	current
v	Membrane potential (from baseCellMembPot)	voltage
w	Adaptation current	current

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Attachments

synapses

Dynamics

State Variables: v: voltage (exposed as v); w: current (exposed as w); lastSpikeTime: time
On Start: v = EL; w = 0
Derived Variables: iSyn = synapses[*]->i(reduce method: add) (exposed as iSyn); iMemb = -1 * gL * (v - EL) + gL * delT * exp((v - VT) / delT) - w + iSyn (exposed as iMemb)
Regime: refractory (initial): On Entry; lastSpikeTime = t; v = reset; w = w + b; On Conditions; IF t > lastSpikeTime + refract THEN; TRANSITION to REGIME integrating; Time Derivatives; d w /dt = (a * (v - EL) - w) / tauw
Regime: integrating (initial): On Conditions; IF v > thresh THEN; EVENT OUT on port: spike; TRANSITION to REGIME refractory; Time Derivatives; d v /dt = iMemb / C; d w /dt = (a * (v - EL) - w) / tauw

Schema

<xs:complexType name="AdExIaFCell">
  <xs:complexContent>
    <xs:extension base="BaseCellMembPotCap">
      <xs:attribute name="gL" type="Nml2Quantity_conductance" use="required"/>
      <xs:attribute name="EL" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="reset" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="VT" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="thresh" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="delT" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="tauw" type="Nml2Quantity_time" use="required"/>
      <xs:attribute name="refract" type="Nml2Quantity_time" use="required"/>
      <xs:attribute name="a" type="Nml2Quantity_conductance" use="required"/>
      <xs:attribute name="b" type="Nml2Quantity_current" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import AdExIaFCell
from neuroml.utils import component_factory

variable = component_factory(
    AdExIaFCell,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    C: 'a Nml2Quantity_capacitance (required)' = None,
    g_l: 'a Nml2Quantity_conductance (required)' = None,
    EL: 'a Nml2Quantity_voltage (required)' = None,
    reset: 'a Nml2Quantity_voltage (required)' = None,
    VT: 'a Nml2Quantity_voltage (required)' = None,
    thresh: 'a Nml2Quantity_voltage (required)' = None,
    del_t: 'a Nml2Quantity_voltage (required)' = None,
    tauw: 'a Nml2Quantity_time (required)' = None,
    refract: 'a Nml2Quantity_time (required)' = None,
    a: 'a Nml2Quantity_conductance (required)' = None,
    b: 'a Nml2Quantity_current (required)' = None,
)

Usage: XML

<adExIaFCell id="adExBurst" C="281pF" gL="30nS" EL="-70.6mV" reset="-48.5mV" VT="-50.4mV" thresh="-40.4mV" refract="0ms" delT="2mV" tauw="40ms" a="4nS" b="0.08nA"/>

fitzHughNagumoCell#

extends baseCellMembPotDL

Simple dimensionless model of spiking cell from FitzHugh and Nagumo. Superseded by fitzHughNagumo1969Cell ( See NeuroML/NeuroML2#42 ).

Parameters

I

Dimensionless

Constants

SEC = 1s

time

Exposures

V	Membrane potential (from baseCellMembPotDL)	Dimensionless
W		Dimensionless

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Dynamics

State Variables: V: Dimensionless (exposed as V); W: Dimensionless (exposed as W)
Time Derivatives: d V /dt = ( (V - ((V^3) / 3)) - W + I) / SEC; d W /dt = (0.08 * (V + 0.7 - 0.8 * W)) / SEC

Schema

<xs:complexType name="FitzHughNagumoCell">
  <xs:complexContent>
    <xs:extension base="BaseCell">
      <xs:attribute name="I" type="Nml2Quantity_none" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import FitzHughNagumoCell
from neuroml.utils import component_factory

variable = component_factory(
    FitzHughNagumoCell,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    I: 'a Nml2Quantity_none (required)' = None,
)

Usage: XML

<fitzHughNagumoCell id="fn1" I="0.8"/>

pinskyRinzelCA3Cell#

extends baseCellMembPot

Reduced CA3 cell model from Pinsky, P.F., Rinzel, J. Intrinsic and network rhythmogenesis in a reduced traub model for CA3 neurons. J Comput Neurosci 1, 39-60 ( 1994 ). See OpenSourceBrain/PinskyRinzelModel.

Parameters

alphac		Dimensionless
betac		Dimensionless
cm		specificCapacitance
eCa		voltage
eK		voltage
eL		voltage
eNa		voltage
gAmpa		conductanceDensity
gCa		conductanceDensity
gKC		conductanceDensity
gKahp		conductanceDensity
gKdr		conductanceDensity
gLd		conductanceDensity
gLs		conductanceDensity
gNa		conductanceDensity
gNmda		conductanceDensity
gc		conductanceDensity
iDend		currentDensity
iSoma		currentDensity
pp		Dimensionless
qd0		Dimensionless

Constants

MSEC = 1 ms		time
MVOLT = 1 mV		voltage
UAMP_PER_CM2 = 1 uA_per_cm2		currentDensity
Smax = 125.0		Dimensionless
Vsyn = 60.0 mV		voltage
betaqd = 0.001		Dimensionless

Exposures

Cad		Dimensionless
ICad		currentDensity
Si		Dimensionless
Vd	Dendritic membrane potential	voltage
Vs	Somatic membrane potential	voltage
Wi		Dimensionless
cd		Dimensionless
hs		Dimensionless
ns		Dimensionless
qd		Dimensionless
sd		Dimensionless
v	Membrane potential (from baseCellMembPot)	voltage

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Dynamics

State Variables: Vs: voltage (exposed as Vs); Vd: voltage (exposed as Vd); Cad: Dimensionless (exposed as Cad); hs: Dimensionless (exposed as hs); ns: Dimensionless (exposed as ns); sd: Dimensionless (exposed as sd); cd: Dimensionless (exposed as cd); qd: Dimensionless (exposed as qd); Si: Dimensionless (exposed as Si); Wi: Dimensionless (exposed as Wi); Sisat: Dimensionless
On Start: Vs = eL; Vd = eL; qd = qd0
Derived Variables: v = Vs (exposed as v); ICad = gCasdsd*(Vd-eCa) (exposed as ICad); alphams_Vs = 0.32*(-46.9-Vs/MVOLT)/(exp((-46.9-Vs/MVOLT)/4.0)-1.0); betams_Vs = 0.28*(Vs/MVOLT+19.9)/(exp((Vs/MVOLT+19.9)/5.0)-1.0); Minfs_Vs = alphams_Vs/(alphams_Vs+betams_Vs); alphans_Vs = 0.016*(-24.9-Vs/MVOLT)/(exp((-24.9-Vs/MVOLT)/5.0)-1.0); betans_Vs = 0.25exp(-1.0-0.025Vs/MVOLT); alphahs_Vs = 0.128*exp((-43.0-Vs/MVOLT)/18.0); betahs_Vs = 4.0/(1.0+exp((-20.0-Vs/MVOLT)/5.0)); alphasd_Vd = 1.6/(1.0+exp(-0.072*(Vd/MVOLT-5.0))); betasd_Vd = 0.02*(Vd/MVOLT+8.9)/(exp((Vd/MVOLT+8.9)/5.0)-1.0); Iampa = gAmpaWi(Vd-Vsyn); Inmda = gNmdaSisat(Vd-Vsyn)/(1.0+0.28exp(-0.062(Vd/MVOLT-60.0))); Isyn = Iampa+Inmda
Conditional Derived Variables: IF 0.00002*Cad > 0.01 THEN; alphaqd = 0.01; OTHERWISE; alphaqd = 0.00002*Cad; IF Cad/250 > 1 THEN; chid = 1; OTHERWISE; chid = Cad/250; IF Vd < -10*MVOLT THEN; alphacd_Vd = exp((Vd/MVOLT+50.0)/11-(Vd/MVOLT+53.5)/27)/18.975; OTHERWISE; alphacd_Vd = 2.0*exp((-53.5-Vd/MVOLT)/27.0); IF Vd < -10*MVOLT THEN; betacd_Vd = (2.0*exp((-53.5-Vd/MVOLT)/27.0)-alphacd_Vd); OTHERWISE; betacd_Vd = 0; IF Si > Smax THEN; Sisat = Smax; OTHERWISE; Sisat = Si
Time Derivatives: d Vs /dt = (-gLs*(Vs-eL)-gNa*(Minfs_Vs^2)hs(Vs-eNa)-gKdrns(Vs-eK)+(gc/pp)*(Vd-Vs)+iSoma/pp) / cm; d Vd /dt = (iDend/(1.0-pp)-Isyn/(1.0-pp)-gLd*(Vd-eL)-ICad-gKahpqd(Vd-eK)-gKCcdchid*(Vd-eK)+(gc*(Vs-Vd))/(1.0-pp)) / cm; d Cad /dt = (-0.13ICad/UAMP_PER_CM2-0.075Cad) / MSEC; d hs /dt = (alphahs_Vs-(alphahs_Vs+betahs_Vs)*hs) / MSEC; d ns /dt = (alphans_Vs-(alphans_Vs+betans_Vs)*ns) / MSEC; d sd /dt = (alphasd_Vd-(alphasd_Vd+betasd_Vd)*sd) / MSEC; d cd /dt = (alphacd_Vd-(alphacd_Vd+betacd_Vd)*cd) / MSEC; d qd /dt = (alphaqd-(alphaqd+betaqd)*qd) / MSEC; d Si /dt = -Si/150.0; d Wi /dt = -Wi/2.0

Schema

<xs:complexType name="PinskyRinzelCA3Cell">
  <xs:complexContent>
    <xs:extension base="BaseCell">
      <xs:attribute name="iSoma" type="Nml2Quantity_currentDensity" use="required"/>
      <xs:attribute name="iDend" type="Nml2Quantity_currentDensity" use="required"/>
      <xs:attribute name="gc" type="Nml2Quantity_conductanceDensity" use="required"/>
      <xs:attribute name="gLs" type="Nml2Quantity_conductanceDensity" use="required"/>
      <xs:attribute name="gLd" type="Nml2Quantity_conductanceDensity" use="required"/>
      <xs:attribute name="gNa" type="Nml2Quantity_conductanceDensity" use="required"/>
      <xs:attribute name="gKdr" type="Nml2Quantity_conductanceDensity" use="required"/>
      <xs:attribute name="gCa" type="Nml2Quantity_conductanceDensity" use="required"/>
      <xs:attribute name="gKahp" type="Nml2Quantity_conductanceDensity" use="required"/>
      <xs:attribute name="gKC" type="Nml2Quantity_conductanceDensity" use="required"/>
      <xs:attribute name="gNmda" type="Nml2Quantity_conductanceDensity" use="required"/>
      <xs:attribute name="gAmpa" type="Nml2Quantity_conductanceDensity" use="required"/>
      <xs:attribute name="eNa" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="eCa" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="eK" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="eL" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="qd0" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="pp" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="alphac" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="betac" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="cm" type="Nml2Quantity_specificCapacitance" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python

from neuroml import PinskyRinzelCA3Cell
from neuroml.utils import component_factory

variable = component_factory(
    PinskyRinzelCA3Cell,
    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,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    i_soma: 'a Nml2Quantity_currentDensity (required)' = None,
    i_dend: 'a Nml2Quantity_currentDensity (required)' = None,
    gc: 'a Nml2Quantity_conductanceDensity (required)' = None,
    g_ls: 'a Nml2Quantity_conductanceDensity (required)' = None,
    g_ld: 'a Nml2Quantity_conductanceDensity (required)' = None,
    g_na: 'a Nml2Quantity_conductanceDensity (required)' = None,
    g_kdr: 'a Nml2Quantity_conductanceDensity (required)' = None,
    g_ca: 'a Nml2Quantity_conductanceDensity (required)' = None,
    g_kahp: 'a Nml2Quantity_conductanceDensity (required)' = None,
    g_kc: 'a Nml2Quantity_conductanceDensity (required)' = None,
    g_nmda: 'a Nml2Quantity_conductanceDensity (required)' = None,
    g_ampa: 'a Nml2Quantity_conductanceDensity (required)' = None,
    e_na: 'a Nml2Quantity_voltage (required)' = None,
    e_ca: 'a Nml2Quantity_voltage (required)' = None,
    e_k: 'a Nml2Quantity_voltage (required)' = None,
    e_l: 'a Nml2Quantity_voltage (required)' = None,
    qd0: 'a Nml2Quantity_none (required)' = None,
    pp: 'a Nml2Quantity_none (required)' = None,
    alphac: 'a Nml2Quantity_none (required)' = None,
    betac: 'a Nml2Quantity_none (required)' = None,
    cm: 'a Nml2Quantity_specificCapacitance (required)' = None,
)

Usage: XML

<pinskyRinzelCA3Cell id="pr2A" iSoma="0.75 uA_per_cm2" iDend="0 uA_per_cm2" gc="2.1 mS_per_cm2" qd0="0" gLs="0.1 mS_per_cm2" gLd="0.1 mS_per_cm2" gNa="30 mS_per_cm2" gKdr="15 mS_per_cm2" gCa="10 mS_per_cm2" gKahp="0.8 mS_per_cm2" gKC="15 mS_per_cm2" eNa="60 mV" eCa="80 mV" eK="-75 mV" eL="-60 mV" pp="0.5" cm="3 uF_per_cm2" alphac="2" betac="0.1" gNmda="0 mS_per_cm2" gAmpa="0 mS_per_cm2"/>

hindmarshRose1984Cell#

extends baseCellMembPotCap

The Hindmarsh Rose model is a simplified point cell model which captures complex firing patterns of single neurons, such as periodic and chaotic bursting. It has a fast spiking subsystem, which is a generalization of the FitzHugh-Nagumo system, coupled to a slower subsystem which allows the model to fire bursts. The dynamical variables x, y, z correspond to the membrane potential, a recovery variable, and a slower adaptation current, respectively. See Hindmarsh J. L., and Rose R. M. ( 1984 ) A model of neuronal bursting using three coupled first order differential equations. Proc. R. Soc. London, Ser. B 221:87–102.

Parameters

C	Total capacitance of the cell membrane (from baseCellMembPotCap)	capacitance
a	cubic term in x nullcline	Dimensionless
b	quadratic term in x nullcline	Dimensionless
c	constant term in y nullcline	Dimensionless
d	quadratic term in y nullcline	Dimensionless
r	timescale separation between slow and fast subsystem (r greater than 0; r much less than 1)	Dimensionless
s	related to adaptation	Dimensionless
v_scaling	scaling of x for physiological membrane potential	voltage
x0		Dimensionless
x1	related to the system’s resting potential	Dimensionless
y0		Dimensionless
z0		Dimensionless

Constants

MSEC = 1ms

time

Exposures

chi		Dimensionless
iMemb	Total current crossing the cell membrane (from baseCellMembPotCap)	current
iSyn	Total current due to synaptic inputs (from baseCellMembPotCap)	current
phi		Dimensionless
rho		Dimensionless
spiking		Dimensionless
v	Membrane potential (from baseCellMembPot)	voltage
x		Dimensionless
y		Dimensionless
z		Dimensionless

Event Ports

spike

Spike event (from baseSpikingCell)

Direction: out

Attachments

synapses

Dynamics

State Variables: v: voltage (exposed as v); y: Dimensionless (exposed as y); z: Dimensionless (exposed as z); spiking: Dimensionless (exposed as spiking)
On Start: v = x0 * v_scaling; y = y0; z = z0
On Conditions: IF v > 0 AND spiking < 0.5 THEN; spiking = 1; EVENT OUT on port: spike; IF v < 0 THEN; spiking = 0
Derived Variables: iSyn = synapses[*]->i(reduce method: add) (exposed as iSyn); x = v / v_scaling (exposed as x); phi = y - a * x^3 + b * x^2 (exposed as phi); chi = c - d * x^2 - y (exposed as chi); rho = s * ( x - x1 ) - z (exposed as rho); iMemb = (C * (v_scaling * (phi - z) / MSEC)) + iSyn (exposed as iMemb)
Time Derivatives: d v /dt = iMemb/C; d y /dt = chi / MSEC; d z /dt = r * rho / MSEC

Schema

<xs:complexType name="HindmarshRose1984Cell">
  <xs:complexContent>
    <xs:extension base="BaseCellMembPotCap">
      <xs:attribute name="a" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="b" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="c" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="d" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="s" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="x1" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="r" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="x0" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="y0" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="z0" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="v_scaling" type="Nml2Quantity_voltage" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Usage: Python