auryn::PatternStimulator Class Reference

Stimulator class to inject timeseries of currents to patterns (subpopulations) of neurons. More...

#include <PatternStimulator.h>

Inheritance diagram for auryn::PatternStimulator:

Collaboration diagram for auryn::PatternStimulator:

Public Member Functions
	PatternStimulator (NeuronGroup *target, string filename, string patfile="", AurynFloat scale=1, NeuronID maximum_patterns=10)
virtual	~PatternStimulator ()
void	set_scale (AurynFloat scale)
AurynFloat	get_scale ()
void	propagate ()
void	load_patterns (string filename)
void	load_1_pattern ()

Protected Member Functions
void	init (NeuronGroup *target, string filename, AurynFloat scale, NeuronID maximum_patterns)
Protected Member Functions inherited from auryn::Monitor
virtual void	open_output_file (std::string filename)
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)
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 ()
virtual void	execute ()

Protected Attributes
NeuronGroup *	dst
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

Stimulator class to inject timeseries of currents to patterns (subpopulations) of neurons.

Instances of this class inject currents that vary over time to subpopulations of the NeuronGroup assigned.

Constructor & Destructor Documentation

PatternStimulator()

PatternStimulator::PatternStimulator	(	NeuronGroup *	target,
		std::string	filename,
		std::string	patfile = "",
		AurynFloat	scale = 1,
		NeuronID	maximum_patterns = 10
	)

Default Constructor

Parameters

                                                                                                                                             : Monitor( "" )
{
        init(target,filename,scale,maximum_patterns);
        std::string s = patfile;
        if ( s.empty() ) {
                std::stringstream oss;
                auryn::logger->msg("No patfile given assuming whole population",NOTIFICATION);
                load_1_pattern();
        } else {
                load_patterns(patfile);
        }
}

Here is the call graph for this function:

~PatternStimulator()

PatternStimulator::~PatternStimulator ( )

virtual

Default Destructor

{
        timeseriesfile.close();
        delete patterns;
        delete currents;
        delete newcurrents;
}

Member Function Documentation

get_scale()

AurynFloat PatternStimulator::get_scale

(

)

                                        {
        return scl;
}

init()

void PatternStimulator::init ( NeuronGroup *  target, std::string  filename, AurynFloat  scale, NeuronID  maximum_patterns  )

protected

Default init method

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

        dst = target;
        set_scale(scale);
        maxpat = maximum_patterns;

        patterns = new std::vector<type_pattern>;

        mem = dst->mem;

        filetime = 0;
        timeseriesfile.open(filename.c_str(),std::ios::in);
        if (!timeseriesfile) {
          std::stringstream oss;
          oss << "Can't open time series file " << filename;
          auryn::logger->msg(oss.str(),ERROR);
          exit(1);
        }

}

Here is the call graph for this function:

load_1_pattern()

void PatternStimulator::load_1_pattern

(

)

Loads the 1111 pattern

{
        type_pattern pattern;
        for ( unsigned int i = 0 ; i < dst->get_rank_size() ; ++i ) {
                pattern_member pm;
                pm.i = i;
                pm.gamma = 1 ; 
                pattern.push_back( pm ) ;
        }
        patterns->push_back(pattern);
        currents = new AurynState[1];
        newcurrents = new AurynState[1];
        currents[0] = 0;
        newcurrents[0] = 0;
}

Here is the call graph for this function:

load_patterns()

void PatternStimulator::load_patterns

(

std::string

filename

)

Load patterns from file

{
        std::ifstream fin (filename.c_str());
        if (!fin) {
                std::stringstream oss;
                oss << "PatternStimulator:: "
                << "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 << "PatternStimulator:: 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 ( dst->localrank( i ) ) {
                        pattern_member pm;
                        pm.gamma = 1 ; 
                        iss >>  pm.gamma ;
                        pm.i = dst->global2rank( i ) ;
                        pattern.push_back( pm ) ;
                }
                total_pattern_size++;
        }

        fin.close();

        currents = new AurynState[patterns->size()];
        newcurrents = new AurynState[patterns->size()];
        for ( unsigned int i = 0 ; i < patterns->size() ; ++i ) {
                newcurrents[i] = 0;
                currents[i] = 0;
        }

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

Here is the call graph for this function:

propagate()

void PatternStimulator::propagate

(

)

Implementation of necessary propagate() function.

{
        if ( dst->evolve_locally() ) {

                char buffer[256]; 
                std::string line;
                while( !timeseriesfile.eof() && filetime < auryn::sys->get_clock() ) {
                        line.clear();
                        timeseriesfile.getline (buffer,255); 
                        // TODO This buffer can quickly become too small of read lots of columns
                        // Instead this section should be re-written to directly read one token/column 
                        // at a time in the loop below. Just making the buffer size large should be avoided 
                        // not to risk buffer overflow or unecessarily large memory consumption on cluster
                        // machines with limited resources.
                        line = buffer;
                        if (line[0] == '#') continue;
                        std::stringstream iss (line);
                        double time;
                        iss >> time;
                        filetime = time/auryn_timestep;

                        for ( unsigned int column = 0 ; column < patterns->size() ; ++column ) {
                                float cur;
                                iss >> cur ;
                                currents[column] = newcurrents[column];
                                newcurrents[column] = cur;
                        }
                }

                AurynState * cur_iter = currents;
                for ( std::vector<type_pattern>::const_iterator pattern = patterns->begin() ; 
                                pattern != patterns->end() ; ++pattern ) { 
                        for ( type_pattern::const_iterator piter = pattern->begin() ; piter != pattern->end() ; ++piter ) {
                                mem->data[piter->i] += *cur_iter * piter->gamma * scl * auryn_timestep;
                        }
                        ++cur_iter;
                }
        }
}

Here is the call graph for this function:

set_scale()

void PatternStimulator::set_scale

(

AurynFloat

scale

)

                                                  {
        scl = scale;
}

Member Data Documentation

dst

NeuronGroup* auryn::PatternStimulator::dst

protected

The target NeuronGroup

---

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

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