GenericOnePairStdpSynapse.h

Go to the documentation of this file.

#ifndef GENERICONEPAIRSTDPSYNAPSE_H_
#define GENERICONEPAIRSTDPSYNAPSE_H_

#include <string>
using std::string;
#include <boost/format.hpp>

#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 GenericOnePairStdpSynapse: public BaseSyn
{
public:
    GenericOnePairStdpSynapse()
    { /* NOOP */
    };

    virtual ~GenericOnePairStdpSynapse()
    { /*NOOP*/
    };

    bool 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 )
    {
        max_delta = maxRelevantSpikeTimeDiff();
        BaseSyn::W = Winit;        
        return BaseSyn::reset(dt);
    };

    virtual int spikeHit( spikeport_t port, SpikeEvent const& spike )
    {
        if( port == 0 ) {
                next_to_last_pre_spike = last_pre_spike;
                last_pre_spike = spike.time();                      
            if (activeSTDP)
                preSpikeHit( spike );
            return BaseSyn::spikeHit( port, spike );
        } else {            
                next_to_last_post_spike = last_post_spike;
                last_post_spike = 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() )  )
            );
        }
    };

private:
        double max_delta;
    double last_pre_spike;
    double last_post_spike;
    double next_to_last_post_spike;
    double next_to_last_pre_spike;
};

template<class BaseSyn>
void GenericOnePairStdpSynapse<BaseSyn>::preSpikeHit( SpikeEvent const& pre_spike )
{
        if (last_pre_spike - last_post_spike < max_delta )
                stdpLearning( last_post_spike - last_pre_spike, last_post_spike, pre_spike.time(), next_to_last_post_spike, next_to_last_pre_spike );
}

template<class BaseSyn>
void GenericOnePairStdpSynapse<BaseSyn>::postSpikeHit( SpikeEvent const& post_spike )
{
        if (last_post_spike - last_pre_spike < max_delta )
        stdpLearning( last_post_spike - last_pre_spike, post_spike.time(), last_pre_spike, next_to_last_post_spike, next_to_last_pre_spike );    
}


#endif /*GENERICONEPAIRSTDPSYNAPSE_H_*/

---