GenericHomeostaticSynapse.h

Go to the documentation of this file.

#ifndef GENERICHOMEOSTATICSYNAPSE_H_
#define GENERICHOMEOSTATICSYNAPSE_H_

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

#include "PCSIMException.h"
#include "SpikeBuffer.h"
#include "SimObject.h"
#include "SimNetwork.h"

#include "GenericStaticSpikingSynapse.h"
#include "GenericDynamicSpikingSynapse.h"
#include "GenericConductanceBasedSpikingSynapse.h"
#include "ExponentialDecaySpikeResponse.h"
#include "AlphaInfiniteSpikeResponse.h"
#include "GenericGlutamateSynapse.h"

template<class BaseSyn>
class GenericHomeostaticSynapse: public BaseSyn
{
public:
    GenericHomeostaticSynapse()
    {
        active=true;
        inhibitory=false;
    };

    virtual ~GenericHomeostaticSynapse()
    {
    };

    bool active;

    bool inhibitory;

    double Winit;

    double alpha;

    double activity_tau;

    double activity_goal;

    double activity_init;

    double activity_decay;

    double activity_post;

    double activity_pre;

    double Wex;

    float back_delay;

    virtual int reset( double dt )
    {
        activity_decay = exp( - dt / activity_tau);
        activity_post = activity_init;
        activity_pre = activity_init;

        BaseSyn::reset(dt);
        return RESETFLAG_ACTIVATE;
    }

    virtual int init(InitializeInfo *ii) 
    {
        BaseSyn::W = Winit;
        return 0; 
    }

    virtual int advance(AdvanceInfo const &ai)
    {
        activity_post *= activity_decay;
        activity_pre *= activity_decay;

        if (active)
        {
            double dW = alpha*activity_pre*(activity_goal - activity_post)*fabs(BaseSyn::W);
            double Wold = BaseSyn::W;

            if (inhibitory)  // BAD HACK
                dW *= -1.0;

            BaseSyn::W += dW;

            if (Wold*BaseSyn::W < 0.0)           // sign change is not allowed
                BaseSyn::W = Wold*0.1;

            if (BaseSyn::W > fabs(Wex))
               BaseSyn::W = Wex;
            else if (BaseSyn::W < -fabs(Wex))
               BaseSyn::W = -Wex;
        }

        BaseSyn::advance(ai);
        return 0;
    }

    virtual int spikeHit( spikeport_t port, SpikeEvent const& spike )
    {
        if( port == 0 ) {
            preSpikeHit( spike );
            BaseSyn::spikeHit( port, spike );
        } else {
            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() )  )
            );
        }
    };

};

template<class BaseSyn>
void GenericHomeostaticSynapse<BaseSyn>::preSpikeHit( SpikeEvent const& spike )
{
        activity_pre += 1.0 / exp(-spike.delta/activity_tau);   
}

template<class BaseSyn>
void GenericHomeostaticSynapse<BaseSyn>::postSpikeHit( SpikeEvent const& spike )
{
        activity_post += 1.0 / exp(-spike.delta/activity_tau);
}


#endif /*GENERICHOMEOSTATICSYNAPSE_H_*/

---