GenericGlutamateSynapse.h

Go to the documentation of this file.

#ifndef _GENERICGLUTAMATESYNAPSE_H_
#define _GENERICGLUTAMATESYNAPSE_H_

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

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

#include <cmath>


template<class Response>
class GenericGlutamateSynapse : public Response
{
public:
    GenericGlutamateSynapse()
    {
        this->ampa_psr=0.0;
        this->nmda_psr=0.0;

        this->fract_NMDA = 0.5;
        this->scale_NMDA = 1.0;

        this->Erev_NMDA = 0.0;
        this->Erev_AMPA = 0.0;

        this->Mg_conc = 1.2e-3;

        this->has_NMDA = 1;

        this->target = &dummyConductanceBasedSynapseTarget;
    };

    virtual ~GenericGlutamateSynapse()
    { // NOOP
    };

    float Erev_NMDA;

    float Erev_AMPA;

    float fract_NMDA;

    float scale_NMDA;

    float Mg_conc;

    int has_NMDA;

    virtual int adjust(double dt)
    {
        if (has_NMDA) {
            resp_AMPA.adjust(dt);
            return Response::adjust(dt);
        }
        else
            return resp_AMPA.adjust(dt);
    }

    virtual int init(InitializeInfo *ii)
    {
        if (has_NMDA) {
            resp_AMPA.init(ii);
            return Response::init(ii);
        }
        else
            return resp_AMPA.init(ii);
    }

    virtual int reset(double dt)
    {
        if (has_NMDA) {
            resp_AMPA.reset(dt);
            return Response::reset(dt);
        }
        else
            return resp_AMPA.reset(dt);
    }

    virtual int spikeHit(spikeport_t port, SpikeEvent const& spike)
    {
        if (has_NMDA) {
            resp_AMPA.spikeHit(port, spike);
            return Response::spikeHit(port, spike);
        }
        else
            return resp_AMPA.spikeHit(port, spike);
    }

    virtual int advance(AdvanceInfo const &ai)
    {
        ampa_psr=(1.0-fract_NMDA)*resp_AMPA.psr;

        target->conductanceInput(ampa_psr, Erev_AMPA);

        if (has_NMDA) {
            double Vm=target->getVm();
            double s=1.0/(1.0+exp(-62.0*Vm)*Mg_conc*1000.0/3.57);

            nmda_psr=fract_NMDA*s*scale_NMDA*Response::psr;

            target->conductanceInput(nmda_psr, Erev_NMDA);

            resp_AMPA.advance(ai);
            return Response::advance(ai);
        }
        else
            return resp_AMPA.advance(ai);
    }

    virtual void outgoing(SimObject *receiver, SimObject::ID const& rec, SimObject::ID const& self, SimNetwork & net )
    {
        ConductanceInputTarget *t = dynamic_cast<ConductanceInputTarget *>(receiver);
        if(t) {
            target = t;
        } 
        else {
            throw(
                PCSIM::Exception( "GenericGlutamateSynapse::outgoing", make_string( "Object must be a ConductanceBasedSynapseTarget; which %s is not!\n", typeid(*receiver).name() )  )
            );
        }
    }

    virtual double getAnalogOutput(analog_port_id_t p) const
    {
        if (p == 0)
            return ampa_psr;
        else if (p == 1)
            return nmda_psr;
        else if (p == 2)
            return resp_AMPA.psr;

        return Response::getAnalogOutput(p-3);
    };

    virtual int psrLength(double dt) const
    {
        if (has_NMDA)
            return Response::psrLength(dt);
        else
            return resp_AMPA.psrLength(dt);
    }

protected:
    Response resp_AMPA;

    ConductanceInputTarget *target;
    double ampa_psr;
    double nmda_psr;
};


#endif //_GENERICGLUTAMATESYNAPSE_H_

---