LinearPoissonNeuron.h

Go to the documentation of this file.

#ifndef LinearPoissonNeuron_H_
#define LinearPoissonNeuron_H_

#include "InputTargetTypes.h"
#include "SpikeSender.h"
#include "SimObject.h"
#include "ThreadSpecificRandomDistribution.h"

/*
 * If there are no Conductance based synapses the membrane potential \f$Vm\f$ is given by
 * \f[
 *   Vm = Rm * ( Isyn + Iinject + Inoise ) 
 * \f]
 * 
 * If there are conductance based synapses the membrane potential \f$Vm\f$ is given by
 * \f[
 *   Vm = ( Isyn + Iinject + Inoise ) / ( Gsyn + 1 / Rm ) 
 * \f]
 *  The neuron fires a poisson spike train with firing rate:
 * \f[ 
 *    R^{post}(t) = C * Vm 
 * \f]
 *  where  
 *  \f$I_s(t)\f$ is the current supplied by synapse \f$s\f$ (Ampere)
 *  \f$I_{inject}\f$ is the injected current (Ampere)
 *  \f$I_{noise}\f$ is the intrinsic noise current (Ampere)
 *  \f$C\f$ is the constant determining the slope of the linear rate function
 * 
 *  After spiking, \f$R^{post}(t)\f$ is reset to 0 during a refractory period defined by parameter \fT_{refract}\f$
 * 
 *  The neuron fires poisson spike trains with exact spike times, but it doesn't spike more then
 *  one spike per time step. To avoid the refractory period, set \fT_{refract}\f$ equal to the simulation time step.
 * 
 * References:
 *   Gütig R, Aharonov R, Rotter S & Sompolinsky H (2003) Learning Input Correlations Through Non-Linear Temporally Asymmetric Hebbian Plasticity.  Journal of Neuroscience   23  3697-3714.
 */
class LinearPoissonNeuron : public SimObject, public SingleOutputSpikeSender, public ConductanceInputTarget 
{
        SIMOBJECT( LinearPoissonNeuron , AdvancePhase::One )
public:

    LinearPoissonNeuron( float C = 1,
                                                float Rm = 1e8,
                                        float Trefract = 3e-3,                    
                                        float Inoise   = 0.0,
                                        float Iinject  = 0.0 ) 
            :  C(C), Rm(Rm), Trefract(Trefract), Inoise(Inoise), Iinject(Iinject)
    {
        /* NOOP */
    }

    virtual ~LinearPoissonNeuron()
    {
        /* NOOP */
    }

    virtual int reset( double dt );

    inline bool refractoryQ() { return (nStepsInRefr > 0); };

    virtual void clearSynapticInput(void);
    
    
    float C;
    
    float Rm;
    
    float Trefract;

    float Inoise;

    float Iinject;
    
    virtual double getManagedDelay() const { return 0; }
    virtual int nSpikeInputPorts() const { return 0; };
    virtual int nSpikeOutputPorts() const { return 1; };
    virtual int nAnalogInputPorts() const { return 0; };
    virtual int nAnalogOutputPorts() const { return 0; };
    virtual PortType outputPortType(port_t o) const
    {
        if( o==0) return spiking; else return undefined;
    };
    virtual PortType inputPortType(port_t i) const
    {
        return undefined;
    };
    virtual int adjust( double dt ) { return 0; };

    virtual int advance(AdvanceInfo const &);


    virtual void currentInput( double Isyn );
    
    virtual void conductanceInput( double g, double Erev );

protected:
    double Vm;
    
    int nStepsInRefr;
    
    double Isyn;
    
    double Gsyn;
    

    double Twindow;
    
    // Random distribution for the poisson firing process
    static ThreadSpecificRandomDistribution< UniformDistribution > spike_gen;
        
    static ThreadSpecificRandomDistribution< NormalDistribution > noise_gen;

};


#endif /*LinearPoissonNeuron_H_*/

---