Inputs

A number of ComponentTypes for providing spiking ( e.g. spikeGeneratorPoisson, spikeArray ) and current inputs ( e.g. pulseGenerator, voltageClamp, timedSynapticInput, poissonFiringSynapse ) to other ComponentTypes


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


basePointCurrent

extends baseStandalone

Base type for all ComponentTypes which produce a current i ( with dimension current ).

i

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

current

baseVoltageDepPointCurrent

extends basePointCurrent

Base type for all ComponentTypes which produce a current i ( with dimension current ) and require a voltage v exposed on the parent Component, which would often be the membrane potential of a Component extending baseCellMembPot.

i

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

current

v

The current may vary with the voltage exposed by the ComponentType on which this is placed

voltage

baseVoltageDepPointCurrentSpiking

extends baseVoltageDepPointCurrent

Base type for all ComponentTypes which produce a current i, require a membrane potential v exposed on the parent and emit spikes ( on a port spike ). The exposed variable tsince can be used for plotting the time since the Component has spiked last.

i

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

current

tsince

Time since the last spike was emitted

time

v

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

voltage

spike

Port on which spikes are emitted

Direction: out

basePointCurrentDL

Base type for all ComponentTypes which produce a dimensionless current I. There are many dimensionless equivalents of all the core current producing ComponentTypes such as pulseGenerator / pulseGeneratorDL, sineGenerator / sineGeneratorDL and rampGenerator / rampGeneratorDL.

I

The total (time varying) current produced by this ComponentType

Dimensionless

baseVoltageDepPointCurrentDL

extends basePointCurrentDL

Base type for all ComponentTypes which produce a dimensionless current I and require a dimensionless membrane potential V exposed on the parent Component.

I

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

Dimensionless

V

The current may vary with the dimensionless voltage exposed by the ComponentType on which this is placed

Dimensionless

baseSpikeSource

Base for any ComponentType whose main purpose is to emit spikes ( on a port spike ). The exposed variable tsince can be used for plotting the time since the Component has spiked last.

tsince

Time since the last spike was emitted

time

spike

Port on which spikes are emitted

Direction: out

spikeGenerator

extends baseSpikeSource

Simple generator of spikes at a regular interval set by period.

period

Time between spikes. The first spike will be emitted after this time.

time

SMALL_TIME = 1e-9ms

time

tnext

When the next spike should ideally be emitted (dt permitting)

time

tsince

Time since the last spike was emitted (from baseSpikeSource)

time

spike

Port on which spikes are emitted (from baseSpikeSource)

Direction: out

State Variables

tsince: time  (exposed as tsince)

tnext: time  (exposed as tnext)

On Start

tsince = 0

tnext = period

On Conditions

IF tnext - t < SMALL_TIME THEN

   tsince = 0

   tnext = tnext+period

   EVENT OUT on port: spike

Time Derivatives

d tsince /dt = 1

d tnext /dt = 0

Go to the libNeuroML documentation

from neuroml import SpikeGenerator

variable = SpikeGenerator(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, period=None, **kwargs_)
<spikeGenerator id="spikeGenRegular" period="20 ms"/>

spikeGeneratorRandom

extends baseSpikeSource

Generator of spikes with a random interspike interval of at least minISI and at most maxISI.

maxISI

Maximum interspike interval

time

minISI

Minimum interspike interval

time

MSEC = 1ms

time

isi

The interval until the next spike

time

tnext

When the next spike should ideally be emitted (dt permitting)

time

tsince

Time since the last spike was emitted (from baseSpikeSource)

time

spike

Port on which spikes are emitted (from baseSpikeSource)

Direction: out

State Variables

tsince: time  (exposed as tsince)

tnext: time  (exposed as tnext)

isi: time  (exposed as isi)

On Start

tsince = 0

isi = minISI + MSEC * random((maxISI - minISI) / MSEC)

tnext = isi

On Conditions

IF t > tnext THEN

   isi = minISI + MSEC * random((maxISI - minISI) / MSEC)

   tsince = 0

   tnext = tnext+isi

   EVENT OUT on port: spike

Time Derivatives

d tsince /dt = 1

d tnext /dt = 0

Go to the libNeuroML documentation

from neuroml import SpikeGeneratorRandom

variable = SpikeGeneratorRandom(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, max_isi=None, min_isi=None, **kwargs_)
<spikeGeneratorRandom id="spikeGenRandom" minISI="10 ms" maxISI="30 ms"/>

spikeGeneratorPoisson

extends baseSpikeSource

Generator of spikes whose ISI is distributed according to an exponential PDF with scale: 1 / averageRate.

averageRate

The average rate at which spikes are emitted

per_time

SMALL_TIME = 1e-9ms

time

isi

The interval until the next spike

time

tnextIdeal

This is the ideal/perfect next spike time, based on a newly generated isi, but dt precision will mean that it’s usually slightly later than this

time

tnextUsed

This is the next spike time for practical purposes, ensuring that it’s later than the current time

time

tsince

Time since the last spike was emitted (from baseSpikeSource)

time

spike

Port on which spikes are emitted (from baseSpikeSource)

Direction: out

State Variables

tsince: time  (exposed as tsince)

tnextIdeal: time  (exposed as tnextIdeal)

tnextUsed: time  (exposed as tnextUsed)

isi: time  (exposed as isi)

On Start

tsince = 0

isi = -1 * log(random(1)) / averageRate

tnextIdeal = isi

tnextUsed = isi

On Conditions

IF t > tnextUsed THEN

   tsince = 0

   isi = -1 * log(random(1)) / averageRate

   tnextIdeal = (tnextIdeal+isi)

   tnextUsed = tnextIdeal*H( (tnextIdeal-t)/t ) + (t+SMALL_TIME)*H( (t-tnextIdeal)/t )

   EVENT OUT on port: spike

Time Derivatives

d tsince /dt = 1

d tnextUsed /dt = 0

d tnextIdeal /dt = 0

Go to the libNeuroML documentation

from neuroml import SpikeGeneratorPoisson

variable = SpikeGeneratorPoisson(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, average_rate=None, extensiontype_=None, **kwargs_)
<spikeGeneratorPoisson id="spikeGenPoisson" averageRate="50 Hz"/>

spikeGeneratorRefPoisson

extends spikeGeneratorPoisson

Generator of spikes whose ISI distribution is the maximum entropy distribution over [ minimumISI, +infinity ) with mean: 1 / averageRate.

averageRate

The average rate at which spikes are emitted (from spikeGeneratorPoisson)

per_time

minimumISI

The minimum interspike interval

time

averageIsi

The average interspike interval

time

isi

The interval until the next spike (from spikeGeneratorPoisson)

time

tnextIdeal

This is the ideal/perfect next spike time, based on a newly generated isi, but dt precision will mean that it’s usually slightly later than this (from spikeGeneratorPoisson)

time

tnextUsed

This is the next spike time for practical purposes, ensuring that it’s later than the current time (from spikeGeneratorPoisson)

time

tsince

Time since the last spike was emitted (from baseSpikeSource)

time

spike

Port on which spikes are emitted (from baseSpikeSource)

Direction: out

State Variables

tsince: time  (exposed as tsince)

tnextIdeal: time  (exposed as tnextIdeal)

tnextUsed: time  (exposed as tnextUsed)

isi: time  (exposed as isi)

On Start

tsince = 0

isi = minimumISI - (averageIsi-minimumISI) * log(random(1))

tnextIdeal = isi

tnextUsed = isi

On Conditions

IF t > tnextUsed THEN

   tsince = 0

   isi = minimumISI - (averageIsi-minimumISI) * log(random(1))

   tnextIdeal = (tnextIdeal+isi)

   tnextUsed = tnextIdeal*H( (tnextIdeal-t)/t ) + (t+SMALL_TIME)*H( (t-tnextIdeal)/t )

   EVENT OUT on port: spike

Time Derivatives

d tsince /dt = 1

d tnextUsed /dt = 0

d tnextIdeal /dt = 0

Go to the libNeuroML documentation

from neuroml import SpikeGeneratorRefPoisson

variable = SpikeGeneratorRefPoisson(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, average_rate=None, minimum_isi=None, **kwargs_)
<spikeGeneratorRefPoisson id="spikeGenRefPoisson" averageRate="50 Hz" minimumISI="10 ms"/>

poissonFiringSynapse

extends baseVoltageDepPointCurrentSpiking

Poisson spike generator firing at averageRate, which is connected to single synapse that is triggered every time a spike is generated, producing an input current. See also transientPoissonFiringSynapse.

averageRate

The average rate at which spikes are emitted

per_time

averageIsi

The average interspike interval

time

spikeTarget

The target of the spikes, i.e. the synapse

synapse

baseSynapse

SMALL_TIME = 1e-9ms

time

weight (default: 1)

Dimensionless

i

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

current

isi

The interval until the next spike

time

tnextIdeal

time

tnextUsed

time

tsince

Time since the last spike was emitted (from baseVoltageDepPointCurrentSpiking)

time

v

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

voltage

in

Note this is not used here. Will be removed in future

Direction: in

spike

Port on which spikes are emitted

Direction: out

spike

Port on which spikes are emitted (from baseVoltageDepPointCurrentSpiking)

Direction: out

Structure

WITH this AS a

WITH spikeTarget AS b

CHILD INSTANCE: synapse

EVENT CONNECTION from a TO b

State Variables

tsince: time  (exposed as tsince)

tnextIdeal: time  (exposed as tnextIdeal)

tnextUsed: time  (exposed as tnextUsed)

isi: time  (exposed as isi)

On Start

tsince = 0

isi = - averageIsi * log(random(1))

tnextIdeal = isi

tnextUsed = isi

On Conditions

IF t > tnextUsed THEN

   tsince = 0

   isi = - averageIsi * log(1 - random(1))

   tnextIdeal = (tnextIdeal+isi)

   tnextUsed = tnextIdeal*H( (tnextIdeal-t)/t ) + (t+SMALL_TIME)*H( (t-tnextIdeal)/t )

   EVENT OUT on port: spike

Derived Variables

iSyn = synapse->i

i = weight * iSyn (exposed as i)

Time Derivatives

d tsince /dt = 1

d tnextUsed /dt = 0

d tnextIdeal /dt = 0

Go to the libNeuroML documentation

from neuroml import PoissonFiringSynapse

variable = PoissonFiringSynapse(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, average_rate=None, synapse=None, spike_target=None, **kwargs_)
<poissonFiringSynapse id="poissonFiringSyn" averageRate="10 Hz" synapse="synInput" spikeTarget="./synInput"/>

transientPoissonFiringSynapse

extends baseVoltageDepPointCurrentSpiking

Poisson spike generator firing at averageRate after a delay and for a duration, connected to single synapse that is triggered every time a spike is generated, providing an input current. Similar to ComponentType poissonFiringSynapse.

averageRate

per_time

delay

time

duration

time

averageIsi

time

spikeTarget

synapse

baseSynapse

SMALL_TIME = 1e-9ms

time

LONG_TIME = 1e9hour

time

weight (default: 1)

Dimensionless

i

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

current

isi

time

tnextIdeal

time

tnextUsed

time

tsince

Time since the last spike was emitted (from baseVoltageDepPointCurrentSpiking)

time

v

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

voltage

in

Note this is not used here. Will be removed in future

Direction: in

spike

Port on which spikes are emitted

Direction: out

spike

Port on which spikes are emitted (from baseVoltageDepPointCurrentSpiking)

Direction: out

Structure

WITH this AS a

WITH spikeTarget AS b

CHILD INSTANCE: synapse

EVENT CONNECTION from a TO b

State Variables

tsince: time  (exposed as tsince)

tnextIdeal: time  (exposed as tnextIdeal)

tnextUsed: time  (exposed as tnextUsed)

isi: time  (exposed as isi)

On Start

tsince = 0

isi = - averageIsi * log(1 - random(1)) +delay

tnextIdeal = isi

tnextUsed = isi

On Conditions

IF t > tnextUsed THEN

   tsince = 0

   isi = - averageIsi * log(1 - random(1))

   tnextIdeal = (tnextIdeal+isi) + H(((t+isi) - (delay+duration))/duration)*LONG_TIME

   tnextUsed = tnextIdeal*H( (tnextIdeal-t)/t ) + (t+SMALL_TIME)*H( (t-tnextIdeal)/t )

   EVENT OUT on port: spike

Derived Variables

iSyn = synapse->i

i = weight * iSyn (exposed as i)

Time Derivatives

d tsince /dt = 1

d tnextUsed /dt = 0

d tnextIdeal /dt = 0

Go to the libNeuroML documentation

from neuroml import TransientPoissonFiringSynapse

variable = TransientPoissonFiringSynapse(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, average_rate=None, delay=None, duration=None, synapse=None, spike_target=None, **kwargs_)
<transientPoissonFiringSynapse id="transPoissonFiringSyn" delay="50ms" duration="50ms" averageRate="300 Hz" synapse="synInputFast" spikeTarget="./synInputFast"/>
<transientPoissonFiringSynapse id="transPoissonFiringSyn2" delay="50ms" duration="500ms" averageRate="10 Hz" synapse="synInputFastTwo" spikeTarget="./synInputFastTwo"/>

timedSynapticInput

extends baseVoltageDepPointCurrentSpiking

Spike array connected to a single synapse, producing a current triggered by each spike in the array.

spikeTarget

synapse

baseSynapse

spikes

spike

weight (default: 1)

Dimensionless

i

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

current

tsince

Time since the last spike was emitted (from baseVoltageDepPointCurrentSpiking)

time

v

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

voltage

in

This will receive events from the children

Direction: in

spike

Port on which spikes are emitted (from baseVoltageDepPointCurrentSpiking)

Direction: out

Structure

WITH this AS a

WITH spikeTarget AS b

CHILD INSTANCE: synapse

EVENT CONNECTION from a TO b

State Variables

tsince: time  (exposed as tsince)

On Events

EVENT IN on port: in

   tsince = 0

   EVENT OUT on port: spike

Derived Variables

iSyn = synapse->i

i = weight * iSyn (exposed as i)

Time Derivatives

d tsince /dt = 1

Go to the libNeuroML documentation

from neuroml import TimedSynapticInput

variable = TimedSynapticInput(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, synapse=None, spike_target=None, spikes=None, **kwargs_)
<timedSynapticInput id="synTrain" synapse="synInputFastTwo" spikeTarget="./synInputFastTwo">
        <spike id="0" time="2 ms"/>
        <spike id="1" time="15 ms"/>
        <spike id="2" time="27 ms"/>
        <spike id="3" time="40 ms"/>
        <spike id="4" time="45 ms"/>
        <spike id="5" time="50 ms"/>
        <spike id="6" time="52 ms"/>
        <spike id="7" time="54 ms"/>
        <spike id="8" time="54.5 ms"/>
        <spike id="9" time="54.6 ms"/>
        <spike id="10" time="54.7 ms"/>
        <spike id="11" time="54.8 ms"/>
        <spike id="12" time="54.9 ms"/>
        <spike id="13" time="55 ms"/>
        <spike id="14" time="55.1 ms"/>
        <spike id="15" time="55.2 ms"/>
    </timedSynapticInput>

spikeArray

extends baseSpikeSource

Set of spike ComponentTypes, each emitting one spike at a certain time. Can be used to feed a predetermined spike train into a cell.

spikes

spike

tsince

Time since the last spike was emitted (from baseSpikeSource)

time

in

This will receive events from the children

Direction: in

spike

Port on which spikes are emitted (from baseSpikeSource)

Direction: out

State Variables

tsince: time  (exposed as tsince)

On Start

tsince = 0

On Events

EVENT IN on port: in

   tsince = 0

   EVENT OUT on port: spike

Time Derivatives

d tsince /dt = 1

Go to the libNeuroML documentation

from neuroml import SpikeArray

variable = SpikeArray(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, spikes=None, **kwargs_)
<spikeArray id="spkArr">
      <spike id="0" time="50 ms"/>
      <spike id="1" time="100 ms"/>
      <spike id="2" time="150 ms"/>
      <spike id="3" time="155 ms"/>
      <spike id="4" time="250 ms"/>
    </spikeArray>

spike

extends baseSpikeSource

Emits a single spike at the specified time.

time

Time at which to emit one spike event

time

spiked

0 signals not yet spiked, 1 signals has spiked

Dimensionless

tsince

Time since the last spike was emitted (from baseSpikeSource)

time

spike

Port on which spikes are emitted (from baseSpikeSource)

Direction: out

Structure

WITH this AS a

WITH parent AS b

EVENT CONNECTION from a TO b

State Variables

tsince: time  (exposed as tsince)

spiked: Dimensionless  (exposed as spiked)

On Start

tsince = 0

On Conditions

IF (t >= time) AND (spiked = 0) THEN

   spiked = 1

   tsince = 0

   EVENT OUT on port: spike

Time Derivatives

d tsince /dt = 1

Go to the libNeuroML documentation

from neuroml import Spike

variable = Spike(neuro_lex_id=None, id=None, time=None, **kwargs_)
<spike id="0" time="50 ms"/>
<spike id="1" time="100 ms"/>
<spike id="2" time="150 ms"/>

pulseGenerator

extends basePointCurrent

Generates a constant current pulse of a certain amplitude for a specified duration after a delay. Scaled by weight, if set.

amplitude

Amplitude of current pulse

current

delay

Delay before change in current. Current is zero prior to this.

time

duration

Duration for holding current at amplitude. Current is zero after delay + duration.

time

weight (default: 1)

Dimensionless

i

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

current

in

Note: this is not used here. Will be removed in future

Direction: in

State Variables

i: current  (exposed as i)

On Events

EVENT IN on port: in

On Conditions

IF t < delay THEN

   i = 0

IF t >= delay AND t < duration + delay THEN

   i = weight * amplitude

IF t >= duration + delay THEN

   i = 0

Go to the libNeuroML documentation

from neuroml import PulseGenerator

variable = PulseGenerator(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, delay=None, duration=None, amplitude=None, **kwargs_)
<pulseGenerator id="pulseGen1" delay="50ms" duration="200ms" amplitude="0.0032nA"/>
<pulseGenerator id="pulseGen2" delay="400ms" duration="200ms" amplitude="0.0020nA"/>
<pulseGenerator id="pulseGen3" delay="700ms" duration="200ms" amplitude="0.0010nA"/>

compoundInput

extends basePointCurrent

Generates a current which is the sum of all its child basePointCurrent element, e.g. can be a combination of pulseGenerator, sineGenerator elements producing a single i. Scaled by weight, if set.

currents

basePointCurrent

weight (default: 1)

Dimensionless

i

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

current

in

Note this is not used here. Will be removed in future

Direction: in

On Events

EVENT IN on port: in

Derived Variables

i_total = currents[*]->i(reduce method: add)

i = weight * i_total (exposed as i)

Go to the libNeuroML documentation

from neuroml import CompoundInput

variable = CompoundInput(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, pulse_generators=None, sine_generators=None, ramp_generators=None, **kwargs_)
<compoundInput id="ci0">
        <pulseGenerator id="pg1" delay="50ms" duration="200ms" amplitude=".8 nA"/>
        <pulseGenerator id="pg2" delay="100ms" duration="100ms" amplitude=".4 nA"/>
        <sineGenerator id="sg0" phase="0" delay="125ms" duration="50ms" amplitude=".4nA" period="25ms"/>
    </compoundInput>

compoundInputDL

extends basePointCurrentDL

Generates a current which is the sum of all its child basePointCurrentDL elements, e.g. can be a combination of pulseGeneratorDL, sineGeneratorDL elements producing a single i. Scaled by weight, if set.

weight (default: 1)

Dimensionless

I

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

Dimensionless

in

Note this is not used here. Will be removed in future

Direction: in

On Events

EVENT IN on port: in

Derived Variables

I_total = currents[*]->I(reduce method: add)

I = weight * I_total (exposed as I)

Go to the libNeuroML documentation

from neuroml import CompoundInputDL

variable = CompoundInputDL(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, pulse_generator_dls=None, sine_generator_dls=None, ramp_generator_dls=None, **kwargs_)

pulseGeneratorDL

extends basePointCurrentDL

Dimensionless equivalent of pulseGenerator. Generates a constant current pulse of a certain amplitude for a specified duration after a delay. Scaled by weight, if set.

amplitude

Amplitude of current pulse

Dimensionless

delay

Delay before change in current. Current is zero prior to this.

time

duration

Duration for holding current at amplitude. Current is zero after delay + duration.

time

weight (default: 1)

Dimensionless

I

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

Dimensionless

in

Note this is not used here. Will be removed in future

Direction: in

State Variables

I: Dimensionless  (exposed as I)

On Events

EVENT IN on port: in

On Conditions

IF t < delay THEN

   I = 0

IF t >= delay AND t < duration + delay THEN

   I = weight * amplitude

IF t >= duration + delay THEN

   I = 0

Go to the libNeuroML documentation

from neuroml import PulseGeneratorDL

variable = PulseGeneratorDL(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, delay=None, duration=None, amplitude=None, **kwargs_)

sineGenerator

extends basePointCurrent

Generates a sinusoidally varying current after a time delay, for a fixed duration. The period and maximum amplitude of the current can be set as well as the phase at which to start. Scaled by weight, if set.

amplitude

Maximum amplitude of current

current

delay

Delay before change in current. Current is zero prior to this.

time

duration

Duration for holding current at amplitude. Current is zero after delay + duration.

time

period

Time period of oscillation

time

phase

Phase (between 0 and 2*pi) at which to start the varying current (i.e. at time given by delay)

Dimensionless

weight (default: 1)

Dimensionless

i

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

current

in

Direction: in

State Variables

i: current  (exposed as i)

On Events

EVENT IN on port: in

On Conditions

IF t < delay THEN

   i = 0

IF t >= delay AND t < duration+delay THEN

   i = weight * amplitude * sin(phase + (2 * 3.14159265 * (t-delay)/period) )

IF t >= duration+delay THEN

   i = 0

Go to the libNeuroML documentation

from neuroml import SineGenerator

variable = SineGenerator(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, delay=None, phase=None, duration=None, amplitude=None, period=None, **kwargs_)
<sineGenerator id="sg0" phase="0" delay="50ms" duration="200ms" amplitude="1.4nA" period="50ms"/>
<sineGenerator id="sg0" phase="0" delay="125ms" duration="50ms" amplitude=".4nA" period="25ms"/>

sineGeneratorDL

extends basePointCurrentDL

Dimensionless equivalent of sineGenerator. Generates a sinusoidally varying current after a time delay, for a fixed duration. The period and maximum amplitude of the current can be set as well as the phase at which to start. Scaled by weight, if set.

amplitude

Maximum amplitude of current

Dimensionless

delay

Delay before change in current. Current is zero prior to this.

time

duration

Duration for holding current at amplitude. Current is zero after delay + duration.

time

period

Time period of oscillation

time

phase

Phase (between 0 and 2*pi) at which to start the varying current (i.e. at time given by delay)

Dimensionless

weight (default: 1)

Dimensionless

I

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

Dimensionless

in

Direction: in

State Variables

I: Dimensionless  (exposed as I)

On Events

EVENT IN on port: in

On Conditions

IF t < delay THEN

   I = 0

IF t >= delay AND t < duration+delay THEN

   I = weight * amplitude * sin(phase + (2 * 3.14159265 * (t-delay)/period) )

IF t >= duration+delay THEN

   I = 0

Go to the libNeuroML documentation

from neuroml import SineGeneratorDL

variable = SineGeneratorDL(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, delay=None, phase=None, duration=None, amplitude=None, period=None, **kwargs_)

rampGenerator

extends basePointCurrent

Generates a ramping current after a time delay, for a fixed duration. During this time the current steadily changes from startAmplitude to finishAmplitude. Scaled by weight, if set.

baselineAmplitude

Amplitude of current before time delay, and after time delay + duration

current

delay

Delay before change in current. Current is baselineAmplitude prior to this.

time

duration

Duration for holding current at amplitude. Current is baselineAmplitude after delay + duration.

time

finishAmplitude

Amplitude of linearly varying current at time delay + duration

current

startAmplitude

Amplitude of linearly varying current at time delay

current

weight (default: 1)

Dimensionless

i

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

current

in

Direction: in

State Variables

i: current  (exposed as i)

On Start

i = baselineAmplitude

On Events

EVENT IN on port: in

On Conditions

IF t < delay THEN

   i = weight * baselineAmplitude

IF t >= delay AND t < duration+delay THEN

   i = weight * (startAmplitude + (finishAmplitude - startAmplitude) * (t - delay) / (duration))

IF t >= duration+delay THEN

   i = weight * baselineAmplitude

Go to the libNeuroML documentation

from neuroml import RampGenerator

variable = RampGenerator(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, delay=None, duration=None, start_amplitude=None, finish_amplitude=None, baseline_amplitude=None, **kwargs_)
<rampGenerator id="rg0" delay="50ms" duration="200ms" startAmplitude="0.5nA" finishAmplitude="4nA" baselineAmplitude="0nA"/>

rampGeneratorDL

extends basePointCurrentDL

Dimensionless equivalent of rampGenerator. Generates a ramping current after a time delay, for a fixed duration. During this time the dimensionless current steadily changes from startAmplitude to finishAmplitude. Scaled by weight, if set.

baselineAmplitude

Amplitude of current before time delay, and after time delay + duration

Dimensionless

delay

Delay before change in current. Current is baselineAmplitude prior to this.

time

duration

Duration for holding current at amplitude. Current is baselineAmplitude after delay + duration.

time

finishAmplitude

Amplitude of linearly varying current at time delay + duration

Dimensionless

startAmplitude

Amplitude of linearly varying current at time delay

Dimensionless

weight (default: 1)

Dimensionless

I

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

Dimensionless

in

Direction: in

State Variables

I: Dimensionless  (exposed as I)

On Start

I = baselineAmplitude

On Events

EVENT IN on port: in

On Conditions

IF t < delay THEN

   I = weight * baselineAmplitude

IF t >= delay AND t < duration+delay THEN

   I = weight * (startAmplitude + (finishAmplitude - startAmplitude) * (t - delay) / (duration))

IF t >= duration+delay THEN

   I = weight * baselineAmplitude

Go to the libNeuroML documentation

from neuroml import RampGeneratorDL

variable = RampGeneratorDL(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, delay=None, duration=None, start_amplitude=None, finish_amplitude=None, baseline_amplitude=None, **kwargs_)

voltageClamp

extends baseVoltageDepPointCurrent

Voltage clamp. Applies a variable current i to try to keep parent at targetVoltage. Not yet fully tested!!! Consider using voltageClampTriple!!

delay

Delay before change in current. Current is zero prior to this.

time

duration

Duration for attempting to keep parent at targetVoltage. Current is zero after delay + duration.

time

simpleSeriesResistance

Current will be calculated by the difference in voltage between the target and parent, divided by this value

resistance

targetVoltage

Current will be applied to try to get parent to this target voltage

voltage

weight (default: 1)

Dimensionless

i

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

current

v

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

voltage

in

Note this is not used here. Will be removed in future

Direction: in

State Variables

i: current  (exposed as i)

On Events

EVENT IN on port: in

On Conditions

IF t < delay THEN

   i = 0

IF t >= delay THEN

   i = weight * (targetVoltage - v) / simpleSeriesResistance

IF t > duration + delay THEN

   i = 0

Go to the libNeuroML documentation

from neuroml import VoltageClamp

variable = VoltageClamp(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, delay=None, duration=None, target_voltage=None, simple_series_resistance=None, **kwargs_)

voltageClampTriple

extends baseVoltageDepPointCurrent

Voltage clamp with 3 clamp levels. Applies a variable current i ( through simpleSeriesResistance ) to try to keep parent cell at conditioningVoltage until time delay, testingVoltage until delay + duration, and returnVoltage afterwards. Only enabled if active = 1.

active

Whether the voltage clamp is active (1) or inactive (0).

Dimensionless

conditioningVoltage

Target voltage before time delay

voltage

delay

Delay before switching from conditioningVoltage to testingVoltage.

time

duration

Duration to hold at testingVoltage.

time

returnVoltage

Target voltage after time duration

voltage

simpleSeriesResistance

Current will be calculated by the difference in voltage between the target and parent, divided by this value

resistance

testingVoltage

Target voltage between times delay and delay + duration

voltage

weight (default: 1)

Dimensionless

i

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

current

v

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

voltage

in

Note this is not used here. Will be removed in future

Direction: in

State Variables

i: current  (exposed as i)

On Events

EVENT IN on port: in

On Conditions

IF active = 1 AND t < delay THEN

   i = weight * (conditioningVoltage - v) / simpleSeriesResistance

IF active = 1 AND t >= delay THEN

   i = weight * (testingVoltage - v) / simpleSeriesResistance

IF active = 1 AND t > duration + delay THEN

   i = weight * (returnVoltage - v) / simpleSeriesResistance

Go to the libNeuroML documentation

from neuroml import VoltageClampTriple

variable = VoltageClampTriple(neuro_lex_id=None, id=None, metaid=None, notes=None, properties=None, annotation=None, active=None, delay=None, duration=None, conditioning_voltage=None, testing_voltage=None, return_voltage=None, simple_series_resistance=None, **kwargs_)
<voltageClampTriple id="vClamp0" active="1" delay="50ms" duration="200ms" conditioningVoltage="-70mV" testingVoltage="-50mV" returnVoltage="-70mV" simpleSeriesResistance="1e6ohm"/>