Generator type devices¶

class ac_generator : public DeviceNode

#include <ac_generator.h>

Name: ac_generator - provides AC input current

Description:

This device produces an ac-current sent by a CurrentEvent. The current is given by

\[ I(t) = offset + amplitude * \sin ( om * t + \phi ) \]

where

\[\begin{split} om = 2 * \pi * frequency \\ \phi = phase / 180 * \pi \end{split}\]

Parameters:

amplitude	pA	Amplitude of sine current
offset	pA	Constant amplitude offset
frequency	Hz	Frequency
phase	degree	Phase of sine current (0-360 deg)

Setting start and stop (see StimulatingDevice) only windows the current as defined above. It does not shift the time axis.

References:

1: Rotter S and Diesmann M (1999). Exact digital simulation of time- invariant linear systems with applications to neuronal modeling, Biol. Cybern. 81, 381-402. DOI: https://doi.org/10.1007/s004220050570

Sends: CurrentEvent

Author: Johan Hake, Spring 2003

SeeAlso: Device, StimulatingDevice, dc_generator, step_current_generator

class dc_generator : public DeviceNode

#include <dc_generator.h>

Name: dc_generator - provides DC input current

Description: The DC-Generator provides a constant DC Input to the connected node. The unit of the current is pA.

Parameters:

The following parameters can be set in the status dictionary:

amplitude

pA

Amplitude of current

Examples:

SLI

The dc current can be altered in the following way:
/dc_generator Create /dc_gen Set  % Creates a dc_generator, which is a node
dc_gen GetStatus info             % View properties (amplitude is 0)
dc_gen << /amplitude 1500. >> SetStatus
dc_gen GetStatus info             % amplitude is now 1500.0

Remarks:

The dc_generator is rather inefficient, since it needs to send the same current information on each time step. If you only need a constant bias current into a neuron, you should set it directly in the neuron, e.g., dc_generator.

Sends: CurrentEvent

Author: docu by Sirko Straube

SeeAlso: Device, StimulatingDevice

class gamma_sup_generator : public DeviceNode

#include <gamma_sup_generator.h>

Name: gamma_sup_generator - simulate the superimposed spike train of a population of gamma process. Description:

The gamma_sup_generator generator simulates the pooled spike train of a population of neurons firing independently with gamma process statistics.

Parameters:

The following parameters appear in the element’s status dictionary:

rate	spikes/s	Mean firing rate of the component processes, default: 0 spikes/s
gamma_shape	integer	Shape paramter of component gamma processes, default: 1
n_proc	integer	Number of superimposed independent component processes, default: 1

References:

1: Deger, Helias, Boucsein, Rotter (2011). Statistical properties of superimposed stationary spike trains. Journal of Computational Neuroscience. DOI: https://doi.org/10.1007/s10827-011-0362-8

Author: Jan 2011, Moritz Deger

SeeAlso: ppd_sup_generator, poisson_generator_ps, spike_generator, Device, StimulatingDevice

class inhomogeneous_poisson_generator : public DeviceNode

#include <inhomogeneous_poisson_generator.h>

Name: inhomogeneous_poisson_generator - provides Poisson spike trains at a piecewise constant rate

Description: The inhomogeneous Poisson generator provides Poisson spike trains at a piecewise constant rate to the connected node(s). The rate of the process is changed at the specified times. The unit of the instantaneous rate is spikes/s. By default, each target of the generator will receive a different spike train.

Parameters: The following parameters can be set in the status dictionary:

rate_times	list of ms	Times at which rate changes
rate_values	list of spikes/s	Rate of Poisson spike train
allow_offgrid_times	boolean	If false, spike times will be rounded to the nearest step if they are less than tic/2 from the step, otherwise NEST reports an error. If true, spike times are rounded to the nearest step if within tic/2 from the step,otherwise they are rounded up to the end of the step. Default: false

Examples:

The rate can be altered in the following way:

/inhomogeneous_poisson_generator Create /sc Set
sc << /rate_times [0.2 0.5] /rate_values [2.0 4.0] >> SetStatus

The average firing rate of each realization of the Poisson process will be 0.0 in the time interval [0, 0.2), 2.0 in the interval [0.2, 0.5) and 4.0 from then on.

Receives: DataLoggingRequest

Sends: SpikeEvent

Authors: Renato Duarte, Barna Zajzon

SeeAlso: sinusoidal_poisson_generator, step_current_generator, Device, StimulatingDevice

class nest::mip_generator : public DeviceNode

#include <mip_generator.h>

class mip_generator

Class mip_generator generates spike trains as described in the MIP model.

Name: mip_generator - create spike trains as described by the MIP model.

Description:

The mip_generator generates correlated spike trains using an Multiple Interaction Process (MIP) as described in [1]. Underlying principle is a Poisson mother process with rate r, the spikes of which are copied into the child processes with a certain probability p. Every node the mip_generator is connected to receives a distinct child process as input, whose rate is p*r. The value of the pairwise correlation coefficient of two child processes created by a MIP process equals p.

Parameters:

The following parameters appear in the element’s status dictionary:

rate	spikes/s	Mean firing rate of the mother process
p_copy	real	Copy probability
mother_rng	rng	Random number generator of mother process
mother_seed	integer	Seed of RNG of mother process

Remarks:

The MIP generator may emit more than one spike through a child process during a single time step, especially at high rates. If this happens, the generator does not actually send out n spikes. Instead, it emits a single spike with n-fold synaptic weight for the sake of efficiency. Furthermore, note that as with the Poisson generator, different threads have their own copy of a MIP generator. By using the same mother_seed it is ensured that the mother process is identical for each of the generators.

IMPORTANT: The mother_seed of mpi_generator must be different from any seeds used for the global or thread-specific RNGs set in the kernel.

Todo:: Better handling of private random number generator, see #143. Most important: If RNG is changed in prototype by SetDefaults, then this is

Sends: SpikeEvent

References:

1: Kuhn A, Aertsen A, Rotter S (2003). Higher-order statistics of input ensembles and the response of simple model neurons. Neural Computation 15:67-101. DOI: https://doi.org/10.1162/089976603321043702

Author: May 2006, Helias

SeeAlso: Device

class noise_generator : public DeviceNode

#include <noise_generator.h>

Name: noise_generator - Device to generate Gaussian white noise current.

Description: This device can be used to inject a Gaussian “white” noise current into a node.

The current is not really white, but a piecewise constant current with Gaussian distributed amplitude. The current changes at intervals of dt. dt must be a multiple of the simulation step size, the default is 1.0ms, corresponding to a 1kHz cut-off. Additionally a second sinusodial modulated term can be added to the standard deviation of the noise.

The current generated is given by

\[ I(t) = mean + std * N_j \text{ for } t_0 + j dt <= t < t_0 + (j-1) dt \]

where \( N_j \) are Gaussian random numbers with unit standard deviation and \( t_0 \) is the device onset time. If the modulation is added the current is given by

\[\begin{split} I(t) = mean + \sqrt(std^2 + std_{mod}^2 * \sin(\omega * t + phase)) * N_j \\ \text{ for } t_0 + j dt <= t < t_0 + (j-1) dt \end{split}\]

For a detailed discussion of the properties of the noise generator, please see the noise_generator.ipynb notebook included in the NEST source code (docs/model_details).

Parameters: The following parameters can be set in the status dictionary:

mean	pA	Mean value of the noise current
std	pA	Standard deviation of noise current
dt	ms	Interval between changes in current, default 1.0ms
std_mod	pA	Modulated standard deviation of noise current
phase	real	Phase of sine modulation (0-360 deg)
frequency	Hz	Frequency of sine modulation

Remarks:

All targets receive different currents.
The currents for all targets change at the same points in time.
The interval between changes, dt, must be a multiple of the time step.
The effect of this noise current on a neuron DEPENDS ON DT. Consider the membrane potential fluctuations evoked when a noise current is injected into a neuron. The standard deviation of these fluctuations across an ensemble will increase with dt for a given value of std. For the leaky integrate-and-fire neuron with time constant \( \tau_m \) and capacity \( C_m \), membrane potential fluctuations Sigma at time s \( t_j+delay \) are given by
\[\begin{split} \Sigma = std * \tau_m / C_m * \sqrt( (1-x) / (1+x) ) \\ \text{where } x = exp(-dt/\tau_m) \end{split}\]
for large \( t_j \). In the white noise limit, dt -> 0, one has
\[ \Sigma -> std / C_m * \sqrt(dt * \tau / 2). \]
To obtain comparable results for different values of dt, you must adapt std.
As the noise generator provides a different current for each of its targets, the current recorded represents the instantaneous average of all the currents computed. When there exists only a single target, this would be equivalent to the actual current provided to that target.

Sends: CurrentEvent

SeeAlso: Device

Author: Ported to NEST2 API 08/2007 by Jochen Eppler, updated 07/2008 by HEP

class poisson_generator : public DeviceNode

#include <poisson_generator.h>

Name: poisson_generator - simulate neuron firing with Poisson processes statistics. Description:

The poisson_generator simulates a neuron that is firing with Poisson statistics, i.e. exponentially distributed interspike intervals. It will generate a unique spike train for each of it’s targets. If you do not want this behavior and need the same spike train for all targets, you have to use a parrot neuron inbetween the poisson generator and the targets.

Parameters:

The following parameters appear in the element’s status dictionary:

rate	spikes/s	Mean firing rate
origin	ms	Time origin for device timer
start	ms	Begin of device application with resp. to origin
stop	ms	End of device application with resp. to origin

Sends: SpikeEvent

Remarks:

A Poisson generator may, especially at high rates, emit more than one spike during a single time step. If this happens, the generator does not actually send out n spikes. Instead, it emits a single spike with n-fold synaptic weight for the sake of efficiency.

The design decision to implement the Poisson generator as a device which sends spikes to all connected nodes on every time step and then discards the spikes that should not have happened generating random numbers at the recipient side via an event hook is twofold.

On one hand, it leads to the saturation of the messaging network with an enormous amount of spikes, most of which will never get delivered and should not have been generated in the first place.

On the other hand, a proper implementation of the Poisson generator needs to provide two basic features: (a) generated spike trains should be IID processes w.r.t. target neurons to which the generator is connected and (b) as long as virtual_num_proc is constant, each neuron should receive an identical Poisson spike train in order to guarantee reproducibility of the simulations across varying machine numbers.

Therefore, first, as Network::get_network().send sends spikes to all the recipients, differentiation has to happen in the hook, second, the hook can use the RNG from the thread where the recipient neuron sits, which explains the current design of the generator. For details, refer to:

http://ken.brainworks.uni-freiburg.de/cgi-bin/mailman/private/nest_developer/2011-January/002977.html

SeeAlso: poisson_generator_ps, Device, parrot_neuron

class ppd_sup_generator : public DeviceNode

#include <ppd_sup_generator.h>

Name: ppd_sup_generator - simulate the superimposed spike train of a population of Poisson processes with dead time.

Description:

The ppd_sup_generator generator simulates the pooled spike train of a population of neurons firing independently with Poisson process with dead time statistics. The rate parameter can also be sine-modulated. The generator does not initialize to equilibrium in this case, initial transients might occur.

Parameters:

The following parameters appear in the element’s status dictionary:

rate	spikes/s	Mean firing rate of the component processes, default: 0 spikes/s
dead_time	ms	Minimal time between two spikes of the component processes, default: 0 ms
n_proc	integer	Number of superimposed independent component processes, default: 1
frequency	Hz	Rate modulation frequency, default: 0 Hz
relative_amplitude	real	Relative rate modulation amplitude, default: 0

Remarks:

References:

1: Deger M, Helias M, Boucsein C, Rotter S (2011). Statistical properties of superimposed stationary spike trains. Journal of Computational Neuroscience. DOI: https://doi.org/10.1007/s10827-011-0362-8

Authors: June 2009, Moritz Deger, Moritz Helias

SeeAlso: gamma_sup_generator, poisson_generator_ps, spike_generator, Device, StimulatingDevice

class pulsepacket_generator : public Node

#include <pulsepacket_generator.h>

Name: pulsepacket_generator - Generate sequence of Gaussian pulse packets.

Description:

The pulsepacket_generator produces a spike train contains Gaussian pulse packets centered about given times. A Gaussian pulse packet is a given number of spikes with normal distributed random displacements from the center time of the pulse. It resembles the output of synfire groups of neurons.

Parameters:

pulse_times	ms	Times of the centers of pulses
activity	integer	Number of spikes per pulse
sdev	ms	Standard deviation of spike times in each pulse

Remarks:

All targets receive identical spike trains.
New pulse packets are generated when activity or sdev are changed.
Gaussian pulse are independently generated for each given pulse-center time.
Both standard deviation and number of spikes may be set at any time. Pulses are then re-generated with the new values.

Sends: SpikeEvent

SeeAlso: spike_generator, StimulatingDevice

class nest::sinusoidal_gamma_generator : public DeviceNode

#include <sinusoidal_gamma_generator.h>

Name: sinusoidal_gamma_generator - Generates sinusoidally modulated gamma spike trains.

Description:

sinusoidal_gamma_generator generates sinusoidally modulated gamma spike trains. By default, each target of the generator will receive a different spike train.

The instantaneous rate of the process is given by

\[ f(t) = rate + amplitude \sin ( 2 \pi frequency t + phase * \pi/180 ) \]

Parameters:

The following parameters can be set in the status dictionary:

rate	spikes/s	Mean firing rate, default: 0 spikes/s
amplitude	spikes/s	Firing rate modulation amplitude, default: 0 s^-1
frequency	Hz	Modulation frequency, default: 0 Hz
phase	real	Modulation phase in degree [0-360], default: 0
order	real	Gamma order (>= 1), default: 1
individual_spike_trains	boolean	See note below, default: true

Remarks:

The gamma generator requires 0 <= amplitude <= rate.
The state of the generator is reset on calibration.
The generator does not support precise spike timing.
You can use the multimeter to sample the rate of the generator.
The generator will create different trains if run at different temporal resolutions.
Individual spike trains vs single spike train: By default, the generator sends a different spike train to each of its targets. If /individual_spike_trains is set to false using either SetDefaults or CopyModel before a generator node is created, the generator will send the same spike train to all of its targets.

Receives: DataLoggingRequest

Sends: SpikeEvent

References:

1: Barbieri et al. (2001). Construction and analysis of non-Poisson stimulus-response models of neural spiking activity. Journal of Neuroscience Methods, 105:25-3. DOI: https://doi.org/10.1016/S0165-0270(00)00344-7

FirstVersion: October 2007, May 2013

Author: Hans E Plesser, Thomas Heiberg

SeeAlso: sinusoidal_poisson_generator, gamma_sup_generator AC Gamma Generator. Generates AC-modulated inhomogeneous gamma process.

Todo:: The implementation is very quick and dirty and not tuned for performance at all.

Todo:: This implementation assumes that outgoing connections are all made from the same synapse type, see #737. Once #681 is fixed, we need to add a check that his assumption holds.

Note

The simulator works by calculating the hazard h(t) for each time step and comparing h(t) dt to a [0,1)-uniform number. The hazard is given by

\[ h(t) = \frac{a \lambda(t) \Lambda(t)^{a-1} e^{-\Lambda(t)}}{\Gamma(a, \Lambda(t))} \]

with

\[ \lambda(t) = dc + ac \sin ( 2 \pi f t + \phi ) \]

\[ \Lambda(t) = a \int_{t_0}^t \lambda(s) ds \]

and the incomplete Gamma function \( Gamma(a,z) \); \( a \) is the order of the gamma function and \(t_0\) the time of the most recent spike.

Note

This implementation includes an additional \( a \) factor in the calculation of \(\Lambda(t)\) and \(h(t)\) in order to keep the mean rate constant with varying \(a\)

Note

Let \(t_0\) be the time of the most recent spike. If stimulus parameters are changed at \(t_c > t_0\), then \(\Lambda(t)\) is integrated piecewise for \(t>t_c\) as

\[ \Lambda(t) = a_{old} \int_{t_0}^{t_c]} \lambda_{old}(s) ds + a_{new} \int_{t_c}^{t]} \lambda_{new}(s) ds \]

where “old” and “new” indicate old an new parameter values, respectively.

class sinusoidal_poisson_generator : public DeviceNode

#include <sinusoidal_poisson_generator.h>

Name: sinusoidal_poisson_generator - Generates sinusoidally modulated Poisson spike trains.

Description:

sinusoidal_poisson_generator generates sinusoidally modulated Poisson spike trains. By default, each target of the generator will receive a different spike train.

The instantaneous rate of the process is given by

\[ f(t) = max(0, rate + amplitude \sin ( 2 \pi frequency t + phase \pi/180 )) >= 0 \]

Parameters:

The following parameters can be set in the status dictionary:

rate	real	Mean firing rate in spikes/second, default: 0 s^-1
amplitude	real	Firing rate modulation amplitude in spikes/second, default: 0 s^-1
frequency	Hz	Modulation frequency, default: 0 Hz
phase	real	Modulation phase in degree [0-360], default: 0
individual_spike_trains	boolean	See note below, default: true

Remarks:

If amplitude > rate, firing rate is cut off at zero. In this case, the mean firing rate will be less than rate.
The state of the generator is reset on calibration.
The generator does not support precise spike timing.
You can use the multimeter to sample the rate of the generator.
The generator will create different trains if run at different temporal resolutions.
Individual spike trains vs single spike train: By default, the generator sends a different spike train to each of its targets. If /individual_spike_trains is set to false using either SetDefaults or CopyModel before a generator node is created, the generator will send the same spike train to all of its targets.

Receives: DataLoggingRequest

Sends: SpikeEvent

FirstVersion: July 2006, Oct 2009, May 2013

Author: Hans Ekkehard Plesser

SeeAlso: poisson_generator, sinusoidal_gamma_generator

class spike_dilutor : public DeviceNode

#include <spike_dilutor.h>

Name: spike_dilutor - repeats incoming spikes with a certain probability.

Description:

The device repeats incoming spikes with a certain probability. Targets will receive diffenrent spike trains.

Remarks:

In parallel simulations, a copy of the device is present on each process and spikes are collected only from local sources.

Parameters:

The following parameters appear in the element’s status dictionary:

p_copy

real

Copy probability

Sends: SpikeEvent

Author: Adapted from mip_generator by Kunkel, Oct 2011 ported to Nest 2.6 by: Setareh, April 2015

SeeAlso: mip_generator

class spike_generator : public DeviceNode

#include <spike_generator.h>

Name: spike_generator - A device which generates spikes from an array with spike-times.

Synopsis: spike_generator Create -> gid

Description:

A spike generator can be used to generate spikes at specific times which are given to the spike generator as an array.

Spike times are given in milliseconds, and must be sorted with the earliest spike first. All spike times must be strictly in the future. Trying to set a spike time in the past or at the current time step, will cause a NEST error. Setting a spike time of 0.0 will also result in an error.

Spike times may not coincide with a time step, i.e., are not a multiple of the simulation resolution. Three options control how spike times that do not coincide with a step are handled (see examples below):

Multiple occurrences of the same time indicate that more than one event is to be generated at this particular time.

Additionally, spike_weights can be set. This also is an array, which contains one weight value per spike time. If set, the spikes are delivered with the respective weight multiplied with the weight of the connection. To disable this functionality, the spike_weights array can be set to an empty array.

/precise_times   default: false

If false, spike times will be rounded to simulation steps, i.e., multiples of the resolution. The rounding is controlled by the two other flags. If true, spike times will not be rounded but represented exactly as a combination of step and offset. This should only be used if all neurons receiving the spike train can handle precise timing information. In this case, the other two options are ignored.

/allow_offgrid_times   default: false

If false, spike times will be rounded to the nearest step if they are less than tic/2 from the step, otherwise NEST reports an error. If true, spike times are rounded to the nearest step if within tic/2 from the step, otherwise they are rounded up to the end of the step.

/shift_now_spikes   default: false

This option is mainly for use by the PyNN-NEST interface. If false, spike times rounded down to the current point in time will be considered in the past and ignored. If true, spike times that are rounded down to the current time step are shifted one time step into the future.

Note that GetStatus will report the spike times that the spike_generator will actually use, i.e., for grid-based simulation the spike times rounded to the appropriate point on the time grid. This means that GetStatus may return different /spike_times values at different resolutions.

Example:

spike_generator << /spike_times [1.0 2.0 3.0] >> SetStatus

Instructs the spike generator to generate events at 1.0, 2.0, and
3.0 milliseconds, relative to the device-timer origin.

Example:

Assume that NEST works with default resolution (step size) of 0.1ms and default tic length of 0.001ms. Then, spikes times not falling onto the grid will be handled as follows for different option settings:

/spike_generator << /spike_times [1.0 1.9999 3.0001] >> Create
---> spikes at steps 10 (==1.0ms), 20 (==2.0ms) and 30 (==3.0ms)

/spike_generator << /spike_times [1.0 1.05 3.0001] >> Create
---> error, spike time 1.05 not within tic/2 of step

/spike_generator << /spike_times [1.0 1.05 3.0001]
                    /allow_offgrid_times true >> Create
---> spikes at steps 10, 11 (mid-step time rounded up),
     30 (time within tic/2 of step moved to step)

/spike_generator << /spike_times [1.0 1.05 3.0001]
                    /precise_times true >> Create
---> spikes at step 10, offset 0.0; step 11, offset -0.05;
     step 31, offset -0.0999

Assume we have simulated 10.0ms and simulation times is thus 10.0 (step 100).
Then, any spike times set, at this time, must be later than step 100.

/spike_generator << /spike_times [10.0001] >> Create
---> spike time is within tic/2 of step 100, rounded down to 100 thus
     not in the future, spike will not be emitted

/spike_generator << /spike_times [10.0001] /precise_times true >> Create
---> spike at step 101, offset -0.0999 is in the future

/spike_generator
  << /spike_times [10.0001 11.0001] /shift_now_spikes true >>
Create
---> spike at step 101, spike shifted into the future, and spike at step 110,
     not shifted, since it is in the future anyways

Example:

spike_generator
  << /spike_times [1.0 2.0] /spike_weights [5.0 -8.0] >>
SetStatus

Instructs the spike generator to generate an event with weight 5.0
at 1.0 ms, and an event with weight -8.0 at 2.0 ms, relative to
the device-timer origin.

spike_generator << /spike_weights [] >> SetStatus

Instructs the spike generator to generate events at 1.0, 2.0, and
3.0 milliseconds, and use the weight of the connection.

Parameters: The following properties can be set in the status dictionary.

origin	ms	Time origin for device timer
start	ms	Earliest possible time stamp of a spike to be emitted
stop	ms	Earliest time stamp of a potential spike event that is not emitted
spike_times	ms	Spike-times
spike_weights	synaptic weights	Corresponding spike-weights, the unit depends on the receiver
spike_multiplicities	integer	Multiplicities of spikes, same length as spike_times; mostly for debugging
precise_times	boolean	see above
allow_offgrid_times	boolean	see above
shift_now_spikes	boolean	see above

Sends: SpikeEvent

Author: Gewaltig, Diesmann, Eppler

SeeAlso: Device, StimulatingDevice, testsuite::test_spike_generator

class step_current_generator : public DeviceNode

#include <step_current_generator.h>

Name: step_current_generator - provides a piecewise constant DC input current

Description:

The dc_generator provides a piecewise constant DC input to the connected node(s). The amplitude of the current is changed at the specified times. The unit of the current is pA.

Parameters:

The following parameters can be set in the status dictionary:

amplitude_times	list of ms	Times at which current changes
amplitude_values	list of pA	Amplitudes of step current current
allow_offgrid_times	boolean	Default false

If false, times will be rounded to the nearest step if they are less than tic/2 from the step, otherwise NEST reports an error. If true, times are rounded to the nearest step if within tic/2 from the step, otherwise they are rounded up to the end of the step.

Note:

Times of amplitude changes must be strictly increasing after conversion to simulation time steps. The option allow_offgrid_times may be useful, e.g., if you are using randomized times for current changes which typically would not fall onto simulation time steps.

Examples:

The current can be altered in the following way:

/step_current_generator Create /sc Set
sc << /amplitude_times [0.2 0.5] /amplitude_values [2.0 4.0] >> SetStatus

The amplitude of the DC will be 0.0 pA in the time interval [0, 0.2),
2.0 pA in the interval [0.2, 0.5) and 4.0 from then on.

Sends: CurrentEvent

Author: Jochen Martin Eppler, Jens Kremkow

SeeAlso: ac_generator, dc_generator, step_current_generator, Device, StimulatingDevice

class step_rate_generator : public DeviceNode

#include <step_rate_generator.h>

Name: step_rate_generator - provides a piecewise constant input rate

Description:

The rate_generator provides a piecewise constant rate input to the connected rate unit(s). Please note that this input is handled in the same way as input from any other rate unit, i.e. it is processed by the input function of the receiving rate unit. The amplitude of the rate is changed at the specified times. The unit of the rate is Hz.

Parameters:

The following parameters can be set in the status dictionary:

amplitude_times	list of ms	Times at which current changes
amplitude_values	list of pA	Amplitudes of step current current
allow_offgrid_times	boolean	Default false

If false, times will be rounded to the nearest step if they are less than tic/2 from the step, otherwise NEST reports an error. If true, times are rounded to the nearest step if within tic/2 from the step, otherwise they are rounded up to the end of the step.

Note:

Times of amplitude changes must be strictly increasing after conversion to simulation time steps. The option allow_offgrid_times may be useful, e.g., if you are using randomized times for rate changes which typically would not fall onto simulation time steps.

Examples:

The rate can be altered in the following way:

/step_rate_generator Create /sc Set sc << /amplitude_times [0.2 0.5] /amplitude_values [2.0 4.0] >> SetStatus

The amplitude of the rate will be 0.0 Hz in the time interval [0, 0.2), 2.0 Hz in the interval [0.2, 0.5) and 4.0 Hz from then on.

Sends: DelayedRateConnectionEvent

Author: Sandra Nestler, David Dahmen

SeeAlso: step_current_generator, Device, StimulatingDevice