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..
r 
(from baseVoltageDepRate) 
caConc 

v 
(from baseVoltageDepRate) 
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.
r 
(from baseVoltageDepRate) 
v 
(from baseVoltageDepRate) 
HHExpRate¶
extends baseHHRate
Exponential form for rate equation ( Q: Should these be renamed hhExpRate, etc? ).
midpoint 
(from baseHHRate) 

rate 
(from baseHHRate) 

scale 
(from baseHHRate) 
r 
(from baseVoltageDepRate) 
v 
(from baseVoltageDepRate) 
 Derived Variables
r = rate * exp((v  midpoint)/scale) (exposed as r)
HHSigmoidRate¶
extends baseHHRate
Sigmoidal form for rate equation.
midpoint 
(from baseHHRate) 

rate 
(from baseHHRate) 

scale 
(from baseHHRate) 
r 
(from baseVoltageDepRate) 
v 
(from baseVoltageDepRate) 
 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) 

rate 
(from baseHHRate) 

scale 
(from baseHHRate) 
r 
(from baseVoltageDepRate) 
v 
(from baseVoltageDepRate) 
 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 
v 
baseVoltageConcDepVariable¶
extends baseVoltageDepVariable
Base ComponentType for voltage and calcium concentration dependent variable x, which depends on v and caConc..
x 
(from baseVoltageDepVariable) 
Dimensionless 
caConc 

v 
(from baseVoltageDepVariable) 
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.
x 
(from baseVoltageDepVariable) 
Dimensionless 
v 
(from baseVoltageDepVariable) 
HHExpVariable¶
extends baseHHVariable
Exponential form for variable equation.
midpoint 
(from baseHHVariable) 

rate 
(from baseHHVariable) 
Dimensionless 
scale 
(from baseHHVariable) 
x 
(from baseVoltageDepVariable) 
Dimensionless 
v 
(from baseVoltageDepVariable) 
 Derived Variables
x = rate * exp((v  midpoint)/scale) (exposed as x)
HHSigmoidVariable¶
extends baseHHVariable
Sigmoidal form for variable equation.
midpoint 
(from baseHHVariable) 

rate 
(from baseHHVariable) 
Dimensionless 
scale 
(from baseHHVariable) 
x 
(from baseVoltageDepVariable) 
Dimensionless 
v 
(from baseVoltageDepVariable) 
 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) 

rate 
(from baseHHVariable) 
Dimensionless 
scale 
(from baseHHVariable) 
x 
(from baseVoltageDepVariable) 
Dimensionless 
v 
(from baseVoltageDepVariable) 
 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.
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 ).
t 
(from baseVoltageDepTime) 
caConc 

v 
(from baseVoltageDepTime) 
fixedTimeCourse¶
extends baseVoltageDepTime
Time course of a fixed magnitude tau which can be used for the time course in gateHHtauInf, gateHHratesTau or gateHHratesTauInf.
baseQ10Settings¶
Base ComponentType for a scaling to apply to gating variable time course, usually temperature dependent.
q10 
Dimensionless 
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) 
 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 

q10Factor 
Dimensionless 
TENDEGREES = 10K 
q10 
(from baseQ10Settings) 
Dimensionless 
temperature 
(from baseQ10Settings) 
 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 
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 

q10Factor 
Dimensionless 
TENDEGREES = 10K 
factor 
(from baseConductanceScaling) 
Dimensionless 
temperature 
(from baseConductanceScaling) 
 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, nonbase form here ).
factor 
(from baseConductanceScaling) 
Dimensionless 
caConc 

temperature 
(from baseConductanceScaling) 
baseGate¶
Base ComponentType for a voltage and/or concentration dependent gate.
gateHHrates¶
extends gate
Gate which follows the general Hodgkin Huxley formalism.
instances 
(from baseGate) 
Dimensionless 
forwardRate 

reverseRate 
q10Settings 
alpha 

beta 

fcond 
(from baseGate) 
Dimensionless 
inf 
Dimensionless 

q 
(from baseGate) 
Dimensionless 
rateScale 
Dimensionless 

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

steadyState 
q10Settings 
fcond 
(from baseGate) 
Dimensionless 
inf 
Dimensionless 

q 
(from baseGate) 
Dimensionless 
rateScale 
Dimensionless 

tau 
 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 
steadyState 
SEC = 1 s 
 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 

reverseRate 

timeCourse 
q10Settings 
alpha 

beta 

fcond 
(from baseGate) 
Dimensionless 
inf 
Dimensionless 

q 
(from baseGate) 
Dimensionless 
rateScale 
Dimensionless 

tau 
 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 

reverseRate 

steadyState 
q10Settings 
alpha 

beta 

fcond 
(from baseGate) 
Dimensionless 
inf 
Dimensionless 

q 
(from baseGate) 
Dimensionless 
rateScale 
Dimensionless 

tau 
 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 

reverseRate 

timeCourse 

steadyState 
q10Settings 
alpha 

beta 

fcond 
(from baseGate) 
Dimensionless 
inf 
Dimensionless 

q 
(from baseGate) 
Dimensionless 
rateScale 
Dimensionless 

tau 
 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 

subGate 
 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 

timeCourse 

steadyState 
inf 
Dimensionless 

q 
Dimensionless 

qfrac 
Dimensionless 

tau 
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 
neuroLexId 
notes 

annotation 
fopen 
Dimensionless 

g 
v 
ionChannelPassive¶
extends ionChannel
Simple passive ion channel where the constant conductance through the channel is equal to conductance.
conductance 
(from baseIonChannel) 
species 
fopen 
(from baseIonChannel) 
Dimensionless 
g 
(from baseIonChannel) 
v 
(from baseIonChannel) 
 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) 
species 
conductanceScaling 

gates 
fopen 
(from baseIonChannel) 
Dimensionless 
g 
(from baseIonChannel) 
v 
(from baseIonChannel) 
 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) 
fopen 
(from baseIonChannel) 
Dimensionless 
g 
(from baseIonChannel) 
v 
(from baseIonChannel) 
 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) 

vShift 
species 
fopen 
(from baseIonChannel) 
Dimensionless 
g 
(from baseIonChannel) 
v 
(from baseIonChannel) 
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 
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 
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) 
species 
conductanceScaling 

gates 
fopen 
(from baseIonChannel) 
Dimensionless 
g 
(from baseIonChannel) 
v 
(from baseIonChannel) 
 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 
SEC = 1s 
rf 
(from KSTransition) 

rr 
(from KSTransition) 
 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 
SEC = 1s 
rf 
(from KSTransition) 

rr 
(from KSTransition) 
 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.
kte = 25.3mV 
rf 
(from KSTransition) 

rr 
(from KSTransition) 
v 
 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.
timeCourse 

steadyState 
rf 
(from KSTransition) 

rr 
(from KSTransition) 
 Derived Variables
tau = timeCourse>t
inf = steadyState>x
rf = inf/tau (exposed as rf)
rr = (1inf)/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 

transitions 

q10Settings 
 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_)