Channels

Original ComponentType definitions: Channels.xml.

Schema against which NeuroML based on these should be valid: NeuroML_v2.1.xsd.

Generated on 01/06/21 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

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)

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)

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)

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

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)

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)

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)

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

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)

Python: libNeuroML API

from neuroml import Q10ConductanceScaling

variable = Q10ConductanceScaling(q10_factor=None, experimental_temp=None, **kwargs_)

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

gate

extends baseGate

Conveniently named baseGate.

instances

(from baseGate)

Dimensionless

fcond

(from baseGate)

Dimensionless

q

(from baseGate)

Dimensionless

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

XML examples

<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

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)

Python: libNeuroML API

from neuroml import GateHHInstantaneous

variable = GateHHInstantaneous(neuro_lex_id=None, id=None, instances=None, notes=None, steady_state=None, **kwargs_)

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

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

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

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)

Python: libNeuroML API

from neuroml import GateFractional

variable = GateFractional(neuro_lex_id=None, id=None, instances=None, notes=None, q10_settings=None, sub_gates=None, **kwargs_)

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

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)

Python: libNeuroML API

from neuroml import IonChannelHH

variable = IonChannelHH(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, q10_conductance_scalings=None, species=None, type=None, conductance=None, gates=None, gate_hh_rates=None, gate_h_hrates_taus=None, gate_hh_tau_infs=None, gate_h_hrates_infs=None, gate_h_hrates_tau_infs=None, gate_hh_instantaneouses=None, gate_fractionals=None, **kwargs_)

XML examples

<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>
<ionChannelHH xmlns:xi="http://www.w3.org/2001/XInclude" id="pas" conductance="10pS"/>
<ionChannelHH id="naChan" conductance="10pS" species="na">
        <notes>Na channel</notes>
        <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)

Python: libNeuroML API

from neuroml import IonChannel

variable = IonChannel(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, q10_conductance_scalings=None, species=None, type=None, conductance=None, gates=None, gate_hh_rates=None, gate_h_hrates_taus=None, gate_hh_tau_infs=None, gate_h_hrates_infs=None, gate_h_hrates_tau_infs=None, gate_hh_instantaneouses=None, gate_fractionals=None, extensiontype_=None, **kwargs_)

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

Python: libNeuroML API

from neuroml import IonChannelVShift

variable = IonChannelVShift(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, q10_conductance_scalings=None, species=None, type=None, conductance=None, gates=None, gate_hh_rates=None, gate_h_hrates_taus=None, gate_hh_tau_infs=None, gate_h_hrates_infs=None, gate_h_hrates_tau_infs=None, gate_hh_instantaneouses=None, gate_fractionals=None, v_shift=None, **kwargs_)

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

Python: libNeuroML API

from neuroml import ClosedState

variable = ClosedState(neuro_lex_id=None, id=None, **kwargs_)

openState

extends KSState

A KSState with relativeConductance of 1.

relativeConductance

(from KSState)

Dimensionless

occupancy

(from KSState)

Dimensionless

q

(from KSState)

Dimensionless

Python: libNeuroML API

from neuroml import OpenState

variable = OpenState(neuro_lex_id=None, id=None, **kwargs_)

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)

Python: libNeuroML API

from neuroml import IonChannelKS

variable = IonChannelKS(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, species=None, conductance=None, gate_kses=None, **kwargs_)

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.

rate

baseHHRate

SEC = 1s

time

Derived Variables

rf0 = rate->r

rf = rf0 (exposed as rf)

rr = 0/SEC (exposed as rr)

Python: libNeuroML API

from neuroml import ForwardTransition

variable = ForwardTransition(neuro_lex_id=None, id=None, from_=None, to=None, anytypeobjs_=None, **kwargs_)

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.

rate

baseHHRate

SEC = 1s

time

Derived Variables

rr0 = rate->r

rr = rr0 (exposed as rr)

rf = 0/SEC (exposed as rf)

Python: libNeuroML API

from neuroml import ReverseTransition

variable = ReverseTransition(neuro_lex_id=None, id=None, from_=None, to=None, anytypeobjs_=None, **kwargs_)

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)

Python: libNeuroML API

from neuroml import TauInfTransition

variable = TauInfTransition(neuro_lex_id=None, id=None, from_=None, to=None, steady_state=None, time_course=None, **kwargs_)

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)

Python: libNeuroML API

from neuroml import GateKS

variable = GateKS(neuro_lex_id=None, id=None, instances=None, notes=None, q10_settings=None, closed_states=None, open_states=None, forward_transition=None, reverse_transition=None, tau_inf_transition=None, **kwargs_)