auryn::SpikingGroup Class Reference

Abstract base class of all objects producing spikes. More...

#include <SpikingGroup.h>

Inheritance diagram for auryn::SpikingGroup:

Collaboration diagram for auryn::SpikingGroup:

Public Member Functions
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 ()
virtual void	evolve ()=0
	Virtual pure evolve function which needs to be implemented by derived classes. More...
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
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
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
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 AurynTime *	clock_ptr = NULL

Friends
class	boost::serialization::access

Detailed Description

Abstract base class of all objects producing spikes.

This is the abstract/virtual base class from which all spiking objects should be derived. All classes derived from SpikingGroup have in common that they can emit spikes. Furthermore they should implement the method evolve() for carring out internal state changes such as integration of the e.g. Euler Step. Other classes interact with inheritants of SpikingGroup by calling the functions get_spikes() and get_spikes_immediate().

Constructor & Destructor Documentation

SpikingGroup()

SpikingGroup::SpikingGroup	(	NeuronID	size,
		NodeDistributionMode	mode = AUTO
	)

Default constructor.

{
        init( n, mode );
}

~SpikingGroup()

SpikingGroup::~SpikingGroup ( )

virtual

Default destructor.

{
        free();
}

Here is the call graph for this function:

Member Function Documentation

add_post_trace()

void SpikingGroup::add_post_trace

(

Trace *

tr

)

Adds trace to posttrace stack of a connection.

Mostly for internal use by get_post_trace()

{
        if ( tr->size != get_vector_size() ) {
                std::stringstream oss;
                oss << "Trying to add as post trace, but its size does not match the SpikinGroup. "
                        << "Trace size: " << tr->size
                        << " Post size: " << get_post_size()
                        << " Expected trace size: " << get_vector_size();
                logger->warning(oss.str());
                return;
        }
        posttraces.push_back(tr);
}

Here is the call graph for this function:

add_pre_trace()

void SpikingGroup::add_pre_trace

(

Trace *

tr

)

Adds trace to pretrace stack of a connection.

Mostly for internal use by get_pre_trace()

Parameters

tr	A pointer to a presynaptic trace instance to be added to the present SpikingGroup

{
        if ( tr->size != calculate_vector_size(get_pre_size()) ) {
                std::stringstream oss;
                oss << "Trying to add as pre trace, but its size does not match the SpikinGroup. "
                        << "Trace size: " << tr->size
                        << " Pre size: " << get_pre_size()
                        << " Expected trace size: " << calculate_vector_size(get_pre_size());
                logger->warning(oss.str());
                return;
        }
        pretraces.push_back(tr);
}

Here is the call graph for this function:

add_state_vector()

void SpikingGroup::add_state_vector	(	std::string	key,
		AurynStateVector *	state_vector
	)

Adds a state vector passed as an argument to the dictinary.

{

        if ( key[0] == '_' ) {
                std::stringstream oss;
                oss << "SpikingGroup:: State vector " 
                        << key 
                        << " marked as volatile alias vector."
                        << " It will neither be saved nor freed.";
                auryn::logger->msg(oss.str(), VERBOSE);
        }
        state_vectors[key] = state_vector;
}

Here is the call graph for this function:

calculate_rank_size()

NeuronID SpikingGroup::calculate_rank_size

(

int

rank = -1

)

Determines rank size and stores it in local variable.

{
        unsigned int comrank ;
        if ( rank >= 0 ) 
                comrank = rank;
        else
                comrank = (unsigned int) mpi_rank;

        if ( comrank >= locked_rank && comrank < (locked_rank+locked_range) ) {
                if (comrank-locked_rank >= size%locked_range)
                        return size/locked_range; // abgerundete groesse
                else
                        return size/locked_range+1;  // groesse plus rest
        }

        return 0;
}

clear_spikes()

void SpikingGroup::clear_spikes

(

)

Clears all spikes stored in the delays which is useful to reset a network during runtime.

{
        delay->clear();
        get_spikes_immediate()->clear();
}

Here is the call graph for this function:

conditional_evolve()

void SpikingGroup::conditional_evolve

(

)

Conditional evolve functino which is called by System.

This function invoces evolve if the present group has work to be done on the current rank. Thus the call of evolve is made conditional on the fact if there is work to be done for this group on the present rank. This is only important for MPI parallel simulations.

{
        spikes = get_spikes_immediate(); 
        spikes->clear();
        attribs = get_attributes_immediate(); 
        attribs->clear();
        if ( evolve_locally() ) {
                evolve();
        }
}

Here is the call graph for this function:

create_state_vector()

AurynStateVector * SpikingGroup::create_state_vector

(

std::string

key

)

Creates a new state vector and throws an exception if a vector with the same name exists.

Returns a new state vector with the given key and returns an exception if a vector with the same key already exists. Moreover, NULL is returned if the state vector would have length 0 otherwise.

Exceptions

AurynDelayTooSmallException

if a state vector with the same key already exists.

Parameters

key	The key of the state vector to be created.

Returns

An AurynStateVector with the provided key.

                                                                  {
        if ( get_vector_size() == 0 ) return NULL; 
        AurynStateVector * vec = find_state_vector(key);
        if ( vec == NULL ) {
                vec = new AurynStateVector(get_vector_size()); 
                add_state_vector(key, vec);

                if ( auryn_AlignOffset( vec->size, vec->data, sizeof(float), 16) ) {
                        throw AurynMemoryAlignmentException();
                }
                return vec;
        } else {
                auryn::logger->error("Failed to creat a new state because a vector with the same key already exists.");
                throw AurynStateVectorException();
        }
}

Here is the call graph for this function:

evolve()

virtual void auryn::SpikingGroup::evolve ( )

pure virtual

Virtual pure evolve function which needs to be implemented by derived classes.

The evolve function is called during simulations in every timestep by the System class. It updates the internal state of the spiking group and pushes spikes which are generated in this timestep to the axonal output delay (SpikeDelay).

Implemented in auryn::StimulusGroup, auryn::AdExGroup, auryn::MovingBumpGroup, auryn::ModSynIFGroup, auryn::IFGroup, auryn::NaudGroup, auryn::IafPscExpGroup, auryn::TIFGroup, auryn::IzhikevichGroup, auryn::CorrelatedPoissonGroup, auryn::SRM0Group, auryn::InputChannelGroup, auryn::AuditoryBeepGroup, auryn::CubaIFGroup, auryn::FileInputGroup, auryn::AIFGroup, auryn::ProfilePoissonGroup, auryn::PoissonGroup, auryn::StructuredPoissonGroup, auryn::IafPscDeltaGroup, auryn::SpikeTimingStimGroup, auryn::AIF2Group, auryn::FileModulatedPoissonGroup, auryn::ParrotGroup, and auryn::PoissonSpikeInjector.

evolve_locally()

bool SpikingGroup::evolve_locally

(

)

Returns true if the calling instance has units which are integrated on the current rank.

{
        return evolve_locally_bool;
}

evolve_traces()

void SpikingGroup::evolve_traces ( )

virtual

Evolves traces.

{

        // evolve pre synaptic traces
        for ( NeuronID i = 0 ; i < pretraces.size() ; i++ ) { // loop over all traces 
                for (SpikeContainer::const_iterator spike = get_spikes()->begin() ; // spike = pre_spike
                                spike != get_spikes()->end() ; 
                                ++spike ) {
                        // std::cout << " bar " << *spike << std::endl;
                        pretraces[i]->inc(*spike);
                }
                pretraces[i]->evolve();
        }

        // evolve post synaptic traces
        for ( NeuronID i = 0 ; i < posttraces.size() ; i++ ) {
                for (SpikeContainer::const_iterator spike = get_spikes_immediate()->begin() ; 
                                spike != get_spikes_immediate()->end() ; 
                                ++spike ) {
                        NeuronID translated_spike = global2rank(*spike); // only to be used for post traces
                        // std::cout << " foo " << translated_spike << std::endl;
                        posttraces[i]->inc(translated_spike);
                }
                posttraces[i]->evolve();
        }

        // evolve state traces
        for ( NeuronID i = 0 ; i < post_state_traces.size() ; i++ ) {

                // spike triggered component
                if ( post_state_traces_spike_biases[i] != 0 ) {
                        for (SpikeContainer::const_iterator spike = get_spikes_immediate()->begin() ; 
                                        spike != get_spikes_immediate()->end() ; 
                                        ++spike ) {
                                NeuronID translated_spike = global2rank(*spike); // only to be used for post traces
                                post_state_traces[i]->add_specific(translated_spike, post_state_traces_spike_biases[i]);
                        }
                }

                // follow the target vector (instead of evolve)
                post_state_traces[i]->follow();
        }
}

Here is the call graph for this function:

find_state_vector()

AurynStateVector * SpikingGroup::find_state_vector

(

std::string

key

)

Returns existing state vector by name or NULL if it does not exist.

Parameters

key	A string with the name of the state vector.

Returns

The state vector and NULL if the state_vector does not exist.

{
        std::stringstream oss;
        oss << "SpikingGroup:: Running find_state_vector for " << key;
        auryn::logger->msg(oss.str(),VERBOSE);
        if ( state_vectors.find(key) == state_vectors.end() ) {
                return NULL;
        } else {
                return state_vectors.find(key)->second;
        }
}

Here is the call graph for this function:

free()

void SpikingGroup::free ( )

protected

Frees potentially allocated memory.

{
        std::stringstream oss;
        oss << "SpikingGroup:: " << 
                get_log_name()
                << " freeing ...";
        auryn::logger->msg(oss.str(),VERBOSE);

        auryn::logger->msg("SpikingGroup:: Deleting delay",VERBOSE);
        delete delay;

        auryn::logger->msg("SpikingGroup:: Freeing pretraces",VERBOSE);
        for ( NeuronID i = 0 ; i < pretraces.size() ; ++i )
                delete pretraces[i];

        auryn::logger->msg("SpikingGroup:: Freeing posttraces",VERBOSE);
        for ( NeuronID i = 0 ; i < posttraces.size() ; ++i )
                delete posttraces[i];

        auryn::logger->msg("SpikingGroup:: Freeing state traces",VERBOSE);
        for ( NeuronID i = 0 ; i < post_state_traces.size() ; ++i ) {
                std::stringstream oss;
                oss << get_log_name() 
                        << ":: Freeing state trace "
                        << post_state_traces_states[i]
                        << " at "
                        << i;
                auryn::logger->msg(oss.str() ,VERBOSE);
                delete post_state_traces[i];
        }

        auryn::logger->msg("SpikingGroup:: Freeing state vectors",VERBOSE);
        for ( std::map<std::string,AurynStateVector *>::const_iterator iter = state_vectors.begin() ; 
                        iter != state_vectors.end() ;
                        ++iter ) {
                std::stringstream oss;
                oss << "Freeing " << get_name()
                        << ": " << iter->first;
                auryn::logger->msg(oss.str(),VERBOSE);
                if ( iter->first[0] == '_' ) continue; // do not process volatile state_vector
                delete iter->second;
        }
        state_vectors.clear();

}

Here is the call graph for this function:

get_attributes()

AttributeContainer * SpikingGroup::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.

{
        return delay->get_attributes();
}

Here is the call graph for this function:

get_attributes_immediate()

AttributeContainer * SpikingGroup::get_attributes_immediate

(

)

Returns pointer to Attributecontainer of spikes generated during the last evolve() step.

{
        return delay->get_attributes_immediate();
}

Here is the call graph for this function:

get_existing_state_vector()

AurynStateVector * SpikingGroup::get_existing_state_vector

(

std::string

key

)

Returns an existing state with the supplied name.

Parameters

key	A string with the name of the state vector.

Returns

The state vector and NULL if the state_vector does not exist.

                                                                        {
        return find_state_vector(key);
}

Here is the call graph for this function:

get_file_name()

std::string SpikingGroup::get_file_name

(

)

Extracts the class name of the connection from the file name.

{
        std::string filename (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__);
        return filename;
}

get_locked_range()

unsigned int SpikingGroup::get_locked_range

(

)

Returns locked range of ranks for SpikingGroups which are not distributed across all ranks.

{
        return locked_range;
}

get_locked_rank()

unsigned int SpikingGroup::get_locked_rank

(

)

Returns locked rank for SpikingGroups which are not distributed across all ranks.

{
        return locked_rank;
}

get_log_name()

std::string SpikingGroup::get_log_name

(

)

Returns a string which is the combination of file and connection name for logging.

{
        std::stringstream oss;
        oss << get_name() << " ("
                << get_file_name() << "): ";
        return oss.str();
}

Here is the call graph for this function:

get_name()

std::string SpikingGroup::get_name

(

)

Retrieves the groups name.

{
        return group_name;
}

get_num_spike_attributes()

int SpikingGroup::get_num_spike_attributes

(

)

{
        return delay->get_num_attributes();
}

Here is the call graph for this function:

get_output_line()

std::string SpikingGroup::get_output_line ( NeuronID  i )

protectedvirtual

{
        std::stringstream oss;

        for ( std::map<std::string,AurynStateVector *>::const_iterator iter = state_vectors.begin() ; 
                        iter != state_vectors.end() ;
                        ++iter ) {
                if ( iter->first[0] == '_' ) continue; // do not process volatile state_vector
                oss << std::scientific << iter->second->get( i ) << " ";
        }

        for ( NeuronID k = 0 ; k < pretraces.size() ; k++ ) { 
                // TODO this is actually a bug and only a part of the pretrace gets saved this way
                for ( NeuronID l = 0 ; l < get_locked_range() ; ++l ) {
                        NeuronID t = get_locked_range()*(i)+l;
                        if ( t < get_size() ) 
                                oss << pretraces[k]->get(t) << " ";
                        else
                                oss << 0.0 << " ";
                }
        }

        for ( NeuronID k = 0 ; k < posttraces.size() ; k++ ) {
                oss << posttraces[k]->get(i) << " ";
        }

        oss << "\n";

        return oss.str();
}

Here is the call graph for this function:

get_post_size()

NeuronID SpikingGroup::get_post_size

(

)

Returns the size on this rank.

It's the size that should be used when a postsynaptic trace is defined on this group, hence the name.

{
        return get_rank_size();
} 

Here is the call graph for this function:

get_post_state_trace() [1/2]

Trace * SpikingGroup::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.

This trace is an cotinuously integrated Trace which uses the follow function on the mem state vector.

Parameters

state_name	A string stating the neurons state name
tau	The time constant of the trace.
b	The optional parameter b allows to specify a spike triggered contribution which will be added instantaneously to the trace upon each postsynaptic spike.

{
        AurynStateVector * state = find_state_vector( state_name );
        return get_post_state_trace(state, tau, b);
}

Here is the call graph for this function:

get_post_state_trace() [2/2]

Trace * SpikingGroup::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.

This trace is an cotinuously integrated Trace which uses the follow function on the mem state vector.

Parameters

state	A pointer to the relevant state vector
tau	The time constant of the trace.
b	The optional parameter b allows to specify a spike triggered contribution which will be added instantaneously to the trace upon each postsynaptic spike.

{
        // first let's check if a state with that name exists
        if ( state == NULL ) {
                auryn::logger->msg("A state vector was not found at this pointer reference.", ERROR);
                throw AurynStateVectorException();
        } // good to go

        for ( NeuronID i = 0 ; i < post_state_traces.size() ; i++ ) {
                if ( post_state_traces[i]->get_tau() == tau 
                                && post_state_traces_spike_biases[i] == b
                                && post_state_traces_states[i] == state ) {
                        std::stringstream oss;
                        oss << get_log_name() 
                                << ":: Sharing post state trace for ptr reference "
                                << state  // TODO replace by name reverse lookup
                                << " with " 
                                << tau 
                                << "s timeconstant." ;
                        auryn::logger->msg(oss.str(),VERBOSE);
                        return post_state_traces[i];
                }
        }

        // trace does not exist yet, so we are creating 
        // it and do the book keeping
        auryn::logger->msg("Initializing post trace instance",VERBOSE);
        Trace * tmp = new EulerTrace(get_post_size(),tau);
        tmp->set_target(state);
        post_state_traces.push_back(tmp);
        post_state_traces_spike_biases.push_back(b);
        post_state_traces_states.push_back(state);
        return tmp;
}

Here is the call graph for this function:

get_post_trace()

Trace * SpikingGroup::get_post_trace

(

AurynFloat

x

)

Returns a post trace with time constant x.

Checks first if an instance of a trace exists and returns it otherwise creates a new instance first.

Parameters

x	The timeconstant for the postsynaptic trace.

Returns

a pointer to a postsynaptic trace instance.

{
        for ( NeuronID i = 0 ; i < posttraces.size() ; i++ ) {
                if ( posttraces[i]->get_tau() == x ) {
                        std::stringstream oss;
                        oss << get_log_name() << ":: Sharing post trace with " << x << "s timeconstant." ;
                        auryn::logger->msg(oss.str(),VERBOSE);
                        return posttraces[i];
                }
        }


        auryn::logger->msg("Initializing post trace instance",VERBOSE);
        Trace * tmp = new EulerTrace(get_post_size(),x);
        add_post_trace(tmp);
        return tmp;
}

Here is the call graph for this function:

get_pre_size()

NeuronID SpikingGroup::get_pre_size

(

)

Returns the size of the group.

It's the size that should be used when a presynaptic trace is defined on this grou, hence the name.

{
        return get_size();
} 

Here is the call graph for this function:

get_pre_trace()

Trace * SpikingGroup::get_pre_trace

(

AurynFloat

x

)

Returns a pre trace with time constant x.

Checks first if an instance of a trace exists and returns it otherwise creates a new instance first.

Parameters

x	The timeconstant for the presynaptic trace

Returns

a pointer to a pre trace instance

{
        for ( NeuronID i = 0 ; i < pretraces.size() ; i++ ) {
                if ( pretraces[i]->get_tau() == x ) {
                        std::stringstream oss;
                        oss << get_log_name() << ":: Sharing pre trace with " << x << "s timeconstant." ;
                        auryn::logger->msg(oss.str(),VERBOSE);
                        return pretraces[i];
                }
        }

        auryn::logger->msg("Initializing pre trace instance",VERBOSE);
        Trace * tmp = new EulerTrace(get_pre_size(),x);
        add_pre_trace(tmp);
        return tmp;
}

Here is the call graph for this function:

get_rank_size()

NeuronID auryn::SpikingGroup::get_rank_size ( )

inline

Returns the size on this rank.

{
        return rank_size;
} 

get_size()

NeuronID SpikingGroup::get_size

(

)

Returns the size of the group.

{
        return size;
} 

get_spikes()

SpikeContainer * SpikingGroup::get_spikes

(

)

Returns pointer to a spike container that contains spikes which arrive in this timestep from all neurons in this group.

In paralell simulations the SpikeContainer returned is at this point in time guaranteed to contain spikes from all ranks.

{
        return delay->get_spikes();
}

Here is the call graph for this function:

get_spikes_immediate()

SpikeContainer * SpikingGroup::get_spikes_immediate

(

)

Returns pointer to SpikeContainer of spikes generated during the last evolve() step.

{
        return delay->get_spikes_immediate();
}

Here is the call graph for this function:

get_state_variable()

AurynState * SpikingGroup::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.

{
        if ( state_variables.find(key) == state_variables.end() ) {
                state_variables[key] = 0.0;
        } 
        return &(state_variables.find(key)->second);
}

get_state_vector()

AurynStateVector * SpikingGroup::get_state_vector

(

std::string

key

)

Creates a new or returns an existing state vector by name.

This function returns a state vector for the given key. If a vector with the key does not exist the function creates one. If it does exist it returns the existing one. The function returns NULL if the statevector would have zero length on that rank.

Parameters

key	The key name of the state vector to be return

Returns

A StateVector matching the key provided.

{
        AurynStateVector * vec = find_state_vector(key);
        if ( vec ) {
                return vec;
        } else {
                return create_state_vector(key);
        }
}

Here is the call graph for this function:

get_uid()

NeuronID SpikingGroup::get_uid

(

)

Get the unique ID of the class.

Returns

a unique numerical identifier of the present SpikingGroup instance.

{
        return unique_id;
}

get_vector_size()

NeuronID SpikingGroup::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.

{
        return calculate_vector_size(get_rank_size());
}

Here is the call graph for this function:

global2rank()

NeuronID auryn::SpikingGroup::global2rank ( NeuronID  i )

inline

Converts global NeuronID within the SpikingGroup to the local NeuronID on this rank.

The return value of global2rank is only defined if the SpikingGroup has units on the present rank.

See also

evolve_locally

Parameters

i	The global NeuronID to convert

Returns

The NeuronID of the referenced neuron on the current rankDoes not

                                                    {
        return i/locked_range;
}

inc_num_spike_attributes()

void SpikingGroup::inc_num_spike_attributes

(

int

x

)

Instructs SpikingGroup to increase the number of spike attributes by x.

The reason we only increment the size is that multiple Connection objects such as STPConnection might want to add an attribute to a spike. These might be different to allow synaptic type dependent plasticity and hence will all have to be transmitted without knowledge about the other synapses which might want to submit a different value.

{
        std::stringstream oss;
        oss << get_log_name() << ":: Registering " << x << " spike attributes." ;
        auryn::logger->msg(oss.str(),VERBOSE);

        delay->inc_num_attributes(x);
}

Here is the call graph for this function:

load_from_file()

bool SpikingGroup::load_from_file ( const char *  filename )

virtual

Reads current states of SpikingGroup to human-readible textfile if implemented in derived class.

{
        if ( !evolve_locally() ) return true;

        std::stringstream oss;
        oss << "Loading SpikingGroup from " << filename;
        auryn::logger->msg(oss.str(),NOTIFICATION);
        
        std::ifstream infile (filename);

        if (!infile) {
                std::stringstream oes;
                oes << "Can't open input file " << filename;
                auryn::logger->msg(oes.str(),ERROR);
                throw AurynOpenFileException();
        }

        NeuronID count = 0;
        char buffer[1024];

        infile.getline (buffer,1024); // skipping header TODO once could make this logic a bit smarter
        infile.getline (buffer,1024); // skipping header 

        boost::archive::text_iarchive ia(infile);
        ia >> *delay;

        infile.getline (buffer,1024); // jumpting to next line

        while ( infile.getline (buffer,1024) )
        {
                load_input_line(count,buffer);
                count++;
        }

        if ( get_rank_size() != count ) {
                // issue warning
                std::stringstream oes;
                oes << "SpikingGroup:: NeuronState file corrupted. Read " 
                        << count << " entries, but " 
                        << get_rank_size() << " expected in " << filename;
                auryn::logger->msg(oes.str(),WARNING);
        }

        infile.close();
        return true;
}

Here is the call graph for this function:

load_input_line()

void SpikingGroup::load_input_line ( NeuronID  i, const char *  buf  )

protectedvirtual

{
                int nums_now, bytes_now;
                int bytes_consumed = 0, nums_read = 0;
                float temp;

                // read the state_vectors
                for ( std::map<std::string,AurynStateVector *>::const_iterator iter = state_vectors.begin() ; 
                        iter != state_vectors.end() ;
                        ++iter ) {
                        if ( iter->first[0] == '_' ) continue; // do not process volatile state_vector
                        if ( ( nums_now = sscanf( buf + bytes_consumed, "%f%n", & temp, & bytes_now ) ) <= 0 )
                        {
                                // error handling
                                auryn::logger->msg("Expected additional fields for single neuron parameters. Corrupted nstate file? Aborting.",ERROR);
                                return;
                        }
                        bytes_consumed += bytes_now;
                        nums_read += nums_now;
                        iter->second->set( i, temp );
                }

                for ( int k = 0 ; k < pretraces.size() ; k++ ) {
                        for ( int l = 0 ; l < get_locked_range() ; ++l ) {
                                if ( ( nums_now = sscanf( buf + bytes_consumed, "%f%n", & temp, & bytes_now ) ) <= 0 )
                                {
                                        // error handling
                                        auryn::logger->msg("Expected additional fields for pretrace values. Corrupted nstate file? Aborting.",ERROR);
                                        return;
                                }
                                bytes_consumed += bytes_now;
                                nums_read += nums_now;
                                NeuronID t = get_locked_range()*(i)+l;
                                if ( t<get_size() )
                                        pretraces[k]->set(t,temp);

                                // std::cout << temp << std::endl;
                        }
                }

                for ( int k = 0 ; k < posttraces.size() ; k++ ) {
                        if ( ( nums_now = sscanf( buf + bytes_consumed, "%f%n", & temp, & bytes_now ) ) <= 0 )
                        {
                                // error handling
                                auryn::logger->msg("Expected additional fields for posttrace values. Corrupted nstate file? Aborting.",ERROR);
                                return;
                        }
                        bytes_consumed += bytes_now;
                        nums_read += nums_now;
                        posttraces[k]->set(i,temp);
                }


                // check if we read all the values on that line
                if ( ( nums_now = sscanf( buf + bytes_consumed, "%f%n", & temp, & bytes_now ) ) > 0 )
                {
                        // error handling
                        auryn::logger->msg("There were unprocessed values in nstatefile.",WARNING);
                }
}

Here is the call graph for this function:

localrank()

bool SpikingGroup::localrank

(

NeuronID

i

)

Checks if the global NeuronID i is integrated on this MPI rank.

Parameters

i	the NeuronID to check.

Returns

true if the neuron with global id i is integrated on the present rank.

                                       {

#ifdef DEBUG
        std::cout << ( (i%locked_range+locked_rank)==mpi_rank ) << " "
                << ( (int) mpi_rank >= locked_rank) << " "
                << ( (int) mpi_rank >= locked_rank) << " "
                << ( (int) mpi_rank < (locked_rank+locked_range) ) << " "
                << ( i/locked_range < get_rank_size() ) << std::endl; 
#endif //DEBUG

        bool t = ( (i%locked_range+locked_rank)==mpi_rank )
                 && (int) mpi_rank >= locked_rank
                 && (int) mpi_rank < (locked_rank+locked_range)
                 && i/locked_range < get_rank_size(); 
        return t; 
}

Here is the call graph for this function:

push_attribute()

void SpikingGroup::push_attribute

(

AurynFloat

attrib

)

Pushes a spike attribute into the axonal SpikeDelay buffer.

This is for instance used to implement short-term plasticity in which each presynaptic spike is associated with a certain currently available amount of presynaptic neurotransmitter. Spike attributes are float values which can be attaced to a spike to convey this information.

{
        attribs->push_back(attrib);
}

push_spike()

void SpikingGroup::push_spike

(

NeuronID

spike

)

Pushes a local NeuronID as spike into the axonal SpikeDelay buffer.

This function expectes the local NeuronID and translates the argument to a global argument.

See also

rank2global, global2rank

Parameters

spike

The NeuronID of the units which spiked in the current timestep

{
        spikes->push_back(rank2global(spike));
}

Here is the call graph for this function:

randomize_state_vector_gauss()

void SpikingGroup::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.

{
        boost::mt19937 ng_gen(seed+mpi_rank); // produces same series every time 
        boost::normal_distribution<> dist((double)mean, (double)sigma);
        boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > die(ng_gen, dist);
        AurynState rv;

        AurynStateVector * vec = get_state_vector(state_vector_name); 


        for ( AurynLong i = 0 ; i<get_rank_size() ; ++i ) {
                rv = die();
                vec->set( i, rv );
        }

}

Here is the call graph for this function:

rank2global()

NeuronID SpikingGroup::rank2global

(

NeuronID

i

)

Converts local NeuronID from the local rank to a global NeuronID.

Parameters

i	The local neuron id.

Returns

The global neuron id.

See also

global2rank

This function performs id translation for parallel simulations from a local rank id to a global NeuronID.

                                             {
        return i*locked_range+(mpi_rank-locked_rank);
}

ranksize()

NeuronID SpikingGroup::ranksize

(

)

Returns size (num of neurons) on the current rank.

                                {
        return get_rank_size();
}

Here is the call graph for this function:

remove_state_vector()

void SpikingGroup::remove_state_vector

(

std::string

key

)

Removes a state vector passed as an argument to the dictinary.

The state vector is not freed automatically!

{
        state_vectors.erase(key);
}

set_clock_ptr()

void SpikingGroup::set_clock_ptr

(

AurynTime *

clock

)

                                                  {
        clock_ptr = clock;
        delay->set_clock_ptr(clock);
}

Here is the call graph for this function:

set_delay()

void SpikingGroup::set_delay

(

int

d

)

Sets axonal delay for this SpikingGroup.

Note the delay needs to be larger er equal to the MINDELAY defined in auryn_definitions.h

{
        if ( d < MINDELAY ) {
                throw AurynDelayTooSmallException();
        }

        axonaldelay = d;

        delay->set_delay(d); // the plus one here takes care of the current timestep

        // spikes  = delay->get_spikes_immediate();
        // attribs = delay->get_attributes_immediate();
}

Here is the call graph for this function:

set_name()

void SpikingGroup::set_name

(

std::string

s

)

Set connection name.

{
        group_name = s;
}

virtual_serialize() [1/2]

void SpikingGroup::virtual_serialize ( boost::archive::binary_oarchive &  ar, const unsigned int  version  )

protectedvirtual

Implementatinon of serialize function for writing.

{
        std::stringstream oss;
        oss << get_log_name() << " serializing delay";
        auryn::logger->msg(oss.str(),VERBOSE);

        ar & size & axonaldelay;
        ar & *delay;

        oss.str("");
        oss << get_log_name() << " serializing " << state_vectors.size() << " state vectors";
        auryn::logger->msg(oss.str(),VERBOSE);
        for ( std::map<std::string,AurynStateVector *>::const_iterator iter = state_vectors.begin() ; 
                        iter != state_vectors.end() ;
                        ++iter ) {
                if ( iter->first[0] == '_' ) continue; // do not process volatile state_vector
                ar & iter->first;
                ar & *(iter->second);
        }

        oss.str("");
        oss << get_log_name() << " serializing " << state_variables.size() << " state variables";
        ar & state_variables;

        oss.str("");
        oss << get_log_name() << " serializing " << pretraces.size() << " pre traces";
        auryn::logger->msg(oss.str(),VERBOSE);
        for ( NeuronID i = 0 ; i < pretraces.size() ; ++i )
                ar & *(pretraces[i]);

        oss.str("");
        oss << get_log_name() << " serializing " << posttraces.size() << " post traces";
        auryn::logger->msg(oss.str(),VERBOSE);
        for ( NeuronID i = 0 ; i < posttraces.size() ; ++i )
                ar & *(posttraces[i]);

        oss.str("");
        oss << get_log_name() << " serializing " << post_state_traces.size() << " post_state traces";
        auryn::logger->msg(oss.str(),VERBOSE);
        for ( NeuronID i = 0 ; i < post_state_traces.size() ; ++i )
                ar & *(post_state_traces[i]);

        oss.str("");
        oss << get_log_name() << " serialize finished for group ";
        auryn::logger->msg(oss.str(),VERBOSE);
}

Here is the call graph for this function:

virtual_serialize() [2/2]

void SpikingGroup::virtual_serialize ( boost::archive::binary_iarchive &  ar, const unsigned int  version  )

protectedvirtual

Implementatinon of serialize function for reading.

{
        std::stringstream oss;
        oss << get_log_name() << " reading delay";
        auryn::logger->msg(oss.str(),VERBOSE);

        ar & size & axonaldelay ; 
        ar & *delay;

        oss.str("");
        oss << get_log_name() << " reading " << state_vectors.size() << " state vectors";
        auryn::logger->msg(oss.str(),VERBOSE);
        for ( std::map<std::string,AurynStateVector *>::const_iterator iter = state_vectors.begin() ; 
                        iter != state_vectors.end() ;
                        ++iter ) {
                if ( iter->first[0] == '_' ) continue; // do not process volatile state_vector
                std::string key;
                ar & key;
                AurynStateVector * vect = find_state_vector(key);
                ar & *vect;
        }

        oss.str("");
        oss << get_log_name() << " reading " << state_variables.size() << " state variables";
        ar & state_variables; 

        oss.str("");
        oss << get_log_name() << " reading " << pretraces.size() << " pre traces";
        auryn::logger->msg(oss.str(),VERBOSE);
        for ( NeuronID i = 0 ; i < pretraces.size() ; ++i )
                ar & *(pretraces[i]);

        oss.str("");
        oss << get_log_name() << " reading " << posttraces.size() << " post traces";
        auryn::logger->msg(oss.str(),VERBOSE);
        for ( NeuronID i = 0 ; i < posttraces.size() ; ++i )
                ar & *(posttraces[i]);

        oss.str("");
        oss << get_log_name() << " reading " << post_state_traces.size() << " post_state_traces";
        auryn::logger->msg(oss.str(),VERBOSE);
        for ( NeuronID i = 0 ; i < post_state_traces.size() ; ++i )
                ar & *(post_state_traces[i]);

        oss.str("");
        oss << get_log_name() << " serialize finished for group ";
        auryn::logger->msg(oss.str(),VERBOSE);
}

Here is the call graph for this function:

write_to_file()

bool SpikingGroup::write_to_file ( const char *  filename )

virtual

Writes current states of SpikingGroup to human-readible textfile if implemented in derived class.

{
        if ( !evolve_locally() ) return true;

        std::ofstream outfile;
        outfile.open(filename,std::ios::out);
        if (!outfile) {
                std::cerr << "Can't open output file " << filename << std::endl;
          throw AurynOpenFileException();
        }

        outfile << "# Auryn SpikingGroup state file for n="<< get_rank_size() <<" neurons" << std::endl;
        outfile << "# Default field order (might be overwritten): ";
        for ( std::map<std::string,AurynStateVector *>::const_iterator iter = state_vectors.begin() ; 
                        iter != state_vectors.end() ;
                        ++iter ) {
                if ( iter->first[0] == '_' ) continue; // do not process volatile state_vector
                outfile << std::scientific << iter->first << " ";
        }
        outfile << "(plus traces)";
        outfile << std::endl;


        boost::archive::text_oarchive oa(outfile);
        oa << *(delay); 
        outfile << std::endl;

        for ( NeuronID i = 0 ; i < get_rank_size() ; ++i ) 
        {
                outfile << get_output_line(i);
        }

        outfile.close();
        return true;
}

Here is the call graph for this function:

Friends And Related Function Documentation

boost::serialization::access

friend class boost::serialization::access

friend

Member Data Documentation

active

bool auryn::SpikingGroup::active

Toggles group active.

Groups do not necessarily obey this toggle though.

attribs

AttributeContainer* auryn::SpikingGroup::attribs

protected

clock_ptr

AurynTime * SpikingGroup::clock_ptr = NULL

staticprotected

Stores the length of output delay

delay

SpikeDelay* auryn::SpikingGroup::delay

group_name

std::string auryn::SpikingGroup::group_name

protected

Identifying name for object.

post_state_traces

std::vector<Trace *> auryn::SpikingGroup::post_state_traces

protected

Post state traces.

post_state_traces_spike_biases

std::vector<AurynFloat> auryn::SpikingGroup::post_state_traces_spike_biases

protected

post_state_traces_states

std::vector<AurynStateVector *> auryn::SpikingGroup::post_state_traces_states

protected

posttraces

std::vector<Trace *> auryn::SpikingGroup::posttraces

protected

Posttraces.

pretraces

std::vector<Trace *> auryn::SpikingGroup::pretraces

protected

Pretraces.

rank_size

NeuronID auryn::SpikingGroup::rank_size

protected

Stores the size of the group on this rank.

size

NeuronID auryn::SpikingGroup::size

protected

Stores the size of the group.

spikes

SpikeContainer* auryn::SpikingGroup::spikes

protected

SpikeContainers to store spikes produced during one step of evolve.

state_variables

std::map<std::string,AurynState> auryn::SpikingGroup::state_variables

Holds group-wide state variables such as population target rates or global protein levels etc

state_vectors

std::map<std::string,AurynStateVector *> auryn::SpikingGroup::state_vectors

Can hold single neuron vectors such as target rates or STP states etc

---

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

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