GenericDAModulatedSTDPSynapse.h

Go to the documentation of this file.

#ifndef GenericDAModulatedSTDPSYNAPSE_H_
#define GenericDAModulatedSTDPSYNAPSE_H_

#include <queue>

using std::queue;

#include "SimObject.h"
#include "SimNetwork.h"
#include "DopamineReceiver.h"

#include "GenericDAModulatedSTDPSynapse.h"
#include "GenericFroemkeDanStdpSynapse.h"
#include "GenericEachPairStdpSynapse.h"
#include "GenericStaticSpikingSynapse.h"
#include "GenericCurrentBasedSpikingSynapse.h"
#include "FiniteSpikeResponse.h"



template<class BaseSyn>
class GenericDAModulatedSTDPSynapse : public BaseSyn
{
public:

    GenericDAModulatedSTDPSynapse()
    { 
        da_trace_response = NULL;
    };

    virtual ~GenericDAModulatedSTDPSynapse()
    { 
        if (da_trace_response != NULL)
                delete da_trace_response;
    };

    double DATrace;

    double DAStdpRate;
    
    double DATraceDelay;

    bool activeDASTDP;

    virtual int reset( double dt )
    {
        dopamine_receiver = dynamic_cast<DopamineReceiver*>(BaseSyn::target);
        while (!trace_starts.empty()) trace_starts.pop();
        while (!trace_weights.empty()) trace_weights.pop();
        dw = 0;
        assert( da_trace_response != NULL );
        da_trace_response->reset(dt);        
        DATrace = 0;        
        return BaseSyn::reset(dt);
    };
    
    
    virtual void deepCopy(const SimObject *obj)
        {               
                this->da_trace_response = dynamic_cast<FiniteSpikeResponse *>(dynamic_cast< const GenericDAModulatedSTDPSynapse<BaseSyn> *>(obj)->da_trace_response->create());
        } 

    virtual int advance(AdvanceInfo const & ai);

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

        virtual int spikeHit( spikeport_t port, SpikeEvent const& spike );
        
        FiniteSpikeResponse * getTraceResponse() {
                return da_trace_response;
        };

protected:    
    DopamineReceiver * dopamine_receiver;
    
    double dw;
    
    queue<double> trace_starts;
    queue<double> trace_weights;
    
    FiniteSpikeResponse * da_trace_response;
};


template<class BaseSyn>
int GenericDAModulatedSTDPSynapse<BaseSyn>::advance(AdvanceInfo const &ai)
{
        // check to see if another event needs to be activated
        while (!trace_starts.empty() && ai.t.in_sec() + ai.dt.in_sec() >= trace_starts.front()) {
        double t =  trace_starts.front(); trace_starts.pop();
        double w = trace_weights.front(); trace_weights.pop();
        // cerr << " simulation step = " << int(ai.t.in_sec() * 10000) << " ************************* new spike hit for da trace response w = " << w << endl;
        // cerr << " simulation step = " << int(ai.t.in_sec() * 10000) << " ************************* delta = " << t - ai.t.in_sec() << " t_begin_timestep = " << ai.t.in_sec() << endl;
        da_trace_response->spikeHit(0, SpikeEvent(ai.t.in_sec(), t - ai.t.in_sec(), w, ai.dt ) );
        }
        if (da_trace_response->isActive()) {            
                // cerr << "************************ advancing da trace response " << endl;             
                da_trace_response->advance(ai);
        }
    DATrace = da_trace_response->psr;
    // cerr << "************************ time = " << int( ai.t.in_sec() * 10000 ) << " da trace response psr =  " << da_trace_response->psr << endl;
    if (activeDASTDP) {
        BaseSyn::W += DAStdpRate * DATrace * dopamine_receiver->DA_concentration;
        // check the sign
        if ((BaseSyn::Wex < 0 && BaseSyn::W > 0) || (BaseSyn::Wex > 0 && BaseSyn::W < 0))
            BaseSyn::W = 0;
        // check for greater Wmax
        if (fabs(BaseSyn::W) > fabs(BaseSyn::Wex))
            BaseSyn::W = BaseSyn::Wex;
    }
    
    int retval = ADVANCEFLAG_DEACTIVATE;    
    if (BaseSyn::isActive()) {          
                retval = BaseSyn::advance(ai);
    }    
                                
        if (da_trace_response->isActive() || !trace_starts.empty()) 
        return 0;    
    else {      
        return retval;
    }
}

template<class BaseSyn>
int GenericDAModulatedSTDPSynapse<BaseSyn>::spikeHit( spikeport_t port, SpikeEvent const& spike )
{
        bool trace_response_active = da_trace_response->isActive() || !trace_starts.empty(); 
        int retval = BaseSyn::spikeHit( port, spike );
        if (fabs(dw) > 0) {
                //cerr << "inserting spike in trace starts spike_time = " << spike.time() << " delay = " << DATraceDelay << endl; 
                trace_starts.push(spike.time() + DATraceDelay);
                trace_weights.push(dw);
        }
        dw = 0;
        
        if (trace_response_active) {    
                return 0;
        }
        else {
                if (port == 1 && !trace_starts.empty() ) {
                        return SPIKEHITFLAG_ACTIVATE;
                }                                       
                return retval;
        }
}


template<class BaseSyn>
double GenericDAModulatedSTDPSynapse<BaseSyn>::stdpLearning(const double & delta, const double  & t_post, const double & t_pre, const double & t_prev_post, const double & t_prev_pre )
{
        float w_temp = BaseSyn::W; 
    dw += BaseSyn::stdpLearning(delta, t_post, t_pre, t_prev_post, t_prev_pre);            
        // rollback previous weight changes by STDP
        BaseSyn::W = w_temp;
    return dw;
}



#endif /*GenericDAModulatedSTDPSYNAPSE_H_*/

---