auryn::PatternMonitor Class Reference

Monitor class to record population firing rates. More...

#include <PatternMonitor.h>

Inheritance diagram for auryn::PatternMonitor:

Collaboration diagram for auryn::PatternMonitor:

Public Member Functions
	PatternMonitor (SpikingGroup *source, string filename, string patfile, NeuronID maximum_patterns=10, AurynFloat binsize=1e-1)
	PatternMonitor (SpikingGroup *source, string filename, StimulusGroup *stimgroup, NeuronID maximum_patterns=10, AurynFloat binsize=1e-1)
virtual	~PatternMonitor ()
void	execute ()
void	load_patterns (string filename)

Protected Member Functions
void	init (SpikingGroup *source, string filename, NeuronID maximum_patterns, AurynFloat binsize)
virtual void	virtual_serialize (boost::archive::binary_oarchive &ar, const unsigned int version)
virtual void	virtual_serialize (boost::archive::binary_iarchive &ar, const unsigned int version)
Protected Member Functions inherited from auryn::Monitor
virtual void	open_output_file (std::string filename)
virtual void	flush ()
	Flush to file. More...
	Monitor (std::string filename, std::string default_extension="dat")
	Standard constructor with file name. More...
	Monitor ()
	Constructor which does not open a text file for output. More...
std::string	generate_filename (std::string name_hint="")
	Generates a default filename from the device ID. More...
virtual	~Monitor ()
	Standard destructor. More...
Protected Member Functions inherited from auryn::Device
void	init ()
	Standard initializer to be called by the constructor. More...
	Device ()
	Standard constructor. More...
void	set_name (std::string s)
	Set device name. More...
std::string	get_name ()
	Get device name. More...
int	get_id ()
	Get numeric device id. More...
virtual	~Device ()
	Standard destructor. More...
virtual void	evolve ()

Protected Attributes
SpikingGroup *	src
Protected Attributes inherited from auryn::Monitor
std::ofstream	outfile
std::string	fname
std::string	default_file_extension
bool	active
	Standard active switch. More...
Protected Attributes inherited from auryn::Device
std::string	device_name
	Identifying name for device. More...
bool	active
	Standard active switch. More...

Detailed Description

Monitor class to record population firing rates.

Instances of this class record the population firing rate of the src SpikingGroup assigned. Binning is done discretely in bins of size bsize that is directly transformed in discrete AurynTime steps.

Constructor & Destructor Documentation

PatternMonitor() [1/2]

PatternMonitor::PatternMonitor	(	SpikingGroup *	source,
		std::string	filename,
		std::string	patfile,
		NeuronID	maximum_patterns = 10,
		AurynFloat	binsize = 1e-1
	)

Default Constructor

Parameters

                                                                                                                                          : Monitor(filename)
{
        init(source,filename,maximum_patterns,binsize);
        load_patterns(patfile);
}

Here is the call graph for this function:

PatternMonitor() [2/2]

PatternMonitor::PatternMonitor	(	SpikingGroup *	source,
		std::string	filename,
		StimulusGroup *	stimgroup,
		NeuronID	maximum_patterns = 10,
		AurynFloat	binsize = 1e-1
	)

Constructor that loads patterns from a StimulusGroup

Parameters

                                                                                                                                                  : Monitor(filename)
{
        init(source,filename,maximum_patterns,binsize);
        delete patterns;
        linked_to_stimgroup = true;
        patterns = stimgroup->get_patterns();

        std::stringstream oss;
        oss << "PatternMonitor:: Linked to StimulusGroup";
        auryn::logger->msg(oss.str(),NOTIFICATION);
}

Here is the call graph for this function:

~PatternMonitor()

PatternMonitor::~PatternMonitor ( )

virtual

Default Destructor

{
        delete [] counter;
        if ( !linked_to_stimgroup )
                delete patterns;
}

Member Function Documentation

execute()

void PatternMonitor::execute ( )

virtual

Implementation of necessary execute() function.

Reimplemented from auryn::Device.

{
        if ( src->evolve_locally() ) {
                for ( SpikeContainer::const_iterator iter = src->get_spikes_immediate()->begin() ;
                                iter != src->get_spikes_immediate()->end() ; ++iter ) {
                        counter[src->global2rank(*iter)] += 1; // might be more memory efficent to count here in rankIDs (local)
                }

                if (auryn::sys->get_clock()%ssize==0) {
                        outfile << auryn_timestep*(auryn::sys->get_clock());
                        for ( std::vector<type_pattern>::iterator pattern = patterns->begin() ; 
                                        pattern != patterns->end() ; ++pattern ) { 
                                double sum = 0.;
                                for ( type_pattern::iterator piter = pattern->begin() ; piter != pattern->end() ; ++piter ) {
                                        if ( counter[piter->i] > 0 ) {
                                                sum += counter[piter->i];
                                        }
                                }
                                double mean = sum/pattern->size();
                                outfile << " " << mean/bsize;
                        }

                        outfile << "\n"; //newline

                        // reset counter
                        for ( NeuronID i = 0 ; i < src->get_rank_size() ; ++i )
                                counter[i] = 0;
                }
        }
}

Here is the call graph for this function:

init()

void PatternMonitor::init ( SpikingGroup *  source, std::string  filename, NeuronID  maximum_patterns, AurynFloat  binsize  )

protected

Default init method

{
        auryn::sys->register_device(this);

        linked_to_stimgroup = false;

        src = source;
        bsize = binsize;
        ssize = bsize/auryn_timestep;
        if ( ssize < 1 ) ssize = 1;

        maxpat = maximum_patterns;

        counter = new  NeuronID [src->get_rank_size()];
        patterns = new std::vector<type_pattern>;

        for ( NeuronID i = 0 ; i < src->get_rank_size() ; ++i )
                counter[i] = 0;

        std::stringstream oss;
        oss << "PatternMonitor:: Setting binsize " << bsize << "s";
        auryn::logger->msg(oss.str(),NOTIFICATION);

        outfile << std::setiosflags(std::ios::fixed) << std::setprecision(6);
}

Here is the call graph for this function:

load_patterns()

void PatternMonitor::load_patterns

(

std::string

filename

)

Load patterns from file

{

                // if ( not src->evolve_locally() ) return ;

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

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

        type_pattern pattern;
        int total_pattern_size = 0;
        while( !fin.eof() && patterns->size() < maxpat ) {

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

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

                                patterns->push_back(pattern);
                                pattern.clear();
                                total_pattern_size = 0;
                        }
                        continue;
                }

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

        fin.close();

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

Here is the call graph for this function:

virtual_serialize() [1/2]

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

protectedvirtual

Functions necesssary for serialization and loading saving to netstate files.

Reimplemented from auryn::Monitor.

{
        for ( NeuronID i = 0 ; i < src->get_rank_size() ; ++i )
                ar & counter[i] ;
}

Here is the call graph for this function:

virtual_serialize() [2/2]

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

protectedvirtual

Reimplemented from auryn::Monitor.

{
        for ( NeuronID i = 0 ; i < src->get_rank_size() ; ++i )
                ar & counter[i] ;
}

Here is the call graph for this function:

Member Data Documentation

src

SpikingGroup* auryn::PatternMonitor::src

protected

The source SpikingGroup

---

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

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