Channels#

Defines voltage ( and concentration ) gated ion channel models. Ion channels will generally extend baseIonChannel. The most commonly used voltage dependent gate will extend baseGate.


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


baseVoltageDepRate#

Base ComponentType for voltage dependent rate. Produces a time varying rate r which depends on v..

baseVoltageConcDepRate#

extends baseVoltageDepRate

Base ComponentType for voltage and concentration dependent rate. Produces a time varying rate r which depends on v and caConc..

baseHHRate#

extends baseVoltageDepRate

Base ComponentType for rate which follow one of the typical forms for rate equations in the standard HH formalism, using the parameters rate, midpoint and scale.

midpoint

voltage

rate

per_time

scale

voltage

<xs:complexType name="HHRate">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="type" type="NmlId" use="required"/>
      <xs:attribute name="rate" type="Nml2Quantity_pertime" use="optional"/>
      <xs:attribute name="midpoint" type="Nml2Quantity_voltage" use="optional"/>
      <xs:attribute name="scale" type="Nml2Quantity_voltage" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

HHExpRate#

extends baseHHRate

Exponential form for rate equation ( Q: Should these be renamed hhExpRate, etc? ).

midpoint

(from baseHHRate)

voltage

rate

(from baseHHRate)

per_time

scale

(from baseHHRate)

voltage

Derived Variables

r = rate * exp((v - midpoint)/scale) (exposed as r)

<xs:complexType name="HHRate">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="type" type="NmlId" use="required"/>
      <xs:attribute name="rate" type="Nml2Quantity_pertime" use="optional"/>
      <xs:attribute name="midpoint" type="Nml2Quantity_voltage" use="optional"/>
      <xs:attribute name="scale" type="Nml2Quantity_voltage" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

HHSigmoidRate#

extends baseHHRate

Sigmoidal form for rate equation.

midpoint

(from baseHHRate)

voltage

rate

(from baseHHRate)

per_time

scale

(from baseHHRate)

voltage

Derived Variables

r = rate / (1 + exp(0 - (v - midpoint)/scale)) (exposed as r)

<xs:complexType name="HHRate">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="type" type="NmlId" use="required"/>
      <xs:attribute name="rate" type="Nml2Quantity_pertime" use="optional"/>
      <xs:attribute name="midpoint" type="Nml2Quantity_voltage" use="optional"/>
      <xs:attribute name="scale" type="Nml2Quantity_voltage" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

HHExpLinearRate#

extends baseHHRate

Exponential linear form for rate equation. Linear for large positive v, exponentially decays for large negative v..

midpoint

(from baseHHRate)

voltage

rate

(from baseHHRate)

per_time

scale

(from baseHHRate)

voltage

Derived Variables

x = (v - midpoint) / scale

Conditional Derived Variables

IF x != 0 THEN

r = rate * x / (1 - exp(0 - x))  (exposed as r)

IF x = 0 THEN

r = rate  (exposed as r)

<xs:complexType name="HHRate">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="type" type="NmlId" use="required"/>
      <xs:attribute name="rate" type="Nml2Quantity_pertime" use="optional"/>
      <xs:attribute name="midpoint" type="Nml2Quantity_voltage" use="optional"/>
      <xs:attribute name="scale" type="Nml2Quantity_voltage" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

baseVoltageDepVariable#

Base ComponentType for voltage dependent variable x, which depends on v. Can be used for inf/steady state of rate variable.

x

Dimensionless

baseVoltageConcDepVariable#

extends baseVoltageDepVariable

Base ComponentType for voltage and calcium concentration dependent variable x, which depends on v and caConc..

x

(from baseVoltageDepVariable)

Dimensionless

baseHHVariable#

extends baseVoltageDepVariable

Base ComponentType for voltage dependent dimensionless variable which follow one of the typical forms for variable equations in the standard HH formalism, using the parameters rate, midpoint, scale.

midpoint

voltage

rate

Dimensionless

scale

voltage

x

(from baseVoltageDepVariable)

Dimensionless

<xs:complexType name="HHVariable">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="type" type="NmlId" use="required"/>
      <xs:attribute name="rate" type="xs:float" use="optional"/>
      <xs:attribute name="midpoint" type="Nml2Quantity_voltage" use="optional"/>
      <xs:attribute name="scale" type="Nml2Quantity_voltage" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

HHExpVariable#

extends baseHHVariable

Exponential form for variable equation.

midpoint

(from baseHHVariable)

voltage

rate

(from baseHHVariable)

Dimensionless

scale

(from baseHHVariable)

voltage

x

(from baseVoltageDepVariable)

Dimensionless

Derived Variables

x = rate * exp((v - midpoint)/scale) (exposed as x)

<xs:complexType name="HHVariable">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="type" type="NmlId" use="required"/>
      <xs:attribute name="rate" type="xs:float" use="optional"/>
      <xs:attribute name="midpoint" type="Nml2Quantity_voltage" use="optional"/>
      <xs:attribute name="scale" type="Nml2Quantity_voltage" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

HHSigmoidVariable#

extends baseHHVariable

Sigmoidal form for variable equation.

midpoint

(from baseHHVariable)

voltage

rate

(from baseHHVariable)

Dimensionless

scale

(from baseHHVariable)

voltage

x

(from baseVoltageDepVariable)

Dimensionless

Derived Variables

x = rate / (1 + exp(0 - (v - midpoint)/scale)) (exposed as x)

<xs:complexType name="HHVariable">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="type" type="NmlId" use="required"/>
      <xs:attribute name="rate" type="xs:float" use="optional"/>
      <xs:attribute name="midpoint" type="Nml2Quantity_voltage" use="optional"/>
      <xs:attribute name="scale" type="Nml2Quantity_voltage" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

HHExpLinearVariable#

extends baseHHVariable

Exponential linear form for variable equation. Linear for large positive v, exponentially decays for large negative v..

midpoint

(from baseHHVariable)

voltage

rate

(from baseHHVariable)

Dimensionless

scale

(from baseHHVariable)

voltage

x

(from baseVoltageDepVariable)

Dimensionless

Derived Variables

a = (v - midpoint) / scale

x = rate * a / (1 - exp(0 - a)) (exposed as x)

<xs:complexType name="HHVariable">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="type" type="NmlId" use="required"/>
      <xs:attribute name="rate" type="xs:float" use="optional"/>
      <xs:attribute name="midpoint" type="Nml2Quantity_voltage" use="optional"/>
      <xs:attribute name="scale" type="Nml2Quantity_voltage" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

baseVoltageDepTime#

Base ComponentType for voltage dependent ComponentType producing value t with dimension time ( e.g. for time course of rate variable ). Note: time course would not normally be fit to exp/sigmoid etc.

t

time

baseVoltageConcDepTime#

extends baseVoltageDepTime

Base type for voltage and calcium concentration dependent ComponentType producing value t with dimension time ( e.g. for time course of rate variable ).

fixedTimeCourse#

extends baseVoltageDepTime

Time course of a fixed magnitude tau which can be used for the time course in gateHHtauInf, gateHHratesTau or gateHHratesTauInf.

tau

time

Derived Variables

t = tau (exposed as t)

baseQ10Settings#

Base ComponentType for a scaling to apply to gating variable time course, usually temperature dependent.

q10

Dimensionless

temperature

temperature

<xs:complexType name="Q10Settings">
  <xs:attribute name="type" type="NmlId" use="required"/>
  <xs:attribute name="fixedQ10" type="Nml2Quantity_none" use="optional"/>
  <xs:attribute name="q10Factor" type="Nml2Quantity_none" use="optional"/>
  <xs:attribute name="experimentalTemp" type="Nml2Quantity_temperature" use="optional"/>
</xs:complexType>

q10Fixed#

extends baseQ10Settings

A fixed value, fixedQ10, for the scaling of the time course of the gating variable.

fixedQ10

Dimensionless

q10

(from baseQ10Settings)

Dimensionless

temperature

(from baseQ10Settings)

temperature

Derived Variables

q10 = fixedQ10 (exposed as q10)

q10ExpTemp#

extends baseQ10Settings

A value for the Q10 scaling which varies as a standard function of the difference between the current temperature, temperature, and the temperature at which the gating variable equations were determined, experimentalTemp.

experimentalTemp

temperature

q10Factor

Dimensionless

TENDEGREES = 10K

temperature

q10

(from baseQ10Settings)

Dimensionless

temperature

(from baseQ10Settings)

temperature

Derived Variables

q10 = q10Factor^((temperature - experimentalTemp)/TENDEGREES) (exposed as q10)

baseConductanceScaling#

Base ComponentType for a scaling to apply to a gate’s conductance, e.g. temperature dependent scaling.

factor

Dimensionless

temperature

temperature

q10ConductanceScaling#

extends baseConductanceScaling

A value for the conductance scaling which varies as a standard function of the difference between the current temperature, temperature, and the temperature at which the conductance was originally determined, experimentalTemp.

experimentalTemp

temperature

q10Factor

Dimensionless

TENDEGREES = 10K

temperature

factor

(from baseConductanceScaling)

Dimensionless

temperature

(from baseConductanceScaling)

temperature

Derived Variables

factor = q10Factor^((temperature - experimentalTemp)/TENDEGREES) (exposed as factor)

<xs:complexType name="Q10ConductanceScaling">
  <xs:complexContent>
    <xs:extension base="BaseWithoutId">
      <xs:attribute name="q10Factor" type="Nml2Quantity_none" use="required"/>
      <xs:attribute name="experimentalTemp" type="Nml2Quantity_temperature" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import Q10ConductanceScaling
from neuroml.utils import component_factory

variable = component_factory(
    Q10ConductanceScaling,
    q10_factor: 'a Nml2Quantity_none (required)' = None,
    experimental_temp: 'a Nml2Quantity_temperature (required)' = None,
)

baseConductanceScalingCaDependent#

extends baseConductanceScaling

Base ComponentType for a scaling to apply to a gate’s conductance which depends on Ca concentration. Usually a generic expression of caConc ( so no standard, non-base form here ).

factor

(from baseConductanceScaling)

Dimensionless

baseGate#

Base ComponentType for a voltage and/or concentration dependent gate.

instances

Dimensionless

notes

notes

fcond

Dimensionless

q

Dimensionless

<xs:complexType name="GateHHUndetermined">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="q10Settings" type="Q10Settings" minOccurs="0"/>
        <xs:element name="forwardRate" type="HHRate" minOccurs="0"/>
        <xs:element name="reverseRate" type="HHRate" minOccurs="0"/>
        <xs:element name="timeCourse" type="HHTime" minOccurs="0"/>
        <xs:element name="steadyState" type="HHVariable" minOccurs="0"/>
        <xs:element name="subGate" type="GateFractionalSubgate" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="instances" type="PositiveInteger" use="required"/>
      <xs:attribute name="type" type="gateTypes" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

gate#

extends baseGate

Conveniently named baseGate.

instances

(from baseGate)

Dimensionless

fcond

(from baseGate)

Dimensionless

q

(from baseGate)

Dimensionless

<xs:complexType name="GateHHUndetermined">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="q10Settings" type="Q10Settings" minOccurs="0"/>
        <xs:element name="forwardRate" type="HHRate" minOccurs="0"/>
        <xs:element name="reverseRate" type="HHRate" minOccurs="0"/>
        <xs:element name="timeCourse" type="HHTime" minOccurs="0"/>
        <xs:element name="steadyState" type="HHVariable" minOccurs="0"/>
        <xs:element name="subGate" type="GateFractionalSubgate" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="instances" type="PositiveInteger" use="required"/>
      <xs:attribute name="type" type="gateTypes" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GateHHUndetermined
from neuroml.utils import component_factory

variable = component_factory(
    GateHHUndetermined,
    id: 'a NmlId (required)' = None,
    instances: 'a PositiveInteger (required)' = None,
    type: 'a gateTypes (required)' = None,
    notes: 'a string (optional)' = None,
    q10_settings: 'a Q10Settings (optional)' = None,
    forward_rate: 'a HHRate (optional)' = None,
    reverse_rate: 'a HHRate (optional)' = None,
    time_course: 'a HHTime (optional)' = None,
    steady_state: 'a HHVariable (optional)' = None,
    sub_gates: 'list of GateFractionalSubgate(s) (optional)' = None,
)

gateHHrates#

extends gate

Gate which follows the general Hodgkin Huxley formalism.

instances

(from baseGate)

Dimensionless

forwardRate

baseVoltageDepRate

reverseRate

baseVoltageDepRate

q10Settings

baseQ10Settings

alpha

per_time

beta

per_time

fcond

(from baseGate)

Dimensionless

inf

Dimensionless

q

(from baseGate)

Dimensionless

rateScale

Dimensionless

tau

time

State Variables

q: Dimensionless  (exposed as q)

On Start

q = inf

Derived Variables

rateScale = q10Settings[*]->q10(reduce method: multiply) (exposed as rateScale)

alpha = forwardRate->r (exposed as alpha)

beta = reverseRate->r (exposed as beta)

fcond = q^instances (exposed as fcond)

inf = alpha/(alpha+beta) (exposed as inf)

tau = 1/((alpha+beta) * rateScale) (exposed as tau)

Time Derivatives

d q /dt = (inf - q) / tau

<xs:complexType name="GateHHRates">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:all>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="q10Settings" type="Q10Settings" minOccurs="0"/>
        <xs:element name="forwardRate" type="HHRate" minOccurs="1"/>
        <xs:element name="reverseRate" type="HHRate" minOccurs="1"/>
      </xs:all>
      <xs:attribute name="instances" type="PositiveInteger" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GateHHRates
from neuroml.utils import component_factory

variable = component_factory(
    GateHHRates,
    id: 'a NmlId (required)' = None,
    instances: 'a PositiveInteger (required)' = None,
    notes: 'a string (optional)' = None,
    q10_settings: 'a Q10Settings (optional)' = None,
    forward_rate: 'a HHRate (required)' = None,
    reverse_rate: 'a HHRate (required)' = None,
)
<gateHHrates id="m" instances="3">
    <forwardRate type="HHExpLinearRate" rate="1per_ms" midpoint="-40mV" scale="10mV"/>
    <reverseRate type="HHExpRate" rate="4per_ms" midpoint="-65mV" scale="-18mV"/>
</gateHHrates>
<gateHHrates id="h" instances="1">
    <forwardRate type="HHExpRate" rate="0.07per_ms" midpoint="-65mV" scale="-20mV"/>
    <reverseRate type="HHSigmoidRate" rate="1per_ms" midpoint="-35mV" scale="10mV"/>
</gateHHrates>
<gateHHrates id="m" instances="3">
    <forwardRate type="HHExpLinearRate" rate="1per_ms" midpoint="-40mV" scale="10mV"/>
    <reverseRate type="HHExpRate" rate="4per_ms" midpoint="-65mV" scale="-18mV"/>
</gateHHrates>

gateHHtauInf#

extends gate

Gate which follows the general Hodgkin Huxley formalism.

instances

(from baseGate)

Dimensionless

q10Settings

baseQ10Settings

fcond

(from baseGate)

Dimensionless

inf

Dimensionless

q

(from baseGate)

Dimensionless

rateScale

Dimensionless

tau

time

State Variables

q: Dimensionless  (exposed as q)

On Start

q = inf

Derived Variables

rateScale = q10Settings[*]->q10(reduce method: multiply) (exposed as rateScale)

fcond = q^instances (exposed as fcond)

inf = steadyState->x (exposed as inf)

tauUnscaled = timeCourse->t

tau = tauUnscaled / rateScale (exposed as tau)

Time Derivatives

d q /dt = (inf - q) / tau

<xs:complexType name="GateHHTauInf">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:all>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="q10Settings" type="Q10Settings" minOccurs="0"/>
        <xs:element name="timeCourse" type="HHTime" minOccurs="1"/>
        <xs:element name="steadyState" type="HHVariable" minOccurs="1"/>
      </xs:all>
      <xs:attribute name="instances" type="PositiveInteger" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GateHHTauInf
from neuroml.utils import component_factory

variable = component_factory(
    GateHHTauInf,
    id: 'a NmlId (required)' = None,
    instances: 'a PositiveInteger (required)' = None,
    notes: 'a string (optional)' = None,
    q10_settings: 'a Q10Settings (optional)' = None,
    time_course: 'a HHTime (required)' = None,
    steady_state: 'a HHVariable (required)' = None,
)

gateHHInstantaneous#

extends gate

Gate which follows the general Hodgkin Huxley formalism but is instantaneous, so tau = 0 and gate follows exactly inf value.

instances

(from baseGate)

Dimensionless

SEC = 1 s

time

fcond

(from baseGate)

Dimensionless

inf

Dimensionless

q

(from baseGate)

Dimensionless

tau

time

Derived Variables

inf = steadyState->x (exposed as inf)

tau = 0 * SEC (exposed as tau)

q = inf (exposed as q)

fcond = q^instances (exposed as fcond)

<xs:complexType name="GateHHInstantaneous">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:all>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="steadyState" type="HHVariable" minOccurs="1"/>
      </xs:all>
      <xs:attribute name="instances" type="PositiveInteger" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GateHHInstantaneous
from neuroml.utils import component_factory

variable = component_factory(
    GateHHInstantaneous,
    id: 'a NmlId (required)' = None,
    instances: 'a PositiveInteger (required)' = None,
    notes: 'a string (optional)' = None,
    steady_state: 'a HHVariable (required)' = None,
)

gateHHratesTau#

extends gate

Gate which follows the general Hodgkin Huxley formalism.

instances

(from baseGate)

Dimensionless

forwardRate

baseVoltageDepRate

reverseRate

baseVoltageDepRate

timeCourse

baseVoltageDepTime

q10Settings

baseQ10Settings

alpha

per_time

beta

per_time

fcond

(from baseGate)

Dimensionless

inf

Dimensionless

q

(from baseGate)

Dimensionless

rateScale

Dimensionless

tau

time

State Variables

q: Dimensionless  (exposed as q)

On Start

q = inf

Derived Variables

rateScale = q10Settings[*]->q10(reduce method: multiply) (exposed as rateScale)

alpha = forwardRate->r (exposed as alpha)

beta = reverseRate->r (exposed as beta)

fcond = q^instances (exposed as fcond)

inf = alpha/(alpha+beta) (exposed as inf)

tauUnscaled = timeCourse->t

tau = tauUnscaled / rateScale (exposed as tau)

Time Derivatives

d q /dt = (inf - q) / tau

<xs:complexType name="GateHHRatesTau">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:all>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="q10Settings" type="Q10Settings" minOccurs="0"/>
        <xs:element name="forwardRate" type="HHRate" minOccurs="1"/>
        <xs:element name="reverseRate" type="HHRate" minOccurs="1"/>
        <xs:element name="timeCourse" type="HHTime" minOccurs="1"/>
      </xs:all>
      <xs:attribute name="instances" type="PositiveInteger" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GateHHRatesTau
from neuroml.utils import component_factory

variable = component_factory(
    GateHHRatesTau,
    id: 'a NmlId (required)' = None,
    instances: 'a PositiveInteger (required)' = None,
    notes: 'a string (optional)' = None,
    q10_settings: 'a Q10Settings (optional)' = None,
    forward_rate: 'a HHRate (required)' = None,
    reverse_rate: 'a HHRate (required)' = None,
    time_course: 'a HHTime (required)' = None,
)

gateHHratesInf#

extends gate

Gate which follows the general Hodgkin Huxley formalism.

instances

(from baseGate)

Dimensionless

forwardRate

baseVoltageDepRate

reverseRate

baseVoltageDepRate

steadyState

baseVoltageDepVariable

q10Settings

baseQ10Settings

alpha

per_time

beta

per_time

fcond

(from baseGate)

Dimensionless

inf

Dimensionless

q

(from baseGate)

Dimensionless

rateScale

Dimensionless

tau

time

State Variables

q: Dimensionless  (exposed as q)

On Start

q = inf

Derived Variables

rateScale = q10Settings[*]->q10(reduce method: multiply) (exposed as rateScale)

alpha = forwardRate->r (exposed as alpha)

beta = reverseRate->r (exposed as beta)

fcond = q^instances (exposed as fcond)

inf = steadyState->x (exposed as inf)

tau = 1/((alpha+beta) * rateScale) (exposed as tau)

Time Derivatives

d q /dt = (inf - q) / tau

<xs:complexType name="GateHHRatesInf">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:all>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="q10Settings" type="Q10Settings" minOccurs="0"/>
        <xs:element name="forwardRate" type="HHRate" minOccurs="1"/>
        <xs:element name="reverseRate" type="HHRate" minOccurs="1"/>
        <xs:element name="steadyState" type="HHVariable" minOccurs="1"/>
      </xs:all>
      <xs:attribute name="instances" type="PositiveInteger" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GateHHRatesInf
from neuroml.utils import component_factory

variable = component_factory(
    GateHHRatesInf,
    id: 'a NmlId (required)' = None,
    instances: 'a PositiveInteger (required)' = None,
    notes: 'a string (optional)' = None,
    q10_settings: 'a Q10Settings (optional)' = None,
    forward_rate: 'a HHRate (required)' = None,
    reverse_rate: 'a HHRate (required)' = None,
    steady_state: 'a HHVariable (required)' = None,
)

gateHHratesTauInf#

extends gate

Gate which follows the general Hodgkin Huxley formalism.

instances

(from baseGate)

Dimensionless

forwardRate

baseVoltageDepRate

reverseRate

baseVoltageDepRate

timeCourse

baseVoltageDepTime

steadyState

baseVoltageDepVariable

q10Settings

baseQ10Settings

alpha

per_time

beta

per_time

fcond

(from baseGate)

Dimensionless

inf

Dimensionless

q

(from baseGate)

Dimensionless

rateScale

Dimensionless

tau

time

State Variables

q: Dimensionless  (exposed as q)

On Start

q = inf

Derived Variables

rateScale = q10Settings[*]->q10(reduce method: multiply) (exposed as rateScale)

alpha = forwardRate->r (exposed as alpha)

beta = reverseRate->r (exposed as beta)

inf = steadyState->x (exposed as inf)

tauUnscaled = timeCourse->t

tau = tauUnscaled / rateScale (exposed as tau)

fcond = q^instances (exposed as fcond)

Time Derivatives

d q /dt = (inf - q) / tau

<xs:complexType name="GateHHRatesTauInf">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:all>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="q10Settings" type="Q10Settings" minOccurs="0"/>
        <xs:element name="forwardRate" type="HHRate" minOccurs="1"/>
        <xs:element name="reverseRate" type="HHRate" minOccurs="1"/>
        <xs:element name="timeCourse" type="HHTime" minOccurs="1"/>
        <xs:element name="steadyState" type="HHVariable" minOccurs="1"/>
      </xs:all>
      <xs:attribute name="instances" type="PositiveInteger" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GateHHRatesTauInf
from neuroml.utils import component_factory

variable = component_factory(
    GateHHRatesTauInf,
    id: 'a NmlId (required)' = None,
    instances: 'a PositiveInteger (required)' = None,
    notes: 'a string (optional)' = None,
    q10_settings: 'a Q10Settings (optional)' = None,
    forward_rate: 'a HHRate (required)' = None,
    reverse_rate: 'a HHRate (required)' = None,
    time_course: 'a HHTime (required)' = None,
    steady_state: 'a HHVariable (required)' = None,
)

gateFractional#

extends gate

Gate composed of subgates contributing with fractional conductance.

instances

(from baseGate)

Dimensionless

q10Settings

baseQ10Settings

subGate

subGate

fcond

(from baseGate)

Dimensionless

q

(from baseGate)

Dimensionless

rateScale

Dimensionless

Derived Variables

q = subGate[*]->qfrac(reduce method: add) (exposed as q)

fcond = q^instances (exposed as fcond)

rateScale = q10Settings[*]->q10(reduce method: multiply) (exposed as rateScale)

<xs:complexType name="GateFractional">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="q10Settings" type="Q10Settings" minOccurs="0"/>
        <xs:element name="subGate" type="GateFractionalSubgate" minOccurs="1" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="instances" type="PositiveInteger" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GateFractional
from neuroml.utils import component_factory

variable = component_factory(
    GateFractional,
    id: 'a NmlId (required)' = None,
    instances: 'a PositiveInteger (required)' = None,
    notes: 'a string (optional)' = None,
    q10_settings: 'a Q10Settings (optional)' = None,
    sub_gates: 'list of GateFractionalSubgate(s) (required)' = None,
)

subGate#

Gate composed of subgates contributing with fractional conductance.

fractionalConductance

Dimensionless

notes

notes

timeCourse

baseVoltageDepTime

steadyState

baseVoltageDepVariable

inf

Dimensionless

q

Dimensionless

qfrac

Dimensionless

tau

time

rateScale

Dimensionless

State Variables

q: Dimensionless  (exposed as q)

On Start

q = inf

Derived Variables

inf = steadyState->x (exposed as inf)

tauUnscaled = timeCourse->t

tau = tauUnscaled / rateScale (exposed as tau)

qfrac = q * fractionalConductance (exposed as qfrac)

Time Derivatives

d q /dt = (inf - q) / tau

<xs:complexType name="GateFractionalSubgate">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:all>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="q10Settings" type="Q10Settings" minOccurs="0"/>
        <xs:element name="steadyState" type="HHVariable" minOccurs="1"/>
        <xs:element name="timeCourse" type="HHTime" minOccurs="1"/>
      </xs:all>
      <xs:attribute name="fractionalConductance" type="Nml2Quantity_none" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GateFractionalSubgate
from neuroml.utils import component_factory

variable = component_factory(
    GateFractionalSubgate,
    id: 'a NmlId (required)' = None,
    fractional_conductance: 'a Nml2Quantity_none (required)' = None,
    notes: 'a string (optional)' = None,
    q10_settings: 'a Q10Settings (optional)' = None,
    steady_state: 'a HHVariable (required)' = None,
    time_course: 'a HHTime (required)' = None,
)

baseIonChannel#

Base for all ion channel ComponentTypes.

conductance

conductance

neuroLexId

notes

notes

annotation

annotation

fopen

Dimensionless

g

conductance

ionChannelPassive#

extends ionChannel

Simple passive ion channel where the constant conductance through the channel is equal to conductance.

conductance

(from baseIonChannel)

conductance

species

fopen

(from baseIonChannel)

Dimensionless

g

(from baseIonChannel)

conductance

Derived Variables

fopen = 1 (exposed as fopen)

g = conductance (exposed as g)

ionChannelHH#

extends baseIonChannel

Note ionChannel and ionChannelHH are currently functionally identical. This is needed since many existing examples use ionChannel, some use ionChannelHH. NeuroML v2beta4 should remove one of these, probably ionChannelHH.

conductance

(from baseIonChannel)

conductance

species

conductanceScaling

baseConductanceScaling

gates

gate

fopen

(from baseIonChannel)

Dimensionless

g

(from baseIonChannel)

conductance

Derived Variables

conductanceScale = conductanceScaling[*]->factor(reduce method: multiply)

fopen0 = gates[*]->fcond(reduce method: multiply)

fopen = conductanceScale * fopen0 (exposed as fopen)

g = conductance * fopen (exposed as g)

<xs:complexType name="IonChannelHH">
  <xs:complexContent>
    <xs:extension base="IonChannel"/>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import IonChannelHH
from neuroml.utils import component_factory

variable = component_factory(
    IonChannelHH,
    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,
    q10_conductance_scalings: 'list of Q10ConductanceScaling(s) (optional)' = None,
    species: 'a NmlId (optional)' = None,
    type: 'a channelTypes (optional)' = None,
    conductance: 'a Nml2Quantity_conductance (optional)' = None,
    gates: 'list of GateHHUndetermined(s) (optional)' = None,
    gate_hh_rates: 'list of GateHHRates(s) (optional)' = None,
    gate_h_hrates_taus: 'list of GateHHRatesTau(s) (optional)' = None,
    gate_hh_tau_infs: 'list of GateHHTauInf(s) (optional)' = None,
    gate_h_hrates_infs: 'list of GateHHRatesInf(s) (optional)' = None,
    gate_h_hrates_tau_infs: 'list of GateHHRatesTauInf(s) (optional)' = None,
    gate_hh_instantaneouses: 'list of GateHHInstantaneous(s) (optional)' = None,
    gate_fractionals: 'list of GateFractional(s) (optional)' = None,
)
<ionChannelHH id="pas" conductance="10pS"/>
<ionChannelHH id="HH_Na" conductance="10pS" species="na">  
        
    </ionChannelHH>
<ionChannelHH id="NaConductance" conductance="10pS" species="na">
    <gateHHrates id="m" instances="3">
        <forwardRate type="HHExpLinearRate" rate="1per_ms" midpoint="-40mV" scale="10mV"/>
        <reverseRate type="HHExpRate" rate="4per_ms" midpoint="-65mV" scale="-18mV"/>
    </gateHHrates>
    <gateHHrates id="h" instances="1">
        <forwardRate type="HHExpRate" rate="0.07per_ms" midpoint="-65mV" scale="-20mV"/>
        <reverseRate type="HHSigmoidRate" rate="1per_ms" midpoint="-35mV" scale="10mV"/>
    </gateHHrates>
</ionChannelHH>

ionChannel#

extends ionChannelHH

Note ionChannel and ionChannelHH are currently functionally identical. This is needed since many existing examples use ionChannel, some use ionChannelHH. NeuroML v2beta4 should remove one of these, probably ionChannelHH.

conductance

(from baseIonChannel)

conductance

fopen

(from baseIonChannel)

Dimensionless

g

(from baseIonChannel)

conductance

Derived Variables

conductanceScale = conductanceScaling[*]->factor(reduce method: multiply)

fopen0 = gates[*]->fcond(reduce method: multiply)

fopen = conductanceScale * fopen0 (exposed as fopen)

g = conductance * fopen (exposed as g)

<xs:complexType name="IonChannel">
  <xs:complexContent>
    <xs:extension base="IonChannelScalable">
      <xs:choice>
        <xs:element name="gate" type="GateHHUndetermined" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="gateHHrates" type="GateHHRates" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="gateHHratesTau" type="GateHHRatesTau" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="gateHHtauInf" type="GateHHTauInf" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="gateHHratesInf" type="GateHHRatesInf" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="gateHHratesTauInf" type="GateHHRatesTauInf" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="gateHHInstantaneous" type="GateHHInstantaneous" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element name="gateFractional" type="GateFractional" minOccurs="0" maxOccurs="unbounded"/>
      </xs:choice>
      <xs:attribute name="species" type="NmlId" use="optional"/>
      <xs:attribute name="type" type="channelTypes" use="optional"/>
      <xs:attribute name="conductance" type="Nml2Quantity_conductance" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import IonChannel
from neuroml.utils import component_factory

variable = component_factory(
    IonChannel,
    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,
    q10_conductance_scalings: 'list of Q10ConductanceScaling(s) (optional)' = None,
    species: 'a NmlId (optional)' = None,
    type: 'a channelTypes (optional)' = None,
    conductance: 'a Nml2Quantity_conductance (optional)' = None,
    gates: 'list of GateHHUndetermined(s) (optional)' = None,
    gate_hh_rates: 'list of GateHHRates(s) (optional)' = None,
    gate_h_hrates_taus: 'list of GateHHRatesTau(s) (optional)' = None,
    gate_hh_tau_infs: 'list of GateHHTauInf(s) (optional)' = None,
    gate_h_hrates_infs: 'list of GateHHRatesInf(s) (optional)' = None,
    gate_h_hrates_tau_infs: 'list of GateHHRatesTauInf(s) (optional)' = None,
    gate_hh_instantaneouses: 'list of GateHHInstantaneous(s) (optional)' = None,
    gate_fractionals: 'list of GateFractional(s) (optional)' = None,
    extensiontype_=None,
)

ionChannelVShift#

extends ionChannel

Same as ionChannel, 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.

conductance

(from baseIonChannel)

conductance

vShift

voltage

species

fopen

(from baseIonChannel)

Dimensionless

g

(from baseIonChannel)

conductance

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

Go to the libNeuroML documentation

from neuroml import IonChannelVShift
from neuroml.utils import component_factory

variable = component_factory(
    IonChannelVShift,
    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,
    q10_conductance_scalings: 'list of Q10ConductanceScaling(s) (optional)' = None,
    species: 'a NmlId (optional)' = None,
    type: 'a channelTypes (optional)' = None,
    conductance: 'a Nml2Quantity_conductance (optional)' = None,
    gates: 'list of GateHHUndetermined(s) (optional)' = None,
    gate_hh_rates: 'list of GateHHRates(s) (optional)' = None,
    gate_h_hrates_taus: 'list of GateHHRatesTau(s) (optional)' = None,
    gate_hh_tau_infs: 'list of GateHHTauInf(s) (optional)' = None,
    gate_h_hrates_infs: 'list of GateHHRatesInf(s) (optional)' = None,
    gate_h_hrates_tau_infs: 'list of GateHHRatesTauInf(s) (optional)' = None,
    gate_hh_instantaneouses: 'list of GateHHInstantaneous(s) (optional)' = None,
    gate_fractionals: 'list of GateFractional(s) (optional)' = None,
    v_shift: 'a Nml2Quantity_voltage (required)' = None,
)

KSState#

One of the states in which a gateKS can be. The rates of transitions between these states are given by KSTransitions.

relativeConductance

Dimensionless

occupancy

Dimensionless

q

Dimensionless

State Variables

occupancy: Dimensionless  (exposed as occupancy)

Derived Variables

q = relativeConductance * occupancy (exposed as q)

closedState#

extends KSState

A KSState with relativeConductance of 0.

relativeConductance

(from KSState)

Dimensionless

occupancy

(from KSState)

Dimensionless

q

(from KSState)

Dimensionless

<xs:complexType name="ClosedState">
  <xs:complexContent>
    <xs:extension base="Base">
      </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import ClosedState
from neuroml.utils import component_factory

variable = component_factory(
    ClosedState,
    id: 'a NmlId (required)' = None,
)

openState#

extends KSState

A KSState with relativeConductance of 1.

relativeConductance

(from KSState)

Dimensionless

occupancy

(from KSState)

Dimensionless

q

(from KSState)

Dimensionless

<xs:complexType name="OpenState">
  <xs:complexContent>
    <xs:extension base="Base">
      </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import OpenState
from neuroml.utils import component_factory

variable = component_factory(
    OpenState,
    id: 'a NmlId (required)' = None,
)

ionChannelKS#

extends baseIonChannel

A kinetic scheme based ion channel with multiple gateKSs, each of which consists of multiple KSStates and KSTransitions giving the rates of transition between them.

conductance

(from baseIonChannel)

conductance

species

conductanceScaling

baseConductanceScaling

gates

gateKS

fopen

(from baseIonChannel)

Dimensionless

g

(from baseIonChannel)

conductance

Derived Variables

fopen = gates[*]->fcond(reduce method: multiply) (exposed as fopen)

g = fopen * conductance (exposed as g)

<xs:complexType name="IonChannelKS">
  <xs:complexContent>
    <xs:extension base="Standalone">
      <xs:sequence>
        <xs:element name="gateKS" type="GateKS" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="species" type="NmlId" use="optional"/>
      <xs:attribute name="conductance" type="Nml2Quantity_conductance" use="optional"/>
      <xs:attribute name="neuroLexId" type="NeuroLexId" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import IonChannelKS
from neuroml.utils import component_factory

variable = component_factory(
    IonChannelKS,
    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,
    species: 'a NmlId (optional)' = None,
    conductance: 'a Nml2Quantity_conductance (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    gate_kses: 'list of GateKS(s) (optional)' = None,
)

KSTransition#

Specified the forward and reverse rates of transition between two KSStates in a gateKS.

forwardTransition#

extends KSTransition

A forward only KSTransition for a gateKS which specifies a rate ( type baseHHRate ) which follows one of the standard Hodgkin Huxley forms ( e.g. HHExpRate, HHSigmoidRate, HHExpLinearRate.

SEC = 1s

time

rate

baseHHRate

Derived Variables

rf0 = rate->r

rf = rf0 (exposed as rf)

rr = 0/SEC (exposed as rr)

<xs:complexType name="ForwardTransition">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:any processContents="skip" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="from" type="NmlId" use="required"/>
      <xs:attribute name="to" type="NmlId" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import ForwardTransition
from neuroml.utils import component_factory

variable = component_factory(
    ForwardTransition,
    id: 'a NmlId (required)' = None,
    from_: 'a NmlId (required)' = None,
    to: 'a NmlId (required)' = None,
    anytypeobjs_=None,
)

reverseTransition#

extends KSTransition

A reverse only KSTransition for a gateKS which specifies a rate ( type baseHHRate ) which follows one of the standard Hodgkin Huxley forms ( e.g. HHExpRate, HHSigmoidRate, HHExpLinearRate.

SEC = 1s

time

rate

baseHHRate

Derived Variables

rr0 = rate->r

rr = rr0 (exposed as rr)

rf = 0/SEC (exposed as rf)

<xs:complexType name="ReverseTransition">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:any processContents="skip" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="from" type="NmlId" use="required"/>
      <xs:attribute name="to" type="NmlId" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import ReverseTransition
from neuroml.utils import component_factory

variable = component_factory(
    ReverseTransition,
    id: 'a NmlId (required)' = None,
    from_: 'a NmlId (required)' = None,
    to: 'a NmlId (required)' = None,
    anytypeobjs_=None,
)

vHalfTransition#

extends KSTransition

Transition which specifies both the forward and reverse rates of transition.

gamma

Dimensionless

tau

time

tauMin

time

vHalf

voltage

z

Dimensionless

kte = 25.3mV

voltage

Derived Variables

rf0 = exp(z * gamma * (v - vHalf) / kte) / tau

rr0 = exp(-z * (1 - gamma) * (v - vHalf) / kte) / tau

rf = 1 / (1/rf0 + tauMin) (exposed as rf)

rr = 1 / (1/rr0 + tauMin) (exposed as rr)

tauInfTransition#

extends KSTransition

KS Transition specified in terms of time constant schema:tau and steady state schema:inf.

Derived Variables

tau = timeCourse->t

inf = steadyState->x

rf = inf/tau (exposed as rf)

rr = (1-inf)/tau (exposed as rr)

<xs:complexType name="TauInfTransition">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:all>
        <xs:element name="steadyState" type="HHVariable"/>
        <xs:element name="timeCourse" type="HHTime"/>
      </xs:all>
      <xs:attribute name="from" type="NmlId" use="required"/>
      <xs:attribute name="to" type="NmlId" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import TauInfTransition
from neuroml.utils import component_factory

variable = component_factory(
    TauInfTransition,
    id: 'a NmlId (required)' = None,
    from_: 'a NmlId (required)' = None,
    to: 'a NmlId (required)' = None,
    steady_state: 'a HHVariable (required)' = None,
    time_course: 'a HHTime (required)' = None,
)

gateKS#

extends baseGate

A gate which consists of multiple KSStates and KSTransitions giving the rates of transition between them.

instances

(from baseGate)

Dimensionless

states

KSState

transitions

KSTransition

q10Settings

baseQ10Settings

fcond

(from baseGate)

Dimensionless

q

(from baseGate)

Dimensionless

rateScale

Dimensionless

Derived Variables

rateScale = q10Settings[*]->q10(reduce method: multiply) (exposed as rateScale)

q = states[*]->q(reduce method: add) (exposed as q)

fcond = q^instances (exposed as fcond)

<xs:complexType name="GateKS">
  <xs:complexContent>
    <xs:extension base="Base">
      <xs:sequence>
        <xs:element name="notes" type="Notes" minOccurs="0"/>
        <xs:element name="q10Settings" type="Q10Settings" minOccurs="0"/>
        <xs:element name="closedState" type="ClosedState" minOccurs="1" maxOccurs="unbounded"/>
        <xs:element name="openState" type="OpenState" minOccurs="1" maxOccurs="unbounded"/>
        <xs:choice minOccurs="1" maxOccurs="unbounded">
          <xs:group ref="ForwardReverseTransition"/>
          <xs:element name="tauInfTransition" type="TauInfTransition"/>
        </xs:choice>
      </xs:sequence>
      <xs:attribute name="instances" type="PositiveInteger" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GateKS
from neuroml.utils import component_factory

variable = component_factory(
    GateKS,
    id: 'a NmlId (required)' = None,
    instances: 'a PositiveInteger (required)' = None,
    notes: 'a string (optional)' = None,
    q10_settings: 'a Q10Settings (optional)' = None,
    closed_states: 'list of ClosedState(s) (required)' = None,
    open_states: 'list of OpenState(s) (required)' = None,
    forward_transition: 'list of ForwardTransition(s) (required)' = None,
    reverse_transition: 'list of ReverseTransition(s) (required)' = None,
    tau_inf_transition: 'list of TauInfTransition(s) (required)' = None,
)