auryn::StimulusGroup Class Reference

Provides a poisson stimulus at random intervals in one or more predefined subsets of the group that are read from a file. More...

#include <StimulusGroup.h>

Inheritance diagram for auryn::StimulusGroup:

Collaboration diagram for auryn::StimulusGroup:

Public Member Functions
virtual unsigned int	get_num_stimuli ()
	Returns number of stimuli. More...
	StimulusGroup (NeuronID n, string filename, string stimfile, StimulusGroupModeType stimulusmode=RANDOM, AurynFloat baserate=1.0)
	Default constructor. More...
	StimulusGroup (NeuronID n, string stimfile, StimulusGroupModeType stimulusmode=RANDOM, AurynFloat baserate=1.0)
	Constructor without pattern file. Patterns can be loaded afterwards using the load_patterns method. More...
virtual	~StimulusGroup ()
virtual void	evolve ()
	Standard virtual evolve function. More...
void	set_baserate (AurynFloat baserate)
	Sets the baserate that is the rate at 1 activity. More...
void	set_maxrate (AurynFloat baserate)
	TODO. More...
void	set_stimulation_mode (StimulusGroupModeType mode)
	Sets the stimulation mode. Can be any of StimulusGroupModeType (MANUAL,RANDOM,SEQUENTIAL,SEQUENTIAL_REV). More...
void	set_all (AurynFloat val=0.0)
	Sets sets the activity of all units. More...
void	seed (int rndseed)
	Seeds the random number generator for all stimulus groups of the simulation. More...
AurynFloat	get_activity (NeuronID i)
	Gets the activity of unit i. More...
virtual void	load_patterns (string filename)
	Loads stimulus patterns from a designated pat file given. More...
virtual void	clear_patterns ()
	Clear stimulus patterns. More...
void	set_mean_off_period (AurynFloat period)
	Set mean quiet interval between consecutive stimuli. More...
void	set_mean_on_period (AurynFloat period)
	Set mean on period. More...
void	set_pattern_activity (unsigned int i)
	Function that loops over the stimulus/pattern vector and sets the activity verctor to the gamma values given with the pattern. More...
void	set_pattern_activity (unsigned int i, AurynFloat setval)
	Function that loops over the stimulus/pattern vector and sets the activity verctor to the given value. More...
virtual void	set_active_pattern (unsigned int i)
	This function is called internally and sets the activity level to a given active stimulus. More...
void	set_active_pattern (unsigned int i, AurynFloat default_value)
	This function is called internally and sets the activity level to a given active stimulus. More...
void	set_next_action_time (double time)
void	set_distribution (std::vector< double > probs)
	Setter for pattern probability distribution. More...
std::vector< double >	get_distribution ()
	Getter for pattern probability distribution. More...
double	get_distribution (int i)
	Getter for pattern i of the probability distribution. More...
unsigned int	get_stim_count ()
	Returns number of stimuli shown. More...
AurynTime	get_last_action_time ()
	returns the last action (stim on/off) time in units of AurynTime More...
AurynTime	get_last_onset_time ()
	returns the last stimulus onset time in units of AurynTime More...
AurynTime	get_last_offset_time ()
	returns the last stimulus offset time in units of AurynTime More...
AurynTime	get_next_action_time ()
	returns the next action (stim on/off) time in units of AurynTime More...
unsigned int	get_cur_stim ()
	returns the index of the current (or last – if not active anymore) active stimulus More...
bool	get_stim_active ()
	Returns true if currently a stimulus is active and false otherwise. More...
void	flat_distribution ()
void	normalize_distribution ()
std::vector< type_pattern > *	get_patterns ()
Public Member Functions inherited from auryn::SpikingGroup
void	add_state_vector (std::string key, AurynStateVector *state_vector)
	Adds a state vector passed as an argument to the dictinary. More...
void	remove_state_vector (std::string key)
	Removes a state vector passed as an argument to the dictinary. More...
AurynStateVector *	find_state_vector (std::string key)
	Returns existing state vector by name or NULL if it does not exist. More...
AurynStateVector *	get_state_vector (std::string key)
	Creates a new or returns an existing state vector by name. More...
AurynStateVector *	get_existing_state_vector (std::string key)
	Returns an existing state with the supplied name. More...
AurynStateVector *	create_state_vector (std::string key)
	Creates a new state vector and throws an exception if a vector with the same name exists. More...
AurynState *	get_state_variable (std::string key)
	Creates a new group-wide state variable or returns an existing group-wide variable by name then returns a pointer to it. More...
void	randomize_state_vector_gauss (std::string state_vector_name, AurynState mean, AurynState sigma, int seed=12239)
	Randomizes the content of a state vector with Gaussian random numbers. Seeding is MPI save. More...
	SpikingGroup (NeuronID size, NodeDistributionMode mode=AUTO)
	Default constructor. More...
virtual	~SpikingGroup ()
	Default destructor. More...
virtual void	evolve_traces ()
	Evolves traces. More...
void	set_name (std::string s)
	Set connection name. More...
std::string	get_name ()
	Retrieves the groups name. More...
std::string	get_file_name ()
	Extracts the class name of the connection from the file name. More...
std::string	get_log_name ()
	Returns a string which is the combination of file and connection name for logging. More...
void	inc_num_spike_attributes (int x)
	Instructs SpikingGroup to increase the number of spike attributes by x. More...
int	get_num_spike_attributes ()
void	conditional_evolve ()
	Conditional evolve functino which is called by System. More...
unsigned int	get_locked_rank ()
	Returns locked rank for SpikingGroups which are not distributed across all ranks. More...
unsigned int	get_locked_range ()
	Returns locked range of ranks for SpikingGroups which are not distributed across all ranks. More...
SpikeContainer *	get_spikes ()
	Returns pointer to a spike container that contains spikes which arrive in this timestep from all neurons in this group. More...
SpikeContainer *	get_spikes_immediate ()
	Returns pointer to SpikeContainer of spikes generated during the last evolve() step. More...
AttributeContainer *	get_attributes ()
	Returns pointer to Attributecontainer for usage in propagating Connection objects. Same as get_spikes_immediate(), however might be overwritten to contain Spikes that have been delayed. More...
AttributeContainer *	get_attributes_immediate ()
	Returns pointer to Attributecontainer of spikes generated during the last evolve() step. More...
NeuronID	get_size ()
	Returns the size of the group. More...
NeuronID	get_pre_size ()
	Returns the size of the group. More...
NeuronID	calculate_rank_size (int rank=-1)
	Determines rank size and stores it in local variable. More...
NeuronID	get_rank_size ()
	Returns the size on this rank. More...
NeuronID	get_post_size ()
	Returns the size on this rank. More...
void	set_clock_ptr (AurynTime *clock)
bool	evolve_locally ()
	Returns true if the calling instance has units which are integrated on the current rank. More...
NeuronID	get_uid ()
	Get the unique ID of the class. More...
Trace *	get_pre_trace (AurynFloat x)
	Returns a pre trace with time constant x. More...
void	add_pre_trace (Trace *tr)
	Adds trace to pretrace stack of a connection. More...
Trace *	get_post_trace (AurynFloat x)
	Returns a post trace with time constant x. More...
void	add_post_trace (Trace *tr)
	Adds trace to posttrace stack of a connection. More...
void	push_spike (NeuronID spike)
	Pushes a local NeuronID as spike into the axonal SpikeDelay buffer. More...
void	push_attribute (AurynFloat attrib)
	Pushes a spike attribute into the axonal SpikeDelay buffer. More...
void	clear_spikes ()
	Clears all spikes stored in the delays which is useful to reset a network during runtime. More...
Trace *	get_post_state_trace (std::string state_name="mem", AurynFloat tau=10e-3, AurynFloat b=0.0)
	Returns a post trace of a neuronal state variable e.g. the membrane potential with time constant tau. More...
Trace *	get_post_state_trace (AurynStateVector *state, AurynFloat tau=10e-3, AurynFloat b=0.0)
	Returns a post trace of a neuronal state variable specified by pointer. More...
void	set_delay (int d)
	Sets axonal delay for this SpikingGroup. More...
virtual bool	write_to_file (const char *filename)
	Writes current states of SpikingGroup to human-readible textfile if implemented in derived class. More...
virtual bool	load_from_file (const char *filename)
	Reads current states of SpikingGroup to human-readible textfile if implemented in derived class. More...
NeuronID	ranksize ()
	Returns size (num of neurons) on the current rank. More...
NeuronID	global2rank (NeuronID i)
	Converts global NeuronID within the SpikingGroup to the local NeuronID on this rank. More...
NeuronID	rank2global (NeuronID i)
	Converts local NeuronID from the local rank to a global NeuronID. More...
bool	localrank (NeuronID i)
	Checks if the global NeuronID i is integrated on this MPI rank. More...
NeuronID	get_vector_size ()
	Rank size but rounded up to multiples of 4 (or potentially some other and larger number in future versions) for SSE compatibility. More...

Public Attributes
int	cur_stim_index
	Current stimulus index. More...
bool	stimulus_active
	Current stimulus active. More...
std::vector< type_pattern >	stimuli
	Vector containing all the stimuli. More...
AurynFloat	scale
	This is by how much the pattern gamma value is multiplied. The resulting value gives the x-times baseline activation. More...
bool	binary_patterns
	Switches to more efficient algorithm which ignores the gamma value. More...
AurynTime	refractory_period
	Enables a finite refractory time specified in AurynTime (only works for non-binary-pattern mode. More...
bool	randomintervals
	Determines if the Group is using random activation intervals. More...
bool	randomintensities
	Determines if the Group is using random activation intensities. More...
AurynDouble	background_rate
	Play random Poisson noise with this rate on all channels when no stim is active. More...
bool	background_during_stimulus
	Switch for background firing during stimulus. More...
Public Attributes inherited from auryn::SpikingGroup
SpikeDelay *	delay
bool	active
	Toggles group active. More...
std::map< std::string, AurynStateVector * >	state_vectors
std::map< std::string, AurynState >	state_variables

Protected Member Functions
void	init (StimulusGroupModeType stimulusmode, string stimfile, AurynFloat baserate)
virtual void	redraw ()
void	write_stimulus_file (AurynDouble time)
void	read_next_stimulus_from_file (AurynDouble &time, int &active, int &stimulusid)
void	set_activity (NeuronID i, AurynFloat val=0.0)
Protected Member Functions inherited from auryn::SpikingGroup
virtual void	load_input_line (NeuronID i, const char *buf)
virtual std::string	get_output_line (NeuronID i)
virtual void	virtual_serialize (boost::archive::binary_oarchive &ar, const unsigned int version)
	Implementatinon of serialize function for writing. More...
virtual void	virtual_serialize (boost::archive::binary_iarchive &ar, const unsigned int version)
	Implementatinon of serialize function for reading. More...
void	free ()
	Frees potentially allocated memory. More...

Protected Attributes
AurynTime *	ttl
AurynFloat *	activity
StimulusGroupModeType	stimulus_order
unsigned int	stimulation_count
	Counter variable for number of stimuli shown. More...
NeuronID	fgx
NeuronID	bgx
std::vector< double >	probabilities
AurynTime	next_action_time
	next stimulus time requiring change in rates More...
AurynTime	last_action_time
	last stimulus time requiring change in rates More...
AurynTime	last_stim_onset_time
	last stimulus onset time More...
AurynTime	last_stim_offset_time
	last stimulus offset time More...
AurynFloat	mean_off_period
AurynFloat	mean_on_period
AurynFloat	curscale
Protected Attributes inherited from auryn::SpikingGroup
std::vector< Trace * >	pretraces
	Pretraces. More...
std::vector< Trace * >	posttraces
	Posttraces. More...
std::vector< Trace * >	post_state_traces
	Post state traces. More...
std::vector< AurynFloat >	post_state_traces_spike_biases
std::vector< AurynStateVector * >	post_state_traces_states
std::string	group_name
	Identifying name for object. More...
NeuronID	size
	Stores the size of the group. More...
NeuronID	rank_size
	Stores the size of the group on this rank. More...
SpikeContainer *	spikes
	SpikeContainers to store spikes produced during one step of evolve. More...
AttributeContainer *	attribs

Static Protected Attributes
static boost::mt19937	poisson_gen = boost::mt19937()
static boost::mt19937	order_gen = boost::mt19937()
static boost::uniform_01< boost::mt19937 >	order_die = boost::uniform_01<boost::mt19937> (order_gen)
Static Protected Attributes inherited from auryn::SpikingGroup
static AurynTime *	clock_ptr = NULL

Detailed Description

Provides a poisson stimulus at random intervals in one or more predefined subsets of the group that are read from a file.

Constructor & Destructor Documentation

StimulusGroup() [1/2]

StimulusGroup::StimulusGroup	(	NeuronID	n,
		std::string	filename,
		std::string	stimfile,
		StimulusGroupModeType	stimulusmode = RANDOM,
		AurynFloat	baserate = 1.0
	)

Default constructor.

Parameters

n	Size of the group
filename	The path and filename of the pat file.
stimfile	The path and filename of the output file used to record the stimulus timing.
stimulusmode	Stimulus mode specifies in which order patterns are presented
baserate	The base firing rate with which all activity is multiplied.

                                                                                                                                        : SpikingGroup( n ) 
{
        init(stimulusmode, stimfile, baserate);
        load_patterns(filename);
}

Here is the call graph for this function:

StimulusGroup() [2/2]

StimulusGroup::StimulusGroup	(	NeuronID	n,
		std::string	stimfile,
		StimulusGroupModeType	stimulusmode = RANDOM,
		AurynFloat	baserate = 1.0
	)

Constructor without pattern file. Patterns can be loaded afterwards using the load_patterns method.

Like the default constructor only that no patterns are specified. They have to be loaded afterwards using the load_patterns function.

Parameters

n	Size of the group
stimfile	The path and filename of the output file used to record the stimulus timing.
stimulusmode	Stimulus mode specifies in which order patterns are presented
baserate	The base firing rate with which all activity is multiplied.

                                                                                                                    : SpikingGroup( n ) // Load multiplier is an empirical value
{
        init(stimulusmode, stimfile, baserate);
}

Here is the call graph for this function:

~StimulusGroup()

StimulusGroup::~StimulusGroup ( )

virtual

{
        delete [] ttl;
        tiserfile.close();
}

Member Function Documentation

clear_patterns()

void StimulusGroup::clear_patterns ( )

virtual

Clear stimulus patterns.

{
        stimuli.clear();
        stimulus_active = false ;
}

evolve()

void StimulusGroup::evolve ( )

virtual

Standard virtual evolve function.

Implements auryn::SpikingGroup.

Reimplemented in auryn::SpikeTimingStimGroup.

{
        if ( !active ) return;


        if ( stimulus_active ) { // during active stimulation

                if ( binary_patterns ) { // binary patterns
                        // detect and push spikes

                        boost::exponential_distribution<> dist(curscale);
                        boost::variate_generator<boost::mt19937&, boost::exponential_distribution<> > die(poisson_gen, dist);

                        type_pattern current = stimuli[cur_stim_index];

                        if ( !background_during_stimulus )
                                bgx = get_rank_size();

                        while ( bgx < get_rank_size() || fgx < current.size() ) {
                                if ( fgx < current.size() && current.at(fgx).i < bgx ) {
                                        push_spike ( current.at(fgx).i );
                                        AurynDouble r = die();
                                        fgx += 1+(NeuronID)(r/auryn_timestep);
                                } else {
                                        push_spike ( bgx );

                                        boost::exponential_distribution<> bg_dist(background_rate);
                                        boost::variate_generator<boost::mt19937&, boost::exponential_distribution<> > bg_die(poisson_gen, bg_dist);
                                        AurynDouble r = bg_die();
                                        bgx += 1+(NeuronID)(r/auryn_timestep); 
                                }
                        }
                        if ( background_during_stimulus )
                                bgx -= get_rank_size();

                        if ( fgx >= current.size() )
                                fgx -= current.size();

                } else { // non-binary patterns --- using time-to-live TTL mechanism
                        boost::exponential_distribution<> dist(1.0);
                        boost::variate_generator<boost::mt19937&, boost::exponential_distribution<> > die(poisson_gen, dist);

                        for ( NeuronID i = 0 ; i < get_rank_size() ; ++i )
                        {
                                if ( ttl[i] < auryn::sys->get_clock() && activity[i]>0.0 )
                                {
                                        push_spike ( i );
                                        ttl[i] = auryn::sys->get_clock() + refractory_period + (AurynTime)((AurynFloat)die()*(1.0/(activity[i]*auryn_timestep)-refractory_period));
                                }
                        }
                }
        } else { // while stimulation is off
                if ( background_rate ) {
                        boost::exponential_distribution<> dist(background_rate);
                        boost::variate_generator<boost::mt19937&, boost::exponential_distribution<> > die(poisson_gen, dist);

                        while ( bgx < get_rank_size() ) {
                                push_spike ( bgx );
                                AurynDouble r = die();
                                bgx += 1+(NeuronID)(r/auryn_timestep); 
                        }
                        bgx -= get_rank_size();
                }
        }

        // update stimulus properties
        if ( auryn::sys->get_clock() >= next_action_time ) { // action required
                last_action_time = next_action_time; // store last time before updating next_action_time

                if ( get_num_stimuli() == 0 ) {
                        set_next_action_time(10); // TODO make this a bit smarter at some point -- i.e. could send this to the end of time 
                        return;
                }

                write_stimulus_file(auryn_timestep*(auryn::sys->get_clock()));

                // if we have variable rate stimuli update curscale otherwise set to scale 
                // this is only needed for binary stimuli -- otherwise the change is done in
                // set_pattern_activity
                if ( randomintensities && binary_patterns ) {
                        curscale = scale*(AurynFloat)order_die();
                } else {
                        curscale = scale;
                }

                if ( stimulus_order == STIMFILE )  {
                        AurynDouble t = 0.0;
                        int a,i;
                        while ( t <= auryn::sys->get_time() ) {
                                read_next_stimulus_from_file(t,a,i);
                                next_action_time = (AurynTime) (t/auryn_timestep);
                                if (a==0) stimulus_active = true; 
                                        else stimulus_active = false;
                                cur_stim_index = i;
                                // std::cout << auryn::sys->get_time() << " " << t << " " << a << " " << i << std::endl;
                        }
                } else { // we have to generate stimulus times

                        if ( stimulus_active ) { // stimulus was active and going inactive now

                                if ( !binary_patterns )
                                        set_all( 0.0 ); // turns off currently active stimulus 
                                stimulus_active = false ;
                                last_stim_offset_time = sys->get_clock();

                                if ( randomintervals && mean_off_period>0.0 ) {
                                        boost::exponential_distribution<> dist(1./mean_off_period);
                                        boost::variate_generator<boost::mt19937&, boost::exponential_distribution<> > die(order_gen, dist);
                                        next_action_time = auryn::sys->get_clock() + (AurynTime)(std::max(0.0,die())/auryn_timestep);
                                } else {
                                        next_action_time = auryn::sys->get_clock() + (AurynTime)(mean_off_period/auryn_timestep);
                                }
                        } else { // stimulus was not active and is going active now
                                if ( active && get_num_stimuli() ) { // the group is active and there are stimuli in the array

                                        // chooses stimulus according to schema specified in stimulusmode
                                        double draw, cummulative;
                                        switch ( stimulus_order ) {
                                                case RANDOM:
                                                        // TODO make this less greedy 
                                                        // and do not compute this every draw
                                                        draw = order_die();
                                                        cummulative = 0; 
                                                        cur_stim_index = 0;
                                                        // std::cout.precision(5);
                                                        // std::cout << " draw " << draw <<  std::endl;
                                                        for ( unsigned int i = 0 ; i < probabilities.size() ; ++i ) {
                                                                cummulative += probabilities[i];
                                                                // std::cout << cummulative << std::endl;
                                                                if ( draw <= cummulative ) {
                                                                        cur_stim_index = i;
                                                                        break;
                                                                }
                                                        }
                                                break;
                                                case SEQUENTIAL:
                                                        cur_stim_index = (cur_stim_index+1)%get_num_stimuli();
                                                break;
                                                case SEQUENTIAL_REV:
                                                        --cur_stim_index;
                                                        if ( cur_stim_index <= 0 ) 
                                                                cur_stim_index = get_num_stimuli() - 1 ;
                                                break;
                                                case MANUAL:
                                                default:
                                                break;
                                        }

                                        if ( !binary_patterns )
                                                set_active_pattern( cur_stim_index );
                                        stimulus_active = true;
                                        stimulation_count++;
                                        last_stim_onset_time = sys->get_clock();

                                        if ( randomintervals && stimulus_order != STIMFILE ) {
                                                boost::normal_distribution<> dist(mean_on_period,mean_on_period/3);
                                                boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > die(order_gen, dist);
                                                next_action_time = auryn::sys->get_clock() + (AurynTime)(std::max(0.0,die())/auryn_timestep);
                                        } else {
                                                next_action_time = auryn::sys->get_clock() + (AurynTime)(mean_on_period/auryn_timestep);
                                        }
                                }
                        }
                        write_stimulus_file(auryn_timestep*(auryn::sys->get_clock()+1));
                }
        }
}

Here is the call graph for this function:

flat_distribution()

void StimulusGroup::flat_distribution

(

)

Initialized distribution to be flat

{
        for ( unsigned int i = 0 ; i < get_num_stimuli() ; ++i ) {
                probabilities.push_back(1./((double)get_num_stimuli()));
        }
}

Here is the call graph for this function:

get_activity()

AurynFloat StimulusGroup::get_activity

(

NeuronID

i

)

Gets the activity of unit i.

{
        if ( localrank(i) )
                return activity[global2rank(i)];
        else 
                return 0;
}

Here is the call graph for this function:

get_cur_stim()

unsigned int StimulusGroup::get_cur_stim

(

)

returns the index of the current (or last – if not active anymore) active stimulus

{
        return cur_stim_index;
}

get_distribution() [1/2]

std::vector< double > StimulusGroup::get_distribution

(

)

Getter for pattern probability distribution.

{
        return probabilities;
}

get_distribution() [2/2]

double StimulusGroup::get_distribution

(

int

i

)

Getter for pattern i of the probability distribution.

{
        return probabilities[i];
}

get_last_action_time()

AurynTime StimulusGroup::get_last_action_time

(

)

returns the last action (stim on/off) time in units of AurynTime

{
        return last_action_time;
}

get_last_offset_time()

AurynTime StimulusGroup::get_last_offset_time

(

)

returns the last stimulus offset time in units of AurynTime

{
        return last_stim_offset_time;
}

get_last_onset_time()

AurynTime StimulusGroup::get_last_onset_time

(

)

returns the last stimulus onset time in units of AurynTime

{
        return last_stim_onset_time;
}

get_next_action_time()

AurynTime StimulusGroup::get_next_action_time

(

)

returns the next action (stim on/off) time in units of AurynTime

{
        return next_action_time;
}

get_num_stimuli()

unsigned int StimulusGroup::get_num_stimuli ( )

virtual

Returns number of stimuli.

{
        return stimuli.size();
}

get_patterns()

std::vector< type_pattern > * StimulusGroup::get_patterns

(

)

{
        return &stimuli;
}

get_stim_active()

bool StimulusGroup::get_stim_active

(

)

Returns true if currently a stimulus is active and false otherwise.

{
        return stimulus_active;
}

get_stim_count()

unsigned int StimulusGroup::get_stim_count

(

)

Returns number of stimuli shown.

{
        return stimulation_count;
}

init()

void StimulusGroup::init ( StimulusGroupModeType  stimulusmode, std::string  stimfile, AurynFloat  baserate  )

protected

Standard initialization

{
        auryn::sys->register_spiking_group(this);
        ttl = new AurynTime [get_rank_size()];

        refractory_period = 1; // initialize with a default of one timestep (avoids two spikes in same time bin)

        activity = new AurynFloat [get_rank_size()];
        for ( NeuronID i = 0 ; i < get_rank_size() ; ++i ) activity[i] = 0.0;
        set_baserate(baserate);

        seed(2351301);


        set_stimulation_mode(stimulusmode);

        stimulation_count = 0;
        stimulus_active = false ;
        set_all( 0.0 ); 

        randomintervals = true;
        mean_off_period = 1.0 ;
        mean_on_period = 0.2 ;

        randomintensities = false;
        scale = 1.0; // TODO does this need to be initialized at 2 ?
        curscale = scale;

        background_during_stimulus = false;

        background_rate = 0.0;
        bgx  = 0 ;

        fgx  = 0 ;


        binary_patterns = false;

        // if a filename was supplied and we are 
        // not supposed to be reading from it.
        if ( !stimfile.empty() && stimulus_order != STIMFILE ) 
        {
                tiserfile.open(stimfile.c_str(),std::ios::out);
                tiserfile.setf(std::ios::fixed);
        } else {
                if (stimulus_order==STIMFILE) {
                        tiserfile.open(stimfile.c_str(),std::ios::in);
                }
        }

        if (!tiserfile) {
                std::stringstream oss;
                oss << "StimulusGroup:: Cannot open stimulus file " 
                        << stimfile
                        << " for ";
                if (stimulus_order==STIMFILE) oss << "reading.";
                else oss << "writing.";

                auryn::logger->msg(oss.str(),ERROR);
                throw AurynOpenFileException();
        }

        std::stringstream oss;
        oss << "StimulusGroup:: " 
                << "size " << get_size() << " "  
                << "(mode " << stimulus_order << ") ";
        auryn::logger->msg(oss.str(),INFO);

        cur_stim_index = 0;
        next_action_time = 0;
        last_action_time = 0;
        active = true;
        off_pattern = -1;

}

Here is the call graph for this function:

load_patterns()

void StimulusGroup::load_patterns ( std::string  filename )

virtual

Loads stimulus patterns from a designated pat file given.

Parameters

filename

The path and filename of the pat file to laod.

{
        std::ifstream fin (filename.c_str());
        if (!fin) {
                std::stringstream oss;
                oss << "StimulusGroup:: "
                << "There was a problem opening file "
                << filename
                << " for reading."
                << std::endl;
                auryn::logger->msg(oss.str(),ERROR);
                throw AurynOpenFileException();
        }

        char buffer[256];
        std::string line;

        clear_patterns();

        type_pattern pattern;
        int total_pattern_size = 0;
        while(!fin.eof()) {

                line.clear();
                fin.getline (buffer,255);
                line = buffer;

                if (line[0] == '#') continue;
                if (line == "") { 
                        if ( total_pattern_size > 0 ) {
                                std::stringstream oss;
                                oss << "StimulusGroup:: Read pattern " 
                                        << get_num_stimuli() 
                                        << " with pattern size "
                                        << total_pattern_size
                                        << " ( "
                                        << pattern.size()
                                        << " on rank )";
                                auryn::logger->msg(oss.str(),VERBOSE);

                                stimuli.push_back(pattern);
                                pattern.clear();
                                total_pattern_size = 0;
                        }
                        continue;
                }

                std::stringstream iss (line);
                NeuronID i ;
                iss >> i ;
                if ( localrank( i ) ) {
                        pattern_member pm;
                        pm.gamma = 1.0 ;
                        iss >>  pm.gamma ;
                        pm.i = global2rank( i ) ;
                        pattern.push_back( pm ) ;
                }
                total_pattern_size++;
        }

        fin.close();

        // initializing all probabilities as a flat distribution
        flat_distribution();

        std::stringstream oss;
        oss << "StimulusGroup:: Finished loading " << get_num_stimuli() << " patterns";
        auryn::logger->msg(oss.str(),NOTIFICATION);
}

Here is the call graph for this function:

normalize_distribution()

void StimulusGroup::normalize_distribution

(

)

Normalizes the distribution

{
        std::stringstream oss;
        oss << "StimulusGroup: Normalizing distribution [";
        double sum = 0 ;
        for ( unsigned int i = 0 ; i < get_num_stimuli() ; ++i ) {
                sum += probabilities[i];
        }

        // normalize vector 
        for ( unsigned int i = 0 ; i < get_num_stimuli() ; ++i ) {
                probabilities[i] /= sum;
                oss << " " << probabilities[i];
        }

        oss << " ]";
        auryn::logger->msg(oss.str(),VERBOSE);
}

Here is the call graph for this function:

read_next_stimulus_from_file()

void StimulusGroup::read_next_stimulus_from_file ( AurynDouble &  time, int &  active, int &  stimulusid  )

protected

Read current stimulus status from stimfile

                                                                                                 {
        char buffer[256];
        if ( tiserfile.getline (buffer,256) ) {
                sscanf (buffer,"%lf %i %i",&time,&active,&stimulusid);
        } else {
                time = auryn::sys->get_time()+1000; // TODO this is a bit weird as a condition but should do the job
                active = 0;
                stimulusid = 0;
        }
}

Here is the call graph for this function:

redraw()

void StimulusGroup::redraw ( )

protectedvirtual

Draw all Time-To-Live (ttls) typically after changing the any of the activiteis

Reimplemented in auryn::SpikeTimingStimGroup.

{
        boost::exponential_distribution<> dist(1.0);
        boost::variate_generator<boost::mt19937&, boost::exponential_distribution<> > die(poisson_gen, dist);
        for ( NeuronID i = 0 ; i < get_rank_size() ; ++i )
        {
                if (activity[i]>0) 
                        ttl[i] = auryn::sys->get_clock() + (AurynTime)((AurynFloat)die()/(activity[i]*auryn_timestep));
        }
}

Here is the call graph for this function:

seed()

void StimulusGroup::seed

(

int

rndseed

)

Seeds the random number generator for all stimulus groups of the simulation.

{
        unsigned int rnd = rndseed + sys->get_synced_seed(); // most be same on all ranks
        order_gen.seed(rnd); 

        // this is here because the seeding above alone does not seem to do anything
        // also need to overwrite the dist operator because it makes of copy of the
        // generator
        // see http://www.bnikolic.co.uk/blog/cpp-boost-uniform01.html
        order_die = boost::uniform_01<boost::mt19937> (order_gen);

        rnd = rndseed + sys->get_seed(); // adds salt to make it different across ranks
        std::stringstream oss;
        oss << "StimulusGroup:: " 
                << "seeding Poisson generator with " 
                << rnd;
        auryn::logger->msg(oss.str(),VERBOSE);
        
        poisson_gen.seed(rnd); // is now drawn differently but reproducibly so for each rank
}

Here is the call graph for this function:

set_active_pattern() [1/2]

void StimulusGroup::set_active_pattern ( unsigned int  i )

virtual

This function is called internally and sets the activity level to a given active stimulus.

Parameters

i	the index of the pattern to set the activity to

{
        set_active_pattern(i, background_rate);
}

set_active_pattern() [2/2]

void StimulusGroup::set_active_pattern	(	unsigned int	i,
		AurynFloat	default_value
	)

This function is called internally and sets the activity level to a given active stimulus.

Parameters

i	The index of the pattern to set the activity to
default_value	The value to assign to the activity values which are not specified in the pattern file. Typically this corresponds to some background value.

{
        std::stringstream oss;
        oss << "StimulusGroup:: Setting active pattern " << i ;
        auryn::logger->msg(oss.str(),VERBOSE);

        set_all( default_value );
        if ( i < get_num_stimuli() ) {
                set_pattern_activity(i);
        }
        redraw();
}

Here is the call graph for this function:

set_activity()

void StimulusGroup::set_activity ( NeuronID  i, AurynFloat  val = 0.0  )

protected

Sets the activity for a given unit on the local rank. Activity determines the freq as baserate*activity

{
        activity[i] = val;
}

set_all()

void StimulusGroup::set_all

(

AurynFloat

val = 0.0

)

Sets sets the activity of all units.

{
        for ( NeuronID i = 0 ; i < get_rank_size() ; ++i )
                set_activity(i,val);
}

Here is the call graph for this function:

set_baserate()

void StimulusGroup::set_baserate

(

AurynFloat

baserate

)

Sets the baserate that is the rate at 1 activity.

{
        base_rate = baserate;
        redraw();
        auryn::logger->parameter("StimulusGroup:: baserate",baserate);
}

Here is the call graph for this function:

set_distribution()

void StimulusGroup::set_distribution

(

std::vector< double >

probs

)

Setter for pattern probability distribution.

{
        for ( unsigned int i = 0 ; i < get_num_stimuli() ; ++i ) {
                probabilities[i] = probs[i];
        }

        normalize_distribution();

        std::stringstream oss;
        oss << "StimulusGroup: Set distribution [";
        for ( unsigned int i = 0 ; i < get_num_stimuli() ; ++i ) {
                oss << " " << probabilities[i];
        }
        oss << " ]";
        auryn::logger->msg(oss.str(),NOTIFICATION);
}

Here is the call graph for this function:

set_maxrate()

void StimulusGroup::set_maxrate

(

AurynFloat

baserate

)

TODO.

Todo:

Deprecated:

remove this function since it's deprecated

{
        set_baserate(baserate);
}

Here is the call graph for this function:

set_mean_off_period()

void StimulusGroup::set_mean_off_period

(

AurynFloat

period

)

Set mean quiet interval between consecutive stimuli.

{
        mean_off_period = period;
        auryn::logger->parameter("StimulusGroup:: mean_off_period",mean_off_period);
}

Here is the call graph for this function:

set_mean_on_period()

void StimulusGroup::set_mean_on_period

(

AurynFloat

period

)

Set mean on period.

{
        mean_on_period = period;
        auryn::logger->parameter("StimulusGroup:: mean_on_period",mean_on_period);
}

Here is the call graph for this function:

set_next_action_time()

void StimulusGroup::set_next_action_time

(

double

time

)

                                                      {
        next_action_time = auryn::sys->get_clock() + time/auryn_timestep;
}

Here is the call graph for this function:

set_pattern_activity() [1/2]

void StimulusGroup::set_pattern_activity

(

unsigned int

i

)

Function that loops over the stimulus/pattern vector and sets the activity verctor to the gamma values given with the pattern.

{
        type_pattern current = stimuli[i];
        type_pattern::iterator iter;

        AurynFloat addrate = 0.0;
        if ( background_during_stimulus ) 
                addrate = background_rate;

        AurynFloat curscale = scale;
        if ( randomintensities ) {
                boost::exponential_distribution<> dist(1.);
                boost::variate_generator<boost::mt19937&, boost::exponential_distribution<> > die(order_gen, dist);
                curscale *= (AurynFloat)die();
        }

        for ( iter = current.begin() ; iter != current.end() ; ++iter )
        {
                set_activity(iter->i,curscale*iter->gamma+addrate);
        }
}

Here is the call graph for this function:

set_pattern_activity() [2/2]

void StimulusGroup::set_pattern_activity	(	unsigned int	i,
		AurynFloat	setval
	)

Function that loops over the stimulus/pattern vector and sets the activity verctor to the given value.

{
        type_pattern current = stimuli[i];
        type_pattern::iterator iter;

        for ( iter = current.begin() ; iter != current.end() ; ++iter )
        {
                set_activity(iter->i,setrate);
        }
}

Here is the call graph for this function:

set_stimulation_mode()

void StimulusGroup::set_stimulation_mode

(

StimulusGroupModeType

mode

)

Sets the stimulation mode. Can be any of StimulusGroupModeType (MANUAL,RANDOM,SEQUENTIAL,SEQUENTIAL_REV).

                                                                     {
        stimulus_order = mode ;
}

write_stimulus_file()

void StimulusGroup::write_stimulus_file ( AurynDouble  time )

protected

write current stimulus to stimfile

                                                        {
        if ( tiserfile && stimulus_order != STIMFILE ) {
                tiserfile 
                        << time
                        << " ";
                if ( stimulus_active || off_pattern > -1 ) tiserfile << "1 "; else tiserfile << "0 ";
                tiserfile 
                        << cur_stim_index
                        << std::endl;
        }
}

Member Data Documentation

activity

AurynFloat* auryn::StimulusGroup::activity

protected

background_during_stimulus

bool auryn::StimulusGroup::background_during_stimulus

Switch for background firing during stimulus.

background_rate

AurynDouble auryn::StimulusGroup::background_rate

Play random Poisson noise with this rate on all channels when no stim is active.

bgx

NeuronID auryn::StimulusGroup::bgx

protected

Background Poisson field pointer

binary_patterns

bool auryn::StimulusGroup::binary_patterns

Switches to more efficient algorithm which ignores the gamma value.

cur_stim_index

int auryn::StimulusGroup::cur_stim_index

Current stimulus index.

Do not write this variable.

curscale

AurynFloat auryn::StimulusGroup::curscale

protected

fgx

NeuronID auryn::StimulusGroup::fgx

protected

Foreground Poisson field pointer

last_action_time

AurynTime auryn::StimulusGroup::last_action_time

protected

last stimulus time requiring change in rates

last_stim_offset_time

AurynTime auryn::StimulusGroup::last_stim_offset_time

protected

last stimulus offset time

last_stim_onset_time

AurynTime auryn::StimulusGroup::last_stim_onset_time

protected

last stimulus onset time

mean_off_period

AurynFloat auryn::StimulusGroup::mean_off_period

protected

allow silence/background activity periods

mean_on_period

AurynFloat auryn::StimulusGroup::mean_on_period

protected

mean presentation time

next_action_time

AurynTime auryn::StimulusGroup::next_action_time

protected

next stimulus time requiring change in rates

order_die

boost::uniform_01< boost::mt19937 > StimulusGroup::order_die = boost::uniform_01<boost::mt19937> (order_gen)

staticprotected

order_gen

boost::mt19937 StimulusGroup::order_gen = boost::mt19937()

staticprotected

generates info for what stimulus is active. Is supposed to give the same result on all nodes (hence same seed required)

poisson_gen

boost::mt19937 StimulusGroup::poisson_gen = boost::mt19937()

staticprotected

pseudo random number generators

probabilities

std::vector<double> auryn::StimulusGroup::probabilities

protected

stimulus probabilities

randomintensities

bool auryn::StimulusGroup::randomintensities

Determines if the Group is using random activation intensities.

randomintervals

bool auryn::StimulusGroup::randomintervals

Determines if the Group is using random activation intervals.

refractory_period

AurynTime auryn::StimulusGroup::refractory_period

Enables a finite refractory time specified in AurynTime (only works for non-binary-pattern mode.

scale

AurynFloat auryn::StimulusGroup::scale

This is by how much the pattern gamma value is multiplied. The resulting value gives the x-times baseline activation.

stimulation_count

unsigned int auryn::StimulusGroup::stimulation_count

protected

Counter variable for number of stimuli shown.

stimuli

std::vector<type_pattern> auryn::StimulusGroup::stimuli

Vector containing all the stimuli.

stimulus_active

bool auryn::StimulusGroup::stimulus_active

Current stimulus active.

Only read this state.

stimulus_order

StimulusGroupModeType auryn::StimulusGroup::stimulus_order

protected

Stimulus order

ttl

AurynTime* auryn::StimulusGroup::ttl

protected

---

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

• /home/zenke/auryn/src/auryn/StimulusGroup.h
• /home/zenke/auryn/src/auryn/StimulusGroup.cpp