GenericEachPairStdpSynapse.h

Go to the documentation of this file.

#ifndef GENERICEACHPAIRSTDPSYNAPSE_H_
#define GENERICEACHPAIRSTDPSYNAPSE_H_

#include <boost/format.hpp>

#include <string>
using std::string;

#include "PCSIMException.h"
#include "SpikeBuffer.h"
#include "SimObject.h"
#include "SimNetwork.h"
#include "GenericFroemkeDanStdpSynapse.h"
#include "GenericStaticSpikingSynapse.h"
#include "GenericDynamicSpikingSynapse.h"
#include "GenericCurrentBasedSpikingSynapse.h"
#include "ExponentialDecaySpikeResponse.h"

template<class BaseSyn>
class GenericEachPairStdpSynapse: public BaseSyn
{
public:
    GenericEachPairStdpSynapse()
    { /* NOOP */
    };

    virtual ~GenericEachPairStdpSynapse()
    { /*NOOP*/
    };    
    
    int activeSTDP;

    float back_delay;
    
    double Winit;
    

    virtual double stdpLearning(const double & delta, const double  & t_post, const double & t_pre, const double & t_prev_post, const double & t_prev_pre ) = 0;

    virtual double maxRelevantSpikeTimeDiff()=0;
    
    virtual int reset( double dt )
    {
        presynapticSpikes.reset( maxRelevantSpikeTimeDiff() );
        postsynapticSpikes.reset( maxRelevantSpikeTimeDiff() );
        BaseSyn::W = Winit;
        return BaseSyn::reset(dt);        
    };

    virtual int spikeHit( spikeport_t port, SpikeEvent const& spike )
    {
        if( port == 0 ) {
                //cerr << "presynaptic spike arrived = " << spike.time() << endl;
            presynapticSpikes.insert( spike.time() );
            postsynapticSpikes.cutoff( spike.time() );
            if (activeSTDP)
                preSpikeHit( spike );
            return BaseSyn::spikeHit( port, spike );
        } else {
                //cerr << "postsynaptic spike arrived = " << spike.time() << endl;
            postsynapticSpikes.insert( spike.time() );
            presynapticSpikes.cutoff( spike.time() );
            if (activeSTDP)
                postSpikeHit( spike );
            return 0;
        }
    };

    void preSpikeHit( SpikeEvent const& spike );

    void postSpikeHit( SpikeEvent const& spike );

    virtual void incoming(SimObject *post, SimObject::ID const& postid, SimObject::ID const& self, SimNetwork & net)
    {
        if( post->outputPortType( 0 ) == SimObject::spiking ) {
            net.addSpikeMessage( postid, (port_t)0, self, (port_t)1, Time::sec( back_delay ) );
        } else {
            throw(
                PCSIM::Exception( "GenericStdpSynapse::incoming",
                                  boost::str( boost::format( "Output port 0 of postsynaptic object must be spiking; which is not true for %1%!\n") % typeid(*post).name() )  )
            );
        }
    };
    
     virtual SimObject::PortType inputPortType(port_t p) const {
        if (p < 2) {
                return SimObject::spiking;
        }
        return SimObject::undefined;
    }

private:
        
    SpikeBuffer postsynapticSpikes;
    SpikeBuffer presynapticSpikes;
};

template<class BaseSyn>
void GenericEachPairStdpSynapse<BaseSyn>::preSpikeHit( SpikeEvent const& pre_spike )
{
    double t_prev_pre = presynapticSpikes.second();
    
    if (postsynapticSpikes.size() > 1) {
        SpikeBuffer::const_iterator post_spike      = postsynapticSpikes.begin();
        SpikeBuffer::const_iterator post_spike_end  = postsynapticSpikes.end_of_window();        
                SpikeBuffer::const_iterator prev_post_spike = post_spike;
        for (prev_post_spike++; prev_post_spike != post_spike_end ; post_spike++, prev_post_spike++ ) {
                stdpLearning( *post_spike - pre_spike.time(), *post_spike, pre_spike.time(), *prev_post_spike, t_prev_pre );
                }        
    }

}

template<class BaseSyn>
void GenericEachPairStdpSynapse<BaseSyn>::postSpikeHit( SpikeEvent const& post_spike )
{
    double t_prev_post = postsynapticSpikes.second();

    if (presynapticSpikes.size() > 1) {
        SpikeBuffer::const_iterator pre_spike      = presynapticSpikes.begin();
        SpikeBuffer::const_iterator pre_spike_end  = presynapticSpikes.end_of_window();
        
        SpikeBuffer::const_iterator prev_pre_spike = pre_spike;
        for (prev_pre_spike++; prev_pre_spike != pre_spike_end ; pre_spike++, prev_pre_spike++ ) {
                stdpLearning( post_spike.time() - *pre_spike, post_spike.time(), *pre_spike, t_prev_post, *prev_pre_spike );
                }
    }

}


#endif /*GENERICEACHPAIRSTDPSYNAPSE_H_*/

---