# 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.

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 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.

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 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.

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.

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.

Sends: SpikeEvent

FirstVersion: July 2006, Oct 2009, May 2013

Author: Hans Ekkehard Plesser

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