GABASynapse.h

Go to the documentation of this file.

#ifndef _GABASYNAPSE_H_
#define _GABASYNAPSE_H_

#include "GenericGABASynapse.h"
#include "GenericNonLinGABASynapse.h"
#include "GABA_BResponse.h"

#include "GenericDynamicSpikingSynapse.h"
#include "GenericStaticSpikingSynapse.h"

#include "ExponentialDecaySpikeResponse.h"
#include "DoubleExponentialSpikeResponse.h"
#include "AlphaFunctionSpikeResponse.h"

// NEEDS TO BE TESTED

/* DATA from Alain Destexhe

Cmax_GABAb = 1      // (mM) max transmitter concentration
Cdur_GABAb = 1      // (ms) transmitter duration (rising phase)
K1_GABAb = 0.09     // (/ms mM) forward binding rate to receptor
K2_GABAb = 0.0012   // (/ms) backward (unbinding) rate of receptor
K3_GABAb = 0.18     // (/ms) rate of G-protein production
K4_GABAb = 0.034    // (/ms) rate of G-protein decay
KD_GABAb = 100      // dissociation constant of K+ channel
n_GABAb  = 4        // nb of binding sites of G-protein on K+
Erev_GABAb = -95    // (mV) reversal potential (E_K)
Prethresh_GABAb = 0 // (mV) voltage level nec for release
Deadtime_GABAb = 1  // (ms) mimimum time between release events
gmax  = 0.0001      // (umho) maximum conductance 
*/

typedef GenericDynamicSpikingSynapse<
        GenericNonLinGABASynapse<
        ExponentialDecaySpikeResponse > > DynamicNonLinGABAExpBase;

class DynamicNonLinGABAExpSynapse : public GenericDynamicSpikingSynapse<
                                           GenericNonLinGABASynapse<
                                           ExponentialDecaySpikeResponse > >
{
    SIMOBJECT(DynamicNonLinGABAExpSynapse, AdvancePhase::SpikeDriven)

public:
    DynamicNonLinGABAExpSynapse(
        const float W         = 1e-9,
        const float WB        = 0.06e-9,
        const float tau_A     = 6e-3,
        const float delay     = 2e-4,
        const float Erev_A    =-70e-3,
        const float Erev_B    =-95e-3,
        const float U         = 0.2,
        const float D         = 0.1,
        const float F         = 0.4,
        const float u0        = 0.2,
        const float r0        = 1.0,
        const float f0        =-1.0,
        const float k1        = 0.09*10e6,   // [M^-1 s^-1]
        const float k2        = 1.2,         // [s^-1]
        const float k3        = 180.0,       // [s^-1]
        const float k4        = 34.0,        // [s^-1]
        const float kd        = 100.0,
        const float Cdur      = 0.5e-3,      // [s]
        const float Cmax      = 1.0e-3,      // [M]
        const float dead_time = 1e-3,
        const int   n         = 4,
        const float fract_B = -1.0
//        , const bool rescale    = false
        )
    {
        this->W = W;
        this->delay = delay;

        this->g_max = WB;
        this->k1=k1;
        this->k2=k2;
        this->k3=k3;
        this->k4=k4;
        this->kd=kd;
        this->dead_time=dead_time; 
        this->Cmax=Cmax;
        this->Cdur=Cdur;
        this->n=n;
        this->fract_B = fract_B;

        this->tau_A = tau_A;
        this->resp_A.tau = tau_A;

        this->Erev_A = Erev_A;
        this->Erev_B = Erev_B;

        this->U  = U;
        this->D  = D;
        this->F  = F;
        this->u0 = u0;
        this->r0 = r0;
        this->f0 = f0;

//        this->rescale = rescale;
    };

    double tau_A;

    double fract_B;

    virtual int reset(double dt)
    {
        resp_A.tau = tau_A;
        resp_A.reset(dt);

        if (fract_B >= 0.0)
            g_max = W*fract_B;

        return DynamicNonLinGABAExpBase::reset(dt);
    }
};


typedef GenericStaticSpikingSynapse< 
        GenericNonLinGABASynapse< 
        ExponentialDecaySpikeResponse > > StaticNonLinGABAExpBase;

class StaticNonLinGABAExpSynapse : public GenericStaticSpikingSynapse< 
                                          GenericNonLinGABASynapse< 
                                          ExponentialDecaySpikeResponse > >
{
    SIMOBJECT(StaticNonLinGABAExpSynapse, AdvancePhase::SpikeDriven)

public:
    StaticNonLinGABAExpSynapse(
        const float W         = 1e-9,
        const float WB        = 0.06e-9, 
        const float tau_A     = 6e-3,
        const float delay     = 2e-4,
        const float Erev_A    = -70e-3,
        const float Erev_B    = -90e-3,
        const float k1        = 0.09*10e6,   // [M^-1 s^-1]
        const float k2        = 1.2,         // [s^-1]
        const float k3        = 180.0,       // [s^-1]
        const float k4        = 34.0,        // [s^-1]
        const float kd        = 100.0, 
        const float Cdur      = 0.5e-3,      // [s]
        const float Cmax      = 1.0e-3,      // [M]
        const float dead_time = 1e-3,
        const int   n         = 4,
        const float fract_B = -1.0
//        , const bool rescale    = false
        )
    {
        this->W = W;
        this->delay = delay;

        this->tau_A = tau_A;
        this->resp_A.tau = tau_A;

        this->g_max = WB;
        this->k1=k1;
        this->k2=k2;
        this->k3=k3;
        this->k4=k4;
        this->kd=kd;
        this->dead_time=dead_time;
        this->Cmax=Cmax;
        this->Cdur=Cdur;
        this->n=n;
        this->fract_B = fract_B;

        this->Erev_A = Erev_A;
        this->Erev_B = Erev_B;

//        this->rescale = rescale;
    };

    double tau_A;

    double fract_B;

    virtual int reset(double dt)
    {
        resp_A.tau = tau_A;
        resp_A.reset(dt);

        if (fract_B >= 0.0)
            g_max = W*fract_B;

        return StaticNonLinGABAExpBase::reset(dt);
    }
};

// Dynamic Synapses

// Exponential Response

typedef GenericDynamicSpikingSynapse< GenericGABASynapse< ExponentialDecaySpikeResponse > > DynamicGABAExpBase;

class DynamicGABAExpSynapse : public GenericDynamicSpikingSynapse<
                                     GenericGABASynapse<
                                     ExponentialDecaySpikeResponse > >
{
    SIMOBJECT(DynamicGABAExpSynapse, AdvancePhase::SpikeDriven)

public:
    DynamicGABAExpSynapse(
        const float W       = 1e-9,
        const float tau_A   = 6e-3,
        const float tau_B   = 150e-3,
        const float delay   = 2e-4,
        const float Erev_A  =-70e-3,
        const float Erev_B  =-90e-3,
        const float fract_A = 0.5,
        const float U       = 0.2,
        const float D       = 0.1,
        const float F       = 0.4,
        const float u0      = 0.2,
        const float r0      = 1.0,
        const float f0      =-1.0,
        const bool rescale  = true)
    {
        this->W = W;
        this->delay = delay;

        this->tau_A = tau_A;
        this->tau_B = tau_B;

        this->tau = tau_B;
        this->resp_A.tau = tau_A;

        this->Erev_A = Erev_A;
        this->Erev_B = Erev_B;

        this->fract_A = fract_A;

        this->U  = U;
        this->D  = D;
        this->F  = F;
        this->u0 = u0;
        this->r0 = r0;
        this->f0 = f0;

        this->rescale = rescale;
    };

    double tau_A;

    double tau_B;

    bool rescale;

    virtual int reset(double dt)
    {
        tau = tau_B;
        resp_A.tau = tau_A;

        if(rescale)
            scale_B = tau_A/tau_B;
        else
            scale_B = 1.0;

        resp_A.reset(dt);
        return DynamicGABAExpBase::reset(dt);
    }
};


// Double Exponential Response

typedef GenericDynamicSpikingSynapse< GenericGABASynapse< DoubleExponentialSpikeResponse > >
        DynamicGABADoubleExpBase;

class DynamicGABADoubleExpSynapse : public GenericDynamicSpikingSynapse<
                                           GenericGABASynapse<
                                           DoubleExponentialSpikeResponse > >
{
    SIMOBJECT(DynamicGABADoubleExpSynapse, AdvancePhase::SpikeDriven)

public:
    DynamicGABADoubleExpSynapse(
        const float W       = 1e-9,
        const float tau1_A  = 0.1e-3,
        const float tau2_A  = 6e-3,
        const float tau1_B  = 0.1e-3,
        const float tau2_B  = 150e-3,
        const float delay   = 2e-4,
        const float Erev_A  =-70e-3,
        const float Erev_B  =-90e-3,
        const float fract_A = 0.5,
        const float U       = 0.2,
        const float D       = 0.1,
        const float F       = 0.4,
        const float u0      = 0.2,
        const float r0      = 1.0,
        const float f0      =-1.0,
        const bool rescale  = true)
    {
        this->W=W;
        this->delay=delay;

        this->tau1_A = tau1_A;
        this->tau2_A = tau2_A;
        this->tau1_B = tau1_B;
        this->tau2_B = tau2_B;

        this->tau1 = tau1_B;
        this->tau2 = tau2_B;
        this->resp_A.tau1 = tau1_A;
        this->resp_A.tau2 = tau2_A; 

        this->Erev_A = Erev_A;
        this->Erev_B = Erev_B;

        this->fract_A = fract_A;

        this->U  = U;
        this->D  = D;
        this->F  = F;
        this->u0 = u0;
        this->r0 = r0;
        this->f0 = f0;

        this->rescale = rescale;
    };

    double tau1_A;

    double tau2_A;

    double tau1_B;

    double tau2_B;

    bool rescale;

    virtual int reset(double dt)
    {
        tau1 = tau1_B;
        tau2 = tau2_B;
        resp_A.tau1 = tau1_A;
        resp_A.tau2 = tau2_A;

        if(rescale)
            scale_B = (tau1_A+tau2_A)/(tau1_B+tau2_B);
        else
            scale_B = 1.0;

        resp_A.reset(dt);
        return DynamicGABADoubleExpBase::reset(dt);
    }
};



// Alpha Response

typedef GenericDynamicSpikingSynapse< GenericGABASynapse< AlphaFunctionSpikeResponse > > 
        DynamicGABAAlphaBase;

class DynamicGABAAlphaSynapse : public GenericDynamicSpikingSynapse< GenericGABASynapse< AlphaFunctionSpikeResponse > >
{
    SIMOBJECT(DynamicGABAAlphaSynapse, AdvancePhase::SpikeDriven)

public:
    DynamicGABAAlphaSynapse(
        const float W       = 1e-9,
        const float tau_A   = 6e-3,
        const float tau_B   = 150e-3,
        const float delay   = 2e-4,
        const float Erev_A  = -70e-3,
        const float Erev_B  = -90e-3,
        const float fract_A = 0.5,
        const float U       = 0.2,
        const float D       = 0.1,
        const float F       = 0.4,
        const float u0      = 0.2,
        const float r0      = 1.0,
        const float f0      = -1.0,
        const bool rescale  = true)
    {
        this->W = W;
        this->delay = delay;

        this->tau_A = tau_A;
        this->tau_B = tau_B;

        this->tau = tau_B;
        this->resp_A.tau = tau_A;

        this->Erev_A = Erev_A;
        this->Erev_B = Erev_B;

        this->fract_A = fract_A;

        this->U  = U;
        this->D  = D;
        this->F  = F;
        this->u0 = u0;
        this->r0 = r0;
        this->f0 = f0;

        this->rescale = rescale;
    };

    double tau_A;

    double tau_B;

    bool rescale;

    virtual int reset(double dt)
    {
        tau = tau_B;
        resp_A.tau = tau_A;

        if(rescale)
            scale_B = tau_A/tau_B;
        else
            scale_B = 1.0;

        resp_A.reset(dt);
        return DynamicGABAAlphaBase::reset(dt);
    }
};



// Static Synapses

// Exponential Response

typedef GenericStaticSpikingSynapse< GenericGABASynapse< ExponentialDecaySpikeResponse > > StaticGABAExpBase;

class StaticGABAExpSynapse : public GenericStaticSpikingSynapse< GenericGABASynapse< ExponentialDecaySpikeResponse > >
{
    SIMOBJECT(StaticGABAExpSynapse, AdvancePhase::SpikeDriven)

public:
    StaticGABAExpSynapse(
        const float W       = 1e-9,
        const float tau_A   = 6e-3,
        const float tau_B   = 150e-3,
        const float delay   = 2e-4,
        const float Erev_A  =-70e-3,
        const float Erev_B  =-90e-3,
        const float fract_A = 0.5,
        const bool  rescale = true)
    {
        this->W = W;
        this->delay = delay;

        this->tau_A = tau_A;
        this->tau_B = tau_B;

        this->tau = tau_B;
        this->resp_A.tau = tau_A;

        this->Erev_A = Erev_A;
        this->Erev_B = Erev_B;

        this->fract_A = fract_A;

        this->rescale = rescale;
    };

    double tau_A;

    double tau_B;

    bool rescale;

    virtual int reset(double dt)
    {
        tau = tau_B;
        resp_A.tau = tau_A;

        if(rescale)
            scale_B = tau_A/tau_B;
        else
            scale_B = 1.0;

        resp_A.reset(dt);
        return StaticGABAExpBase::reset(dt);
    }
};


// Double Exponential Response

typedef GenericStaticSpikingSynapse< GenericGABASynapse< DoubleExponentialSpikeResponse > >
        StaticGABADoubleExpBase;

class StaticGABADoubleExpSynapse : public GenericStaticSpikingSynapse< GenericGABASynapse< DoubleExponentialSpikeResponse > >
{
    SIMOBJECT(StaticGABADoubleExpSynapse, AdvancePhase::SpikeDriven)

public:
    StaticGABADoubleExpSynapse(
        const float W       = 1e-9,
        const float tau1_A  = 0.1e-3,
        const float tau2_A  = 6e-3,
        const float tau1_B  = 0.1e-3,
        const float tau2_B  = 150e-3,
        const float delay   = 2e-4,
        const float Erev_A  =-70e-3,
        const float Erev_B  =-90e-3,
        const float fract_A = 0.5,
        const bool  rescale = true)
    {
        this->W=W;
        this->delay=delay;

        this->tau1_A = tau1_A;
        this->tau2_A = tau2_A;
        this->tau1_B = tau1_B;
        this->tau2_B = tau2_B;

        this->tau1 = tau1_B;
        this->tau2 = tau2_B;
        this->resp_A.tau1 = tau1_A;
        this->resp_A.tau2 = tau2_A; 

        this->Erev_A = Erev_A;
        this->Erev_B = Erev_B;

        this->fract_A = fract_A;

        this->rescale = rescale;
    };

    double tau1_A;

    double tau2_A;

    double tau1_B;

    double tau2_B;

    bool rescale;

    virtual int reset(double dt)
    {
        tau1 = tau1_B;
        tau2 = tau2_B;
        resp_A.tau1 = tau1_A;
        resp_A.tau2 = tau2_A;

        if(rescale)
            scale_B = (tau1_A+tau2_A)/(tau1_B+tau2_B);
        else
            scale_B = 1.0;

        resp_A.reset(dt);
        return StaticGABADoubleExpBase::reset(dt);
    }
};



// Alpha Response

typedef GenericStaticSpikingSynapse< GenericGABASynapse< AlphaFunctionSpikeResponse > > 
        StaticGABAAlphaBase;

class StaticGABAAlphaSynapse : public GenericStaticSpikingSynapse< GenericGABASynapse< AlphaFunctionSpikeResponse > >
{
    SIMOBJECT(StaticGABAAlphaSynapse, AdvancePhase::SpikeDriven)

public:
    StaticGABAAlphaSynapse(
        const float W       = 1e-9,
        const float tau_A   = 6e-3,
        const float tau_B   = 150e-3,
        const float delay   = 2e-4,
        const float Erev_A  =-70e-3,
        const float Erev_B  =-90e-3,
        const float fract_A = 0.5,
        const bool  rescale = true)
    {
        this->W = W;
        this->delay = delay;

        this->tau_A = tau_A;
        this->tau_B = tau_B;

        this->tau = tau_B;
        this->resp_A.tau = tau_A;

        this->Erev_A = Erev_A;
        this->Erev_B = Erev_B;

        this->fract_A = fract_A;

        this->rescale = rescale;
    };

    double tau_A;

    double tau_B;

    bool rescale;

    virtual int reset(double dt)
    {
        tau = tau_B;
        resp_A.tau = tau_A;

        if(rescale)
            scale_B = tau_A/tau_B;
        else
            scale_B = 1.0;

        resp_A.reset(dt);
        return StaticGABAAlphaBase::reset(dt);
    }
};

#endif //_GABASYNAPSE_H_

---