auryn::BinaryStateMonitor Class Reference

Records from an arbitray state vector of one unit from the source SpikingGroup to a binary file. More...

#include <BinaryStateMonitor.h>

Inheritance diagram for auryn::BinaryStateMonitor:

Collaboration diagram for auryn::BinaryStateMonitor:

Public Member Functions
	BinaryStateMonitor (SpikingGroup *source, NeuronID id, string statename, std::string filename="", AurynDouble sampling_interval=auryn_timestep)
	Standard constructor. More...
	BinaryStateMonitor (auryn_vector_float *state, NeuronID id, std::string filename="", AurynDouble sampling_interval=auryn_timestep)
	Alternative constructor. More...
	BinaryStateMonitor (Trace *trace, NeuronID id, std::string filename="", AurynDouble sampling_interval=auryn_timestep)
	Trace constructor. More...
void	record_for (AurynDouble time=10.0)
	Sets relative time at which to stop recording. More...
void	set_stop_time (AurynDouble time=10.0)
	Set an absolute time when to stop recording. More...
virtual	~BinaryStateMonitor ()
void	execute ()
Public Member Functions inherited from auryn::Monitor
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...
Public Member Functions inherited from auryn::Device
	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 ()

Public Attributes
bool	enable_compression
	Switch to enable/disable output compression. More...
Public Attributes inherited from auryn::Monitor
bool	active
	Standard active switch. More...
Public Attributes inherited from auryn::Device
bool	active
	Standard active switch. More...

Protected Member Functions
void	init (string filename, AurynDouble stepsize)
	Standard initialization. More...
Protected Member Functions inherited from auryn::Monitor
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::Device
void	init ()
	Standard initializer to be called by the constructor. More...

Protected Attributes
SpikingGroup *	src
	The source SpikingGroup to record from. More...
AurynState *	target_variable
	Target variable. More...
AurynState	lastval
	Last value (used for compression) More...
AurynState	lastder
NeuronID	nid
	The source neuron id to record from. More...
AurynTime	ssize
	The step size (sampling interval) in units of auryn_timestep. More...
AurynTime	t_stop
	Defines the maximum recording time in AurynTime to save space. More...
Protected Attributes inherited from auryn::Monitor
std::ofstream	outfile
std::string	fname
std::string	default_file_extension
Protected Attributes inherited from auryn::Device
std::string	device_name
	Identifying name for device. More...

Detailed Description

Records from an arbitray state vector of one unit from the source SpikingGroup to a binary file.

Binary state files need to be read with the command line tool aubs or with custom code.

Constructor & Destructor Documentation

BinaryStateMonitor() [1/3]

BinaryStateMonitor::BinaryStateMonitor	(	SpikingGroup *	source,
		NeuronID	id,
		std::string	statename,
		std::string	filename = "",
		AurynDouble	sampling_interval = auryn_timestep
	)

Standard constructor.

Parameters

source	The neuron group to record from
id	The neuron id in the group to record from
statename	The name of the StateVector to record from
filename	The filename of the file to dump the output to
sampling_interval	The sampling interval in seconds

                                                                                                                                                  : Monitor(filename, default_extension)
{

        if ( !source->localrank(id) ) return; // do not register if neuron is not on the local rank

        init(filename, sampling_interval);
        auryn::sys->register_device(this);
        src = source;
        nid = src->global2rank(id);

        if ( nid >= src->get_rank_size() ) {
                auryn::logger->msg("Error: BinaryStateMonitor trying to read from non-existing neuron.",ERROR);
                throw AurynStateVectorException();
        }

        // TODO test if state exists -- use find_state_vector instead .. 
        if ( source->evolve_locally() ) {
                target_variable = src->get_state_vector(statename)->data+nid;
        } else {
                nid = src->get_rank_size() + 1;
        }
}

Here is the call graph for this function:

BinaryStateMonitor() [2/3]

BinaryStateMonitor::BinaryStateMonitor	(	auryn_vector_float *	state,
		NeuronID	id,
		std::string	filename = "",
		AurynDouble	sampling_interval = auryn_timestep
	)

Alternative constructor.

Parameters

state	The source state vector
filename	The filename of the file to dump the output to
sampling_interval	The sampling interval in seconds

                                                                                                                                : Monitor(filename, default_extension)
{
        if ( id >= state->size ) return; // do not register if neuron is out of vector range

        init(filename, sampling_interval);

        auryn::sys->register_device(this);
        src = NULL;
        nid = id;
        target_variable = state->data+nid;
        lastval = *target_variable;
}

Here is the call graph for this function:

BinaryStateMonitor() [3/3]

BinaryStateMonitor::BinaryStateMonitor	(	Trace *	trace,
		NeuronID	id,
		std::string	filename = "",
		AurynDouble	sampling_interval = auryn_timestep
	)

Trace constructor.

Parameters

trace	The source synaptic trace
filename	The filename of the file to dump the output to
sampling_interval	The sampling interval in seconds

                                                                                                                   : Monitor(filename, default_extension)
{
        if ( id >= trace->get_state_ptr()->size ) return; // do not register if neuron is out of vector range

        init(filename, sampling_interval);

        auryn::sys->register_device(this);
        src = NULL;
        nid = id;
        target_variable = trace->get_state_ptr()->data+nid;
        lastval = *target_variable;
}

Here is the call graph for this function:

~BinaryStateMonitor()

BinaryStateMonitor::~BinaryStateMonitor ( )

virtual

{
        AurynState value = *target_variable;
        AurynState deriv = value-lastval;
        if ( enable_compression && deriv==lastder ) { //terminate output with last value, but only if wasn't written already
                const AurynTime t = auryn::sys->get_clock()-ssize;
                write_frame(t, lastval);
        }

        outfile.close();
}

Here is the call graph for this function:

Member Function Documentation

execute()

void BinaryStateMonitor::execute ( )

virtual

Virtual execute function to be called at the end of central simulation loop in System

Reimplemented from auryn::Device.

{
        if ( auryn::sys->get_clock() < t_stop && auryn::sys->get_clock()%ssize==0  ) {
                if ( enable_compression && auryn::sys->get_clock()>0 ) {
                        AurynState value = *target_variable;
                        AurynState deriv = value-lastval;

                        if ( deriv != lastder ) {
                                const AurynTime t = auryn::sys->get_clock()-ssize;
                                write_frame(t, lastval);
                        }

                        lastval = value;
                        lastder = deriv;

                } else {
                        const AurynTime t = auryn::sys->get_clock();
                        write_frame(t, *target_variable);
                }
        }
}

Here is the call graph for this function:

init()

void BinaryStateMonitor::init ( std::string  filename, AurynDouble  stepsize  )

protected

Standard initialization.

{
        set_stop_time(10.0);
        ssize = sampling_interval/auryn_timestep;
        if ( ssize < 1 ) ssize = 1;

        enable_compression = true;
        lastval = 0.0;
        lastder = 0.0;


        // per convention the first entry contains
        // the number of timesteps per second
        // the neuronID field contains a tag 
        // encoding the version number
        StateValue_type headerFrame;
        headerFrame.time  = (AurynTime)(1.0/auryn_timestep);
        headerFrame.value = sys->build.tag_binary_state_monitor;
        outfile.write((char*)&headerFrame, sizeof(StateValue_type));
}

Here is the call graph for this function:

record_for()

void BinaryStateMonitor::record_for

(

AurynDouble

time = 10.0

)

Sets relative time at which to stop recording.

The time is given in seconds and interpreted as relative time with respect to the current clock value. This features is useful to decrease IO. The stop time can be set again after calling run to record multiple snippets.

{
        if (time < 0) {
                auryn::logger->msg("Warning: Negative stop times not supported -- ingoring.",WARNING);
        } 
        else t_stop = auryn::sys->get_clock() + time/auryn_timestep;
        auryn::logger->debug("Set record for times for monitor.");
}

Here is the call graph for this function:

set_stop_time()

void BinaryStateMonitor::set_stop_time

(

AurynDouble

time = 10.0

)

Set an absolute time when to stop recording.

{ 
        AurynDouble stoptime = std::min( time, std::numeric_limits<AurynTime>::max()*auryn_timestep );
        t_stop = stoptime/auryn_timestep;
}

Member Data Documentation

enable_compression

bool auryn::BinaryStateMonitor::enable_compression

Switch to enable/disable output compression.

When set to true, Auryn will compute the derivative of two consecutive datapoints of the state and only a value if the derivative changes. The correct function can then be recovered with linear interpolation (i.e. plotting in gnuplot with lines will yield the correct output). When compression is enabled the last value written to file always by one timestep with respect to the simulation clock. enable_compression is true by default.

lastder

AurynState auryn::BinaryStateMonitor::lastder

protected

lastval

AurynState auryn::BinaryStateMonitor::lastval

protected

Last value (used for compression)

nid

NeuronID auryn::BinaryStateMonitor::nid

protected

The source neuron id to record from.

src

SpikingGroup* auryn::BinaryStateMonitor::src

protected

The source SpikingGroup to record from.

ssize

AurynTime auryn::BinaryStateMonitor::ssize

protected

The step size (sampling interval) in units of auryn_timestep.

t_stop

AurynTime auryn::BinaryStateMonitor::t_stop

protected

Defines the maximum recording time in AurynTime to save space.

target_variable

AurynState* auryn::BinaryStateMonitor::target_variable

protected

Target variable.

---

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

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