auryn::System Class Reference

Class that implements system wide variables and methods to manage and run simulations. More...

#include <System.h>

Collaboration diagram for auryn::System:

Public Member Functions
	System (mpi::communicator *communicator)
	Default constructor for MPI enabled. More...
void	set_simulation_name (std::string name)
	Sets the simulation name. More...
std::string	get_simulation_name ()
	Returns the simulation name. More...
void	set_output_dir (std::string path)
	Set output dir for fn function. More...
virtual	~System ()
void	set_online_rate_monitor_target (SpikingGroup *group=NULL)
	Sets the target group for online rate estimate. More...
void	set_online_rate_monitor_id (unsigned int id=0)
	Sets the SpikingGroup used to display the rate estimate in the progressbar. More...
void	set_online_rate_monitor_tau (AurynDouble tau=100e-3)
	Sets the timeconstant to compute the online rate average for the status bar. More...
double	get_last_elapsed_time ()
	Returns last elapsed time in seconds. More...
double	get_total_elapsed_time ()
	Returns total elapsed time in seconds. More...
void	save_network_state (std::string basename)
	Saves network state to a netstate file. More...
void	load_network_state (std::string basename)
	Loads network state from a netstate file. More...
void	save_network_state_text (std::string basename)
	Saves the network state to human readable text files. More...
void	flush_devices ()
	Flush devices. More...
void	register_spiking_group (SpikingGroup *spiking_group)
	Registers an instance of SpikingGroup to the spiking_groups vector. More...
void	register_connection (Connection *connection)
	Registers an instance of Connection to the connections vector. More...
void	register_device (Device *device)
	Registers an instance of Device to the devices vector. More...
void	register_checker (Checker *checker)
	Registers an instance of Checker to the checkers vector. More...
bool	run (AurynFloat simulation_time, bool checking=true)
	Runs a simulation for a given amount of time. More...
bool	run_chunk (AurynFloat chunk_time, AurynFloat interval_start, AurynFloat interval_end, bool checking=true)
	Runs simulation for a given amount of time. More...
AurynDouble	get_time ()
	Gets the current system time in [s]. More...
AurynTime	get_clock ()
	Gets the current clock value in AurynTime. More...
AurynTime *	get_clock_ptr ()
	Gets a pointer to the current clock. More...
AurynLong	get_total_neurons ()
	Get total number of registered neurons. More...
AurynDouble	get_total_effective_load ()
	Get total effective load. More...
AurynLong	get_total_synapses ()
	Get total number of registered synapses. More...
string	fn (std::string extension)
	Format output file name. More...
string	fn (std::string name, std::string extension)
	Format output file name. More...
string	fn (std::string name, NeuronID index, std::string extension)
	Format output file name. More...
mpi::communicator *	get_com ()
	Returns global mpi communicator. More...
unsigned int	mpi_size ()
	Returns number of ranks. More...
unsigned int	mpi_rank ()
	Returns current rank. More...
void	set_master_seed (unsigned int seed=123)
	Set master seed. More...
unsigned int	get_seed ()
	Returns a random seed which is different on each rank. More...
unsigned int	get_synced_seed ()
	Returns a random seed which is the same on each rank. More...

Public Attributes
bool	quiet
	Switch to turn output to quiet mode (no progress bar). More...
AurynVersion	build
	Version info. More...
unsigned int	progressbar_update_interval
	The progressbar update interval in timesteps of auryn_timestep. More...

Detailed Description

Class that implements system wide variables and methods to manage and run simulations.

This Class contains methods to manage and run sets of classes that make up the simulation. In particular it distinguishes between constituents of types SpikingGroup, Connection, Monitor and Checker. A MPI implementation should implement communicators and all that stuff in here. All the constituent object of a single simulation are stored in STL vectors. The methods evolve() and propagate() from each object in these vectors are called alternatingly from within the run procedure.

Constructor & Destructor Documentation

System()

System::System

(

mpi::communicator *

communicator

)

Default constructor for MPI enabled.

{

        mpicom = communicator;
        init();


        std::stringstream oss;
        if ( mpi_size() > 1 ) {
                oss << "This is an MPI run. I am rank "
                        <<  mpi_rank() << " of a total of "
                        <<  mpi_size() << " ranks.";
                auryn::logger->msg(oss.str(),NOTIFICATION);
        } else {
                auryn::logger->msg("Not running a parallel simulation.",NOTIFICATION);
        }

        if ( mpi_size() > 0 && (mpi_size() & (mpi_size()-1)) ) {
                oss.str("");
                oss << "WARNING! The number of processes is not a power of two. "
                        << "This causes impaired performance or even crashes "
                        << "in some MPI implementations.";
                auryn::logger->msg(oss.str(),WARNING,true);
        }
}

Here is the call graph for this function:

~System()

System::~System ( )

virtual

{
        free();
}

Here is the call graph for this function:

Member Function Documentation

flush_devices()

void System::flush_devices

(

)

Flush devices.

Write monitor data buffers to file.

{
        for ( unsigned int i = 0 ; i < devices.size() ; ++i )
                devices[i]->flush();
}

fn() [1/3]

string System::fn

(

std::string

extension

)

Format output file name.

Formats output files according to the following convention: <outputdir>/<name>.<rank>.<extension> where <name> is taken from System->get_name() and returns it as a c string;

{
        return fn(get_simulation_name(), extension);
}

Here is the call graph for this function:

fn() [2/3]

string System::fn	(	std::string	name,
		std::string	extension
	)

Format output file name.

Formats output files according to the following convention: <outputdir>/<name>.<rank>.<extension> and returns it as a c string;

{
        std::stringstream oss;
        oss << outputdir << "/" << name
        << "." << mpi_rank()
        << "." << extension;
        return oss.str();
}

Here is the call graph for this function:

fn() [3/3]

string System::fn	(	std::string	name,
		NeuronID	index,
		std::string	extension
	)

Format output file name.

Formats output files according to the following convention: <outputdir>/<name><index>.<rank>.<extension> and returns it as a c string;

{
        std::stringstream oss;
        oss << outputdir << "/" 
                << name
                << index
                << "." << mpi_rank()
                << "." << extension;
        return oss.str();
}

Here is the call graph for this function:

get_clock()

AurynTime System::get_clock

(

)

Gets the current clock value in AurynTime.

{
        return clock;
}

get_clock_ptr()

AurynTime * System::get_clock_ptr

(

)

Gets a pointer to the current clock.

{
        return &clock;
}

get_com()

mpi::communicator * System::get_com

(

)

Returns global mpi communicator.

{
        return mpicom;
}

get_last_elapsed_time()

AurynDouble System::get_last_elapsed_time

(

)

Returns last elapsed time in seconds.

{
        return last_elapsed_time;
}

get_seed()

unsigned int System::get_seed

(

)

Returns a random seed which is different on each rank.

{
        return (*seed_die)();
}

get_simulation_name()

std::string System::get_simulation_name

(

)

Returns the simulation name.

{
        return simulation_name;
}

get_synced_seed()

unsigned int System::get_synced_seed

(

)

Returns a random seed which is the same on each rank.

Can be used to synchronize randomness across ranks StimulusGroup etc

{
        unsigned int value;
        if ( mpi_rank() == 0 ) value = get_seed();
#ifdef AURYN_CODE_USE_MPI
        broadcast(*mpicom, value, 0);
#endif // AURYN_CODE_USE_MPI
        // std::cout << mpi_rank() << " " << value << std::endl;
        return value;
}

Here is the call graph for this function:

get_time()

AurynDouble System::get_time

(

)

Gets the current system time in [s].

{
        return auryn_timestep * clock;
}

get_total_effective_load()

AurynDouble auryn::System::get_total_effective_load

(

)

Get total effective load.

get_total_elapsed_time()

AurynDouble System::get_total_elapsed_time

(

)

Returns total elapsed time in seconds.

{
        time_t t_now ;
        time(&t_now);
        double elapsed  = difftime(t_now,t_sys_start);
        return elapsed;
}

get_total_neurons()

AurynLong System::get_total_neurons

(

)

Get total number of registered neurons.

{
        AurynLong sum = 0;
        std::vector<SpikingGroup *>::const_iterator iter;
        for ( iter = spiking_groups.begin() ; iter != spiking_groups.end() ; ++iter ) {
                sum += (*iter)->get_rank_size(); 
        }
        return sum;
}

get_total_synapses()

AurynLong System::get_total_synapses

(

)

Get total number of registered synapses.

{
        AurynLong sum = 0;
        std::vector<Connection *>::const_iterator iter;
        for ( iter = connections.begin() ; iter != connections.end() ; ++iter ) {
                sum += (*iter)->get_nonzero(); 
        }
        return sum;
}

load_network_state()

void System::load_network_state

(

std::string

basename

)

Loads network state from a netstate file.

Parameters

basename

(directory and prefix of file) of the netstate file without extension

{
        auryn::logger->msg("Loading network state", NOTIFICATION);


        std::string netstate_filename;
        {
                std::stringstream oss;
                oss << basename
                        << "." << mpi_rank()
                        << ".netstate";
                netstate_filename = oss.str();
        } // oss goes out of focus

        std::ifstream ifs(netstate_filename.c_str());

        if ( !ifs.is_open() ) {
                std::stringstream oss;
                oss << "Error opening netstate file: "
                        << netstate_filename;
                auryn::logger->msg(oss.str(),ERROR);
                throw AurynOpenFileException();
        }

        boost::archive::binary_iarchive ia(ifs);


        // verify simulator version information 
        bool pass_version = true;
        int tmp_version;
        ia >> tmp_version;
        pass_version = pass_version && build.version==tmp_version;
        ia >> tmp_version;
        pass_version = pass_version && build.subversion==tmp_version;
        ia >> tmp_version;
        pass_version = pass_version && build.revision_number==tmp_version;

        if ( !pass_version ) {
                auryn::logger->msg("WARNING: Version check failed! Current Auryn version " 
                                "does not match the version which created the file. "
                                "This could pose a problem. " 
                                "Proceed with caution!" ,WARNING);
        }

        // verify communicator information 
        bool pass_comm = true;
        unsigned int tmp_int;
        ia >> tmp_int;
        pass_comm = pass_comm && (tmp_int == mpi_size());
        ia >> tmp_int;
        pass_comm = pass_comm && (tmp_int == mpi_rank());

        if ( !pass_comm ) {
                auryn::logger->msg("ERROR: Communicator size or rank do not match! "
                                "Presumably you are trying to load the network "
                                "state netstate from a simulation which was run "
                                "on a different number of cores." ,ERROR);
        }  

        auryn::logger->msg("Loading connections ...",VERBOSE);
        for ( unsigned int i = 0 ; i < connections.size() ; ++i ) {

                std::stringstream oss;
                oss << "Loading connection "
                        <<  i 
                        << ": " 
                        << connections[i]->get_name();
                auryn::logger->msg(oss.str(),VERBOSE);

                ia >> *(connections[i]);
                connections[i]->finalize();
        }

        auryn::logger->msg("Loading SpikingGroups ...",VERBOSE);
        for ( unsigned int i = 0 ; i < spiking_groups.size() ; ++i ) {

                std::stringstream oss;
                oss << "Loading group "
                        <<  i 
                        << ": "
                        << spiking_groups[i]->get_name();
                auryn::logger->msg(oss.str(),VERBOSE);

                ia >> *(spiking_groups[i]);
        }

        // Loading Devices states
        auryn::logger->msg("Loading Devices ...",VERBOSE);
        for ( unsigned int i = 0 ; i < devices.size() ; ++i ) {

                std::stringstream oss;
                oss << "Loading Device "
                        <<  i;
                auryn::logger->msg(oss.str(),VERBOSE);

                ia >> *(devices[i]);
        }

        
        auryn::logger->msg("Loading Checkers ...",VERBOSE);
        for ( unsigned int i = 0 ; i < checkers.size() ; ++i ) {

                std::stringstream oss;
                oss << "Loading Checker "
                        <<  i;
                auryn::logger->msg(oss.str(),VERBOSE);

                ia >> *(checkers[i]);
        }

        ifs.close();
}

Here is the call graph for this function:

mpi_rank()

unsigned int System::mpi_rank

(

)

Returns current rank.

like mpicom->rank(), but also defined when run without mpi.

{
        return mpi_rank_;
}

mpi_size()

unsigned int System::mpi_size

(

)

Returns number of ranks.

like mpicom->size(), but also defined when run without mpi.

{
        return mpi_size_;
}

register_checker()

void System::register_checker

(

Checker *

checker

)

Registers an instance of Checker to the checkers vector.

Note: The first checker that is registered is by default used by System for the rate output in the progress bar. Called internally by constructor of Monitor.

{
        checkers.push_back(checker);
}

Here is the call graph for this function:

register_connection()

void System::register_connection

(

Connection *

connection

)

Registers an instance of Connection to the connections vector.

Called internally by constructor of Connection.

{
        connections.push_back(connection);
}

register_device()

void System::register_device

(

Device *

device

)

Registers an instance of Device to the devices vector.

Called internally by constructor of Monitor.

{
        devices.push_back(device);
}

register_spiking_group()

void System::register_spiking_group

(

SpikingGroup *

spiking_group

)

Registers an instance of SpikingGroup to the spiking_groups vector.

Called internally by constructor of SpikingGroup.

{
        spiking_groups.push_back(spiking_group);
        spiking_group->set_clock_ptr(get_clock_ptr());
}

Here is the call graph for this function:

run()

bool System::run	(	AurynFloat	simulation_time,
		bool	checking = true
	)

Runs a simulation for a given amount of time.

Parameters

simulation_time	time to run the simulation in seconds.
checking	true if checkers can break the run (e.g. if a frequency get's to high and the network explodes)

Returns

bool true on success

{
        if ( simulation_time < 0.0 ) {
                logger->error("Negative run time not allowed.");
                return false;
        }

        // throw an exception if the stoptime is post the range of AurynTime
        if ( get_time() + simulation_time > std::numeric_limits<AurynTime>::max()*auryn_timestep ) {
                auryn::logger->msg("The requested simulation time exceeds the number of possible timesteps limited by AurynTime datatype.",ERROR);
                throw AurynTimeOverFlowException();
        }

        AurynTime starttime = get_clock();
        AurynTime stoptime = get_clock() + (AurynTime) (simulation_time/auryn_timestep);

        return run(starttime, stoptime, simulation_time, checking);
}

Here is the call graph for this function:

run_chunk()

bool System::run_chunk	(	AurynFloat	chunk_time,
		AurynFloat	interval_start,
		AurynFloat	interval_end,
		bool	checking = true
	)

Runs simulation for a given amount of time.

Exposes the interface to the progressbar params. Can be used to run a single progress bar, but cut it in different chunks to turn on and off stuff in the simulation without perturbing the output. interval_start and end define the total duration of the simulation (this is used to build the progress bar, while chung_time is the actual time that is simulated for each call.

{
        AurynTime stopclock = get_clock()+chunk_time/auryn_timestep;

        // throw an exception if the stoptime is post the range of AurynTime
        if ( interval_end > std::numeric_limits<AurynTime>::max()*auryn_timestep ) {
                auryn::logger->msg("The requested simulation time exceeds the number of possible timesteps limited by AurynTime datatype.",ERROR);
                throw AurynTimeOverFlowException();
        }

        return run(interval_start/auryn_timestep, stopclock, (interval_end-interval_start), checking);
}

Here is the call graph for this function:

save_network_state()

void System::save_network_state

(

std::string

basename

)

Saves network state to a netstate file.

This function saves the network state to one serialized file. The network state includes the internal state variables of all neurons and the synaptic connections. It currently does not save the state of any random number generators (v0.5) but this is planned to change in the future. Note that netstate files do not contain any parameters either. This was done to allow to run a simulation with a certain parameter set for a given amount of time. Save the network state and then continue the simulation from that point with a changed parameter set (e.g. a new stimulus set or similar).

Parameters

basename

(including directory path) of the netstate file without extension

{
        auryn::logger->msg("Saving network state", NOTIFICATION);

        std::string netstate_filename;
        {
                std::stringstream oss;
                oss << outputdir 
                        << "/" << basename
                        << "." << mpi_rank()
                        << ".netstate";
                netstate_filename = oss.str();
        } // oss goes out of focus

        auryn::logger->msg("Opening output stream ...",VERBOSE);
        std::ofstream ofs(netstate_filename.c_str());
        boost::archive::binary_oarchive oa(ofs);
        
        auryn::logger->msg("Saving version information ...",VERBOSE);
        // save simulator version information 
        oa << build.version;
        oa << build.subversion;
        oa << build.revision_number;

        auryn::logger->msg("Saving communicator information ...",VERBOSE);
        // save communicator information 
        unsigned int tmp_int = mpi_size();
        oa << tmp_int;
        tmp_int = mpi_rank();
        oa << tmp_int;


        auryn::logger->msg("Saving Connections ...",VERBOSE);
        for ( unsigned int i = 0 ; i < connections.size() ; ++i ) {

                std::stringstream oss;
                oss << "Saving connection "
                        <<  i 
                        << " '"
                        << connections[i]->get_name()
                        << "' "
                        << " to stream";
                auryn::logger->msg(oss.str(),VERBOSE);

                oa << *(connections[i]);
        }

        auryn::logger->msg("Saving SpikingGroups ...",VERBOSE);
        for ( unsigned int i = 0 ; i < spiking_groups.size() ; ++i ) {

                std::stringstream oss;
                oss << "Saving SpikingGroup "
                        <<  i 
                        << " ("
                        << spiking_groups[i]->get_name()
                        << ")"
                        << " to stream";
                auryn::logger->msg(oss.str(),VERBOSE);

                oa << *(spiking_groups[i]);
        }

        // Save Devices
        auryn::logger->msg("Saving Devices ...",VERBOSE);
        for ( unsigned int i = 0 ; i < devices.size() ; ++i ) {

                std::stringstream oss;
                oss << "Saving Device "
                        <<  i 
                        << " to stream";
                auryn::logger->msg(oss.str(),VERBOSE);

                oa << *(devices[i]);
        }

        auryn::logger->msg("Saving Checkers ...",VERBOSE);
        for ( unsigned int i = 0 ; i < checkers.size() ; ++i ) {

                std::stringstream oss;
                oss << "Saving Checker "
                        <<  i 
                        << " to stream";
                auryn::logger->msg(oss.str(),VERBOSE);

                oa << *(checkers[i]);
        }

        ofs.close();
}

Here is the call graph for this function:

save_network_state_text()

void System::save_network_state_text

(

std::string

basename

)

Saves the network state to human readable text files.

This deprecated method of saving the network state generates a large number of files because each Connection object or SpikingGroup creates their own respective file. This function might still be useful if you have code in which you analaze these files offline. In most cases you will want to use save_network_state and only dump a limited subset (e.g. all the plastic connections) in human-readable text files for analysis.

Parameters

Basename

(directory and prefix of file) of the netstate file without extension

{
        auryn::logger->msg("Saving network state to textfile", NOTIFICATION);

        char filename [255];
        for ( unsigned int i = 0 ; i < connections.size() ; ++i ) {
                sprintf(filename, "%s.%d.%d.wmat", basename.c_str(), i, mpi_rank());

                std::stringstream oss;
                oss << "Saving connection "
                        <<  filename ;
                auryn::logger->msg(oss.str(),VERBOSE);

                connections[i]->write_to_file(filename);
        }

        for ( unsigned int i = 0 ; i < spiking_groups.size() ; ++i ) {
                sprintf(filename, "%s.%d.%d.gstate", basename.c_str(), i, mpi_rank());

                std::stringstream oss;
                oss << "Saving group "
                        <<  filename ;
                auryn::logger->msg(oss.str(),VERBOSE);

                spiking_groups[i]->write_to_file(filename);
        }
}

Here is the call graph for this function:

set_master_seed()

void System::set_master_seed

(

unsigned int

seed = 123

)

Set master seed.

Set the master seed from which other seeds are drawn. When the master seed is set to 0 a master seed is generated from ctime and will be different at each run.

{
        if ( seed == 0 ) {
                seed = static_cast<unsigned int>(std::time(0));
        }

        const unsigned int master_seed_multiplier = 257;
        const unsigned int rank_master_seed = seed*master_seed_multiplier*(mpi_rank()+1);

        std::stringstream oss;
        oss << "Seeding this rank with master seed " << rank_master_seed;
        auryn::logger->msg(oss.str(),INFO);

        seed_gen.seed(rank_master_seed);
}

Here is the call graph for this function:

set_online_rate_monitor_id()

void System::set_online_rate_monitor_id

(

unsigned int

id = 0

)

Sets the SpikingGroup used to display the rate estimate in the progressbar.

Deprecated:

This function should not be used any more. Use set_online_rate_monitor_target instead.

This typically is reflected by the order in which you define the SpikingGroup and NeuronGroup classes. It starts numbering from 0.

{
        if ( id < spiking_groups.size() ) {
                online_rate_monitor_id = id;
                set_online_rate_monitor_target(spiking_groups[online_rate_monitor_id]);
        } else {
                online_rate_monitor_id = -1;
                set_online_rate_monitor_target(NULL);
        }
}

Here is the call graph for this function:

set_online_rate_monitor_target()

void System::set_online_rate_monitor_target

(

SpikingGroup *

group = NULL

)

Sets the target group for online rate estimate.

{
        online_rate_monitor_state = 0.0;
        online_rate_monitor_target = group;
}

set_online_rate_monitor_tau()

void System::set_online_rate_monitor_tau

(

AurynDouble

tau = 100e-3

)

Sets the timeconstant to compute the online rate average for the status bar.

{
        online_rate_monitor_tau = tau;
        online_rate_monitor_mul = exp(-auryn_timestep/tau);
}

Here is the call graph for this function:

set_output_dir()

void System::set_output_dir

(

std::string

path

)

Set output dir for fn function.

{
        outputdir = path;
}

set_simulation_name()

void System::set_simulation_name

(

std::string

name

)

Sets the simulation name.

{
        simulation_name = name;
}

Member Data Documentation

build

AurynVersion auryn::System::build

Version info.

progressbar_update_interval

unsigned int auryn::System::progressbar_update_interval

The progressbar update interval in timesteps of auryn_timestep.

quiet

bool auryn::System::quiet

Switch to turn output to quiet mode (no progress bar).

---

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

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