SpikingGroup.h

Go to the documentation of this file.

/* 
* Copyright 2014-2018 Friedemann Zenke
*
* This file is part of Auryn, a simulation package for plastic
* spiking neural networks.
* 
* Auryn is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* 
* Auryn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
* 
* You should have received a copy of the GNU General Public License
* along with Auryn.  If not, see <http://www.gnu.org/licenses/>.
*
* If you are using Auryn or parts of it for your work please cite:
* Zenke, F. and Gerstner, W., 2014. Limits to high-speed simulations 
* of spiking neural networks using general-purpose computers. 
* Front Neuroinform 8, 76. doi: 10.3389/fninf.2014.00076
*/

#ifndef SPIKINGGROUP_H_
#define SPIKINGGROUP_H_

#include "auryn_definitions.h"
#include "AurynVector.h"
#include "SpikeDelay.h"
#include "Trace.h"
#include "EulerTrace.h"

#include <vector>
#include <map>

#include <boost/serialization/vector.hpp>
#include <boost/serialization/map.hpp>

#include <boost/archive/text_oarchive.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <boost/archive/binary_oarchive.hpp> 
#include <boost/archive/binary_iarchive.hpp> 


namespace auryn {

enum NodeDistributionMode { 
        AUTO, 
        ROUNDROBIN, 
        BLOCKLOCK, 
        RANKLOCK 
};


class SpikingGroup
{
private:
        /* Functions necesssary for serialization */
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
                virtual_serialize(ar, version);
        }

        NeuronID unique_id;

        unsigned int mpi_rank;
        unsigned int mpi_size;

        static NeuronID unique_id_count;

        void init( NeuronID size, NodeDistributionMode mode );

        void lock_range( double rank_fraction );
        unsigned int locked_rank;
        unsigned int locked_range;
        static int last_locked_rank;

        bool evolve_locally_bool;

        int axonaldelay;

protected:
        std::vector<Trace *> pretraces;

        std::vector<Trace *> posttraces;

        std::vector<Trace *> post_state_traces;
        std::vector<AurynFloat> post_state_traces_spike_biases;
        std::vector<AurynStateVector *> post_state_traces_states;

        std::string group_name;

    NeuronID size;
        NeuronID rank_size;
        SpikeContainer * spikes;
        AttributeContainer * attribs;

        static AurynTime * clock_ptr;

        /* Functions related to loading and storing the state from files */
        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 );

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

        void free();
        
public:
        SpikeDelay * delay;

        bool active;


        std::map<std::string,AurynStateVector *> state_vectors;

        std::map<std::string,AurynState> state_variables;


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

        void remove_state_vector( std::string key );

        AurynStateVector * find_state_vector(std::string key);

        AurynStateVector * get_state_vector(std::string key);

        AurynStateVector * get_existing_state_vector(std::string key);

        AurynStateVector * create_state_vector(std::string key);

        AurynState * get_state_variable(std::string key);

        void randomize_state_vector_gauss(std::string state_vector_name, AurynState mean, AurynState sigma, int seed=12239);

        SpikingGroup( NeuronID size, NodeDistributionMode mode=AUTO );

        virtual ~SpikingGroup();

        virtual void evolve_traces();

        void set_name(std::string s);

        std::string get_name();

        std::string get_file_name();

        std::string get_log_name();

        void inc_num_spike_attributes(int x);
        int get_num_spike_attributes();

        virtual void evolve() = 0;

        void conditional_evolve();

        unsigned int get_locked_rank();

        unsigned int get_locked_range();

        SpikeContainer * get_spikes();

        SpikeContainer * get_spikes_immediate();

        AttributeContainer * get_attributes();

        AttributeContainer * get_attributes_immediate();

        NeuronID get_size();

        NeuronID get_pre_size();

        NeuronID calculate_rank_size(int rank = -1);

        NeuronID get_rank_size();

        NeuronID get_post_size();

        void set_clock_ptr(AurynTime * clock);

        bool evolve_locally();


        NeuronID get_uid();

        Trace * get_pre_trace( AurynFloat x );

        void add_pre_trace( Trace * tr );

        Trace * get_post_trace( AurynFloat x );

        void add_post_trace( Trace * tr );

        void push_spike(NeuronID spike);

        void push_attribute(AurynFloat attrib);

        void clear_spikes();


        Trace * get_post_state_trace( std::string state_name="mem", AurynFloat tau=10e-3, AurynFloat b=0.0 );

        Trace * get_post_state_trace( AurynStateVector * state, AurynFloat tau=10e-3, AurynFloat b=0.0 );

        void set_delay( int d );

        virtual bool write_to_file(const char * filename);

        virtual bool load_from_file(const char * filename);

        NeuronID ranksize();

        NeuronID global2rank(NeuronID i); 

        NeuronID rank2global(NeuronID i);

        bool localrank(NeuronID i);

        NeuronID get_vector_size();

#ifdef CODE_GATHER_STATS_WAITALL_TIME

        boost::timer waitall_timer;
        static double waitall_time;
        static double waitall_time2;
#endif
};

BOOST_SERIALIZATION_ASSUME_ABSTRACT(SpikingGroup)

//      extern System * sys;
extern Logger * logger;
#ifdef AURYN_CODE_USE_MPI
        extern mpi::communicator * mpicommunicator;
#endif // AURYN_CODE_USE_MPI


inline NeuronID SpikingGroup::global2rank(NeuronID i) {
        return i/locked_range;
}

inline NeuronID SpikingGroup::get_rank_size()
{
        return rank_size;
} 

} // closing namespace brackets

#endif /*SPIKINGGROUP_H_*/