CARLsim  3.1.3
CARLsim: a GPU-accelerated SNN simulator
PoissonRate Class Reference

Class for generating Poisson spike trains. More...

#include <poisson_rate.h>

Public Member Functions

 PoissonRate (int nNeur, bool onGPU=false)
 PoissonRate constructor. More...
 
 ~PoissonRate ()
 PoissonRate destructor. More...
 
int getNumNeurons ()
 Returns the number of neurons for which to generate Poisson spike trains. More...
 
float getRate (int neurId)
 Returns the mean firing rate of a specific neuron ID. More...
 
float * getRatePtrCPU ()
 Returns pointer to CPU-allocated firing rate array (deprecated) More...
 
float * getRatePtrGPU ()
 Returns pointer to GPU-allocated firing rate array (deprecated) More...
 
std::vector< float > getRates ()
 Returns a vector of firing rates, one element per neuron. More...
 
bool isOnGPU ()
 Checks whether the firing rates are allocated on CPU or GPU. More...
 
void setRate (int neurId, float rate)
 Sets the mean firing rate of a particular neuron ID. More...
 
void setRates (float rate)
 Assigns the same mean firing rate to all neurons. More...
 
void setRates (const std::vector< float > &rates)
 Sets the mean firing rate of each neuron from a vector. More...
 

Detailed Description

The PoissonRate class allows a user create spike trains whose inter-spike interval follows a Poisson process. The object can then be linked to a spike generator group (created via CARLsim::createSpikeGeneratorGroup) by calling CARLsim::setSpikeRate.

All firing rates will be initialized to zero. The user then has a number of options to manipulate the mean firing rate of each neuron. The same rate can be applied to all neurons by calling PoissonRate::setRates(float rate). Individual rates can be applied from a vector by calling PoissonRate::setRates(const std::vector<float>& rates). The rate of a single neuron can be manipulated by calling PoissonRate::setRate(int neurId, float rate).

Example usage:

// create a PoissonRate object on GPU for a group of 50 neurons
PoissonRate myRate(50, true);
// let all rates be zero except the one for neurId=42, set that to 20 Hz
myRate.setRate(42, 20.0f);
// apply to spike generator group (say, g0) of CARLsim object in SETUP or EXECUTION state
// and run the network for a second
sim.setSpikeRate(g0, &myRate);
sim.runNetwork(1,0);
// now change the rates of all neurons to 12 Hz
myRate.setRates(12.0f);
sim.setSpikeRate(g0, &myRate);
sim.runNetwork(1,0);
Attention
The mean firing rate will keep getting applied to any instances of CARLsim::runNetwork until the user changes the values and calls CARLsim::setSpikeRate again.
Note
A PoissonRate object can be allocated either on the CPU or the GPU. However, GPU allocation is only supported if the CARLsim simulation is run in GPU_MODE.
Since
v3.0

Definition at line 84 of file poisson_rate.h.

Constructor & Destructor Documentation

PoissonRate ( int  nNeur,
bool  onGPU = false 
)

Creates a new instance of class PoissonRate.

Parameters
[in]nNeurthe number of neurons for which to generate Poisson spike trains
[in]onGPUwhether to allocate the rate vector on GPU (true) or CPU (false)
Since
v2.0

Cleans up all the memory upon object deletion.

Since
v2.0

Member Function Documentation

int getNumNeurons ( )

This function returns the number of neurons for which to generate Poisson spike trains. This number is defined at initialization and cannot be changed during the object lifetime.

Returns
number of neurons
Since
v3.0
float getRate ( int  neurId)

This function returns the mean firing rate assigned to a specific neuron ID. The neuron ID is 0-indexed and should thus be in the range [ 0 , getNumNeurons() ). It is completely independent from CARLsim neuron IDs.

Parameters
[in]neurIdthe neuron ID (0-indexed)
Returns
mean firing rate
Since
v3.0
float* getRatePtrCPU ( )

This function returns a pointer to the underlying firing rate array if allocated on the CPU. This pointer does not exist when the PoissonRate object is allocated on GPU.

Deprecated:
This function is deprecated, as it should not be exposed to the high-level UI API. Use PoissonRate::getRates instead.
float* getRatePtrGPU ( )

This function returns a pointer to the underlying firing rate array if allocated on the GPU. This pointer does not exist when the PoissonRate object is allocated on CPU.

Deprecated:
This function is deprecated, as it should not be exposed to the high-level UI API. Use PoissonRate::getRates instead.
std::vector<float> getRates ( )

This function returns all the mean firing rates in a vector, one vector element per neuron.

Returns
vector of firing rates
Since
v3.0
bool isOnGPU ( )

This function checks whether the firing rates are allocated either on CPU or GPU.

Returns
a flag whether allocated on GPU (true) or CPU (false)
Since
v3.0
void setRate ( int  neurId,
float  rate 
)

This function sets the firing rate of a particular neuron ID. The neuron ID is 0-indexed and should thus be in the range [ 0 , getNumNeurons() ). It is completely independent from CARLsim neuron IDs.

Parameters
[in]neurIdthe neuron ID (0-indexed)
[in]ratethe firing rate to set
Since
v3.0
void setRates ( float  rate)

This function assigns the same firing rate to all the neurons.

Parameters
[in]ratethe firing rate to set
Since
v3.0
void setRates ( const std::vector< float > &  rates)

This function sets the firing rate of each neuron from a vector of firing rates, one rate per neuron.

Parameters
[in]ratesvector of firing rates (size should be equivalent to PoissonRate::getNumNeurons())
Since
v3.0

The documentation for this class was generated from the following file: