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

Exposures

r

per_time

Requirements

v

voltage

baseVoltageConcDepRate

extends baseVoltageDepRate

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

Exposures

r

(from baseVoltageDepRate)

per_time

Requirements

caConc		concentration
v	(from baseVoltageDepRate)	voltage

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.

Parameters

midpoint		voltage
rate		per_time
scale		voltage

Exposures

r

(from baseVoltageDepRate)

per_time

Requirements

v

(from baseVoltageDepRate)

voltage

Schema

<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? ).

Parameters

midpoint	(from baseHHRate)	voltage
rate	(from baseHHRate)	per_time
scale	(from baseHHRate)	voltage

Exposures

r

(from baseVoltageDepRate)

per_time

Requirements

v

(from baseVoltageDepRate)

voltage

Dynamics

Derived Variables

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

Schema

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

Parameters

midpoint	(from baseHHRate)	voltage
rate	(from baseHHRate)	per_time
scale	(from baseHHRate)	voltage

Exposures

r

(from baseVoltageDepRate)

per_time

Requirements

v

(from baseVoltageDepRate)

voltage

Dynamics

Derived Variables

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

Schema

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

Parameters

midpoint	(from baseHHRate)	voltage
rate	(from baseHHRate)	per_time
scale	(from baseHHRate)	voltage

Exposures

r

(from baseVoltageDepRate)

per_time

Requirements

v

(from baseVoltageDepRate)

voltage

Dynamics

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)

Schema

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

Exposures

x

Dimensionless

Requirements

v

voltage

baseVoltageConcDepVariable

extends baseVoltageDepVariable

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

Exposures

x

(from baseVoltageDepVariable)

Dimensionless

Requirements

caConc		concentration
v	(from baseVoltageDepVariable)	voltage

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.

Parameters

midpoint		voltage
rate		Dimensionless
scale		voltage

Exposures

x

(from baseVoltageDepVariable)

Dimensionless

Requirements

v

(from baseVoltageDepVariable)

voltage

Schema

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

Parameters

midpoint	(from baseHHVariable)	voltage
rate	(from baseHHVariable)	Dimensionless
scale	(from baseHHVariable)	voltage

Exposures

x

(from baseVoltageDepVariable)

Dimensionless

Requirements

v

(from baseVoltageDepVariable)

voltage

Dynamics

Derived Variables

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

Schema

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

Parameters

midpoint	(from baseHHVariable)	voltage
rate	(from baseHHVariable)	Dimensionless
scale	(from baseHHVariable)	voltage

Exposures

x

(from baseVoltageDepVariable)

Dimensionless

Requirements

v

(from baseVoltageDepVariable)

voltage

Dynamics

Derived Variables

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

Schema

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

Parameters

midpoint	(from baseHHVariable)	voltage
rate	(from baseHHVariable)	Dimensionless
scale	(from baseHHVariable)	voltage

Exposures

x

(from baseVoltageDepVariable)

Dimensionless

Requirements

v

(from baseVoltageDepVariable)

voltage

Dynamics

Derived Variables

a = (v - midpoint) / scale

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

Schema

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

Exposures

t

time

Requirements

v

voltage

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

Exposures

t

(from baseVoltageDepTime)

time

Requirements

caConc		concentration
v	(from baseVoltageDepTime)	voltage

fixedTimeCourse

extends baseVoltageDepTime

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

Parameters

tau

time

Exposures

t

(from baseVoltageDepTime)

time

Requirements

v

(from baseVoltageDepTime)

voltage

Dynamics

Derived Variables

t = tau (exposed as t)

baseQ10Settings

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

Exposures

q10

Dimensionless

Requirements

temperature

temperature

Schema

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

Parameters

fixedQ10

Dimensionless

Exposures

q10

(from baseQ10Settings)

Dimensionless

Requirements

temperature

(from baseQ10Settings)

temperature

Dynamics

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.

Parameters

experimentalTemp		temperature
q10Factor		Dimensionless

Constants

TENDEGREES = 10K

temperature

Exposures

q10

(from baseQ10Settings)

Dimensionless

Requirements

temperature

(from baseQ10Settings)

temperature

Dynamics

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.

Exposures

factor

Dimensionless

Requirements

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.

Parameters

experimentalTemp		temperature
q10Factor		Dimensionless

Constants

TENDEGREES = 10K

temperature

Exposures

factor

(from baseConductanceScaling)

Dimensionless

Requirements

temperature

(from baseConductanceScaling)

temperature

Dynamics

Derived Variables

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

Schema

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

Usage: Python

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

Exposures

factor

(from baseConductanceScaling)

Dimensionless

Requirements

caConc		concentration
temperature	(from baseConductanceScaling)	temperature

baseGate

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

Parameters

instances

Dimensionless

Child list

notes

notes

Exposures

fcond		Dimensionless
q		Dimensionless

Schema

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

Parameters

instances

(from baseGate)

Dimensionless

Exposures

fcond	(from baseGate)	Dimensionless
q	(from baseGate)	Dimensionless

Schema

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

Usage: Python

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.

Parameters

instances

(from baseGate)

Dimensionless

Child list

forwardRate		baseVoltageDepRate
reverseRate		baseVoltageDepRate

Children list

q10Settings

baseQ10Settings

Exposures

alpha		per_time
beta		per_time
fcond	(from baseGate)	Dimensionless
inf		Dimensionless
q	(from baseGate)	Dimensionless
rateScale		Dimensionless
tau		time

Dynamics

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

Schema

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

Usage: Python

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

Usage: XML

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

Parameters

instances

(from baseGate)

Dimensionless

Child list

timeCourse		baseVoltageDepTime
steadyState		baseVoltageDepVariable

Children list

q10Settings

baseQ10Settings

Exposures

fcond	(from baseGate)	Dimensionless
inf		Dimensionless
q	(from baseGate)	Dimensionless
rateScale		Dimensionless
tau		time

Dynamics

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

Schema

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

Usage: Python

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.

Parameters

instances

(from baseGate)

Dimensionless

Constants

SEC = 1 s

time

Child list

steadyState

baseVoltageDepVariable

Exposures

fcond	(from baseGate)	Dimensionless
inf		Dimensionless
q	(from baseGate)	Dimensionless
tau		time

Dynamics

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)

Schema

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

Usage: Python

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.

Parameters

instances

(from baseGate)

Dimensionless

Child list

forwardRate		baseVoltageDepRate
reverseRate		baseVoltageDepRate
timeCourse		baseVoltageDepTime

Children list

q10Settings

baseQ10Settings

Exposures

alpha		per_time
beta		per_time
fcond	(from baseGate)	Dimensionless
inf		Dimensionless
q	(from baseGate)	Dimensionless
rateScale		Dimensionless
tau		time

Dynamics

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

Schema

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

Usage: Python

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.

Parameters

instances

(from baseGate)

Dimensionless

Child list

forwardRate		baseVoltageDepRate
reverseRate		baseVoltageDepRate
steadyState		baseVoltageDepVariable

Children list

q10Settings

baseQ10Settings

Exposures

alpha		per_time
beta		per_time
fcond	(from baseGate)	Dimensionless
inf		Dimensionless
q	(from baseGate)	Dimensionless
rateScale		Dimensionless
tau		time

Dynamics

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

Schema

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

Usage: Python

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.

Parameters

instances

(from baseGate)

Dimensionless

Child list

forwardRate		baseVoltageDepRate
reverseRate		baseVoltageDepRate
timeCourse		baseVoltageDepTime
steadyState		baseVoltageDepVariable

Children list

q10Settings

baseQ10Settings

Exposures

alpha		per_time
beta		per_time
fcond	(from baseGate)	Dimensionless
inf		Dimensionless
q	(from baseGate)	Dimensionless
rateScale		Dimensionless
tau		time

Dynamics

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

Schema

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

Usage: Python

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.

Parameters

instances

(from baseGate)

Dimensionless

Children list

q10Settings		baseQ10Settings
subGate		subGate

Exposures

fcond	(from baseGate)	Dimensionless
q	(from baseGate)	Dimensionless
rateScale		Dimensionless

Dynamics

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)

Schema

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

Usage: Python

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.

Parameters

fractionalConductance

Dimensionless

Child list

notes		notes
timeCourse		baseVoltageDepTime
steadyState		baseVoltageDepVariable

Exposures

inf		Dimensionless
q		Dimensionless
qfrac		Dimensionless
tau		time

Requirements

rateScale

Dimensionless

Dynamics

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

Schema

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

Usage: Python

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.

Parameters

conductance

conductance

Text fields

neuroLexId

Child list

notes		notes
annotation		annotation

Exposures

fopen		Dimensionless
g		conductance

Requirements

v

voltage

ionChannelPassive

extends ionChannel

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

Parameters

conductance

(from baseIonChannel)

conductance

Text fields

species

Exposures

fopen	(from baseIonChannel)	Dimensionless
g	(from baseIonChannel)	conductance

Requirements

v

(from baseIonChannel)

voltage

Dynamics

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.

Parameters

conductance

(from baseIonChannel)

conductance

Text fields

species

Children list

conductanceScaling		baseConductanceScaling
gates		gate

Exposures

fopen	(from baseIonChannel)	Dimensionless
g	(from baseIonChannel)	conductance

Requirements

v

(from baseIonChannel)

voltage

Dynamics

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)

Schema

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

Usage: Python

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

Usage: XML

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

Parameters

conductance

(from baseIonChannel)

conductance

Exposures

fopen	(from baseIonChannel)	Dimensionless
g	(from baseIonChannel)	conductance

Requirements

v

(from baseIonChannel)

voltage

Dynamics

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)

Schema

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

Usage: Python

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.

Parameters

conductance	(from baseIonChannel)	conductance
vShift		voltage

Text fields

species

Exposures

fopen	(from baseIonChannel)	Dimensionless
g	(from baseIonChannel)	conductance

Requirements

v

(from baseIonChannel)

voltage

Schema

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

Usage: Python

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.

Parameters

relativeConductance

Dimensionless

Exposures

occupancy		Dimensionless
q		Dimensionless

Dynamics

State Variables

occupancy: Dimensionless  (exposed as occupancy)

Derived Variables

q = relativeConductance * occupancy (exposed as q)

closedState

extends KSState

A KSState with relativeConductance of 0.

Parameters

relativeConductance

(from KSState)

Dimensionless

Exposures

occupancy	(from KSState)	Dimensionless
q	(from KSState)	Dimensionless

Schema

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

Usage: Python

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.

Parameters

relativeConductance

(from KSState)

Dimensionless

Exposures

occupancy	(from KSState)	Dimensionless
q	(from KSState)	Dimensionless

Schema

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

Usage: Python

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.

Parameters

conductance

(from baseIonChannel)

conductance

Text fields

species

Children list

conductanceScaling		baseConductanceScaling
gates		gateKS

Exposures

fopen	(from baseIonChannel)	Dimensionless
g	(from baseIonChannel)	conductance

Requirements

v

(from baseIonChannel)

voltage

Dynamics

Derived Variables

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

g = fopen * conductance (exposed as g)

Schema

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

Usage: Python

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.

Exposures

rf		per_time
rr		per_time

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.

Constants

SEC = 1s

time

Child list

rate

baseHHRate

Exposures

rf	(from KSTransition)	per_time
rr	(from KSTransition)	per_time

Dynamics

Derived Variables

rf0 = rate->r

rf = rf0 (exposed as rf)

rr = 0/SEC (exposed as rr)

Schema

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

Usage: Python

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.

Constants

SEC = 1s

time

Child list

rate

baseHHRate

Exposures

rf	(from KSTransition)	per_time
rr	(from KSTransition)	per_time

Dynamics

Derived Variables

rr0 = rate->r

rr = rr0 (exposed as rr)

rf = 0/SEC (exposed as rf)

Schema

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

Usage: Python

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.

Parameters

gamma		Dimensionless
tau		time
tauMin		time
vHalf		voltage
z		Dimensionless

Constants

kte = 25.3mV

voltage

Exposures

rf	(from KSTransition)	per_time
rr	(from KSTransition)	per_time

Requirements

v

voltage

Dynamics

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.

Child list

timeCourse		baseVoltageDepTime
steadyState		baseVoltageDepVariable

Exposures

rf	(from KSTransition)	per_time
rr	(from KSTransition)	per_time

Dynamics

Derived Variables

tau = timeCourse->t

inf = steadyState->x

rf = inf/tau (exposed as rf)

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

Schema

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

Usage: Python

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.

Parameters

instances

(from baseGate)

Dimensionless

Children list

states		KSState
transitions		KSTransition
q10Settings		baseQ10Settings

Exposures

fcond	(from baseGate)	Dimensionless
q	(from baseGate)	Dimensionless
rateScale		Dimensionless

Dynamics

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)

Schema

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

Usage: Python

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