ca.nengo.model.neuron.impl
Class ALIFSpikeGenerator

java.lang.Object
  extended by ca.nengo.model.neuron.impl.ALIFSpikeGenerator
All Implemented Interfaces:
SpikeGenerator, Probeable, Resettable, SimulationMode.ModeConfigurable, java.io.Serializable, java.lang.Cloneable

public class ALIFSpikeGenerator
extends java.lang.Object
implements SpikeGenerator, Probeable

An adapting leaky-integrate-and-fire model of spike generation. The mechanism of adaptation is a current I_ahp that is related to firing frequency. This current is proportional to the concentration of an ion species N, as I_ahp = -g_N * [N]. [N] increases with every spike and decays between spikes, as follows: d[N]/dt = -[N]/tau_N + inc_N sum_k(delta(t-t_k).

This form is taken from La Camera et al. (2004) Minimal models of adapted neuronal response to in vivo-like input currents, Neural Computation 16, 2101-24. This form of adaptation (as opposed to variation in firing threshold or membrane time constant) is convenient because it allows a rate model as well as a spiking model.

Some example parameter values are the same as a standard LIF, plus TauN = .2; incN = .05 - .2. for greater amounts of differing adaptation, increase the range of incN

TODO: unit tests (particularly verify numbers of spikes and rate match in various cases -- they seem to)

Author:
Bryan Tripp
See Also:
Serialized Form

Nested Class Summary
static class ALIFSpikeGenerator.Factory
          Creates ALIFSpikeGenerators.
 
Constructor Summary
ALIFSpikeGenerator()
          Uses default parameters
ALIFSpikeGenerator(float tauRef, float tauRC, float tauN, float incN)
           
 
Method Summary
 SpikeGenerator clone()
           
 float getAdaptedRate(float I)
           
 TimeSeries getHistory(java.lang.String stateName)
          Note that the units of TimeSeries' for a given state do not change over time (ie at different time steps).
 float getIncN()
           
 SimulationMode getMode()
           
 float getOnsetRate(float I)
           
 float getTauN()
           
 float getTauRC()
           
 float getTauRef()
           
 float getVoltage()
           
 java.util.Properties listStates()
           
static void main(java.lang.String[] args)
           
 void reset(boolean randomize)
           
 InstantaneousOutput run(float[] time, float[] current)
          Runs the model for a given time segment.
 void setIncN(float incN)
           
 void setMode(SimulationMode mode)
          DEFAULT and RATE are supported.
 void setTauN(float tauN)
           
 void setTauRC(float tauRC)
           
 void setTauRef(float tauRef)
           
 
Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

ALIFSpikeGenerator

public ALIFSpikeGenerator()
Uses default parameters


ALIFSpikeGenerator

public ALIFSpikeGenerator(float tauRef,
                          float tauRC,
                          float tauN,
                          float incN)
Parameters:
tauRef - Refracory period (s)
tauRC - Resistive-capacitive time constant (s)
tauN - Time constant of adaptation-related ion
incN - Increment of adaptation-related ion with each spike
Method Detail

getTauRef

public float getTauRef()
Returns:
Refracory period (s)

setTauRef

public void setTauRef(float tauRef)
Parameters:
tauRef - Refracory period (s)

getTauRC

public float getTauRC()
Returns:
Resistive-capacitive time constant (s)

setTauRC

public void setTauRC(float tauRC)
Parameters:
tauRC - Resistive-capacitive time constant (s)

getTauN

public float getTauN()
Returns:
Time constant of adaptation-related ion

setTauN

public void setTauN(float tauN)
Parameters:
tauN - Time constant of adaptation-related ion

getIncN

public float getIncN()
Returns:
Increment of adaptation-related ion with each spike

setIncN

public void setIncN(float incN)
Parameters:
incN - Increment of adaptation-related ion with each spike

run

public InstantaneousOutput run(float[] time,
                               float[] current)
Description copied from interface: SpikeGenerator
Runs the model for a given time segment. The total time is meant to be short (eg 1/2ms), in that the output of the model is either a spike or no spike during this period of simulation time.

The model is responsible for maintaining its internal state, and the state is assumed to be consistent with the start time. That is, if a caller calls run({.001 .002}, ...) and then run({.501 .502}, ...), the results may not make any sense, but this is not the model's responsibility. Absolute times are provided to support explicitly time-varying models, and for the convenience of Probeable models.

Specified by:
run in interface SpikeGenerator
Parameters:
time - Array of points in time at which input current is defined. This includes at least the start and end times, and possibly intermediate times. (The SpikeGenerator model can use its own time step -- these times are only used to define the input.)
current - Driving current at each given point in time (assumed to be constant until next time point)
Returns:
true If there is a spike between the first and last times, false otherwise
See Also:
SpikeGenerator.run(float[], float[])

getOnsetRate

public float getOnsetRate(float I)
Parameters:
I - driving current
Returns:
Unadapted firing rate given this current

getAdaptedRate

public float getAdaptedRate(float I)
Parameters:
I - driving current
Returns:
Adapted firing rate given this current

reset

public void reset(boolean randomize)
Specified by:
reset in interface Resettable
Parameters:
randomize - True indicates that the object should be reset to a randomly selected initial state (the object must be aware of the distribution from which to draw from). False indicates that the object should be reset to a fixed initial state (which it must also know). Some objects may not support randomization of the initial state, in which case a fixed state will be used in either case.
See Also:
Resettable.reset(boolean)

getMode

public SimulationMode getMode()
Specified by:
getMode in interface SimulationMode.ModeConfigurable
Returns:
The SimulationMode in which the object is running
See Also:
SimulationMode.ModeConfigurable.getMode()

setMode

public void setMode(SimulationMode mode)
DEFAULT and RATE are supported.

Specified by:
setMode in interface SimulationMode.ModeConfigurable
Parameters:
mode - SimulationMode in which it is desired that the object runs.
See Also:
SimulationMode.ModeConfigurable.setMode(ca.nengo.model.SimulationMode)

getHistory

public TimeSeries getHistory(java.lang.String stateName)
                      throws SimulationException
Description copied from interface: Probeable
Note that the units of TimeSeries' for a given state do not change over time (ie at different time steps). CAUTION: The TimeSeries should not contain a reference to any arrays that you are going to change later. The caller owns what you return.

Specified by:
getHistory in interface Probeable
Parameters:
stateName - A state variable name
Returns:
History of values for the named state variable. The history must cover the most recent network time step, and no more. There should be no overlap in the time points returned for different steps.
Throws:
SimulationException - if the Probeable does not have the requested state
See Also:
Probeable.getHistory(java.lang.String)

getVoltage

public float getVoltage()

listStates

public java.util.Properties listStates()
Specified by:
listStates in interface Probeable
Returns:
List of state variable names, eg "V", and associated descriptions eg "membrane potential (mV)"
See Also:
Probeable.listStates()

clone

public SpikeGenerator clone()
                     throws java.lang.CloneNotSupportedException
Specified by:
clone in interface SpikeGenerator
Overrides:
clone in class java.lang.Object
Throws:
java.lang.CloneNotSupportedException

main

public static void main(java.lang.String[] args)