Generator type devices¶

class
ac_generator
: public DeviceNode  #include <ac_generator.h>
Name: ac_generator  provides AC input current
Description:
This device produces an accurrent 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 (0360 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, 381402. 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 DCGenerator 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/s1082701103628
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
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 nfold 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 threadspecific RNGs set in the kernel.
Sends: SpikeEvent
References:
 1
Kuhn A, Aertsen A, Rotter S (2003). Higherorder statistics of input ensembles and the response of simple model neurons. Neural Computation 15:67101. 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 cutoff. 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 + (j1) 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 + (j1) 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 (0360 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 integrateandfire 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( (1x) / (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 nfold 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:
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 sinemodulated. 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/s1082701103628
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 pulsecenter time.
Both standard deviation and number of spikes may be set at any time. Pulses are then regenerated with the new values.
Sends: SpikeEvent
SeeAlso: spike_generator, StimulatingDevice

class
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 [0360], 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 nonPoisson stimulusresponse models of neural spiking activity. Journal of Neuroscience Methods, 105:253. DOI: https://doi.org/10.1016/S01650270(00)003447
FirstVersion: October 2007, May 2013
Author: Hans E Plesser, Thomas Heiberg
SeeAlso: sinusoidal_poisson_generator, gamma_sup_generator AC Gamma Generator. Generates ACmodulated inhomogeneous gamma process.
 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)^{a1} 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 [0360], 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 spiketimes.
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 PyNNNEST 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 gridbased 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 devicetimer 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 (midstep 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 devicetimer 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
Spiketimes
spike_weights
synaptic weights
Corresponding spikeweights, 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