LifNeuron.cpp

Go to the documentation of this file.

#include "LifNeuron.h"

#include <cmath>
#include <iostream>
using std::cerr;
using std::endl;

ThreadSpecificRandomDistribution< NormalDistribution > LifNeuronBase::noise_gen;


LifNeuronBase::LifNeuronBase(float Rm, float Cm, float Vresting, float Vthresh, float Vreset,
                                                         float Vinit, float Trefract, float Inoise, float Iinject)
        : Rm(Rm), Cm(Cm), Vresting(Vresting), Vthresh(Vthresh), Vreset(Vreset)
           , Vinit(Vinit), Trefract(Trefract), Inoise(Inoise), Iinject(Iinject)            
        
{
}

int LifNeuronBase::reset( double dt )
{
    SingleOutputSpikeSender::reset();


    Vm             = Vinit;     /* set membrane voltage to its initial value */
    nStepsInRefr   = -1;        /* we are not refractory at the begining     */
    //cerr << "LifNeuron::reset\n\n";
    clearSynapticInput();
    adjust( dt );
    return 0;
}


LifNeuron::LifNeuron(float Rm, float Cm, float Vresting, float Vthresh, float Vreset, float Vinit, float Trefract,
                                          float Inoise, float Iinject)
        :LifNeuronBase(Rm, Cm, Vresting, Vthresh, Vreset, Vinit, Trefract, Inoise, Iinject)
{
}


int LifNeuron::adjust( double dt )
{
    _dt = dt ;
    double tau = Cm*Rm;          /* the membrane time constant                          */
    if ( tau > 0 ) {             /* init consts C1,C2 for exponential Euler integration */
        C1 = exp( - dt / tau );
        C2 = Rm*(1-C1);
    } else {
        C1 = 0.0;
        C2 = Rm;
    }

    //cerr << "LifNeuron::adjust\n\n";

    noise_gen.set( NormalDistribution( 0.0, 1.0 ) );

    if ( Rm > 0 )
        I0 =  Iinject + Vresting/Rm;
    else {
        // TheCsimError.add("LifNeuron::fieldChangeNotify: Rm <= 0!\n"); return -1;
    }
    return 0;
}

int LifNeuron::advance( AdvanceInfo const &ai )
{
    bool register hasFired = false;

    if (nStepsInRefr > 0) {
        --nStepsInRefr;
    } else  {
        // all synapses have added the contributions to Isyn
        // we add I0
        double Itot = Isyn + I0;
        
        // Add white noise
        if (Inoise > 0.0) {             
                        Itot += (noise_gen() * Inoise);
        }
        
        // Add additional noise (custom implemented in derived classes)                 
        Itot += currentNoiseInput();
        

        // do the exponential Euler integration step
        Vm = C1 * Vm + C2 * Itot;

        if ( Vm >= Vthresh ) {
            // Note that the neuron has fired!
            hasFired = true;
            // calc number of steps how long we are refractory
            nStepsInRefr = (int)( Trefract / ai.dt.in_sec() ) - 1;
            // reset to 'Vreset'
            Vm = Vreset;
        }
    }

    // clear synaptic input for next time step
    clearSynapticInput();

    // Return proper value
    if( hasFired ) {
        out_port.setSpike( ai );
        return ADVANCEFLAG_HASSPIKED;
    } else {
        return 0;
    }
}



CbLifNeuron::CbLifNeuron(float Rm, float Cm, float Vresting, float Vthresh, float Vreset, float Vinit, 
                                             float Trefract, float Inoise, float Iinject)
        :LifNeuronBase(Rm, Cm, Vresting, Vthresh, Vreset, Vinit, Trefract, Inoise, Iinject)
{
}


int CbLifNeuron::adjust( double dt )
{
    _dt = dt;
    double tau = Cm*Rm;          /* the membrane time constant                          */
    if ( tau > 0 ) {             /* init consts C1,C2 for exponential Euler integration */
        C1 = exp( - dt / tau );
        C2 = Rm*(1-C1);
    } else {
        C1 = 0.0;
        C2 = Rm;
    }

    noise_gen.set( NormalDistribution( 0.0, 1.0 ) );

    if ( Rm > 0 )
        I0 =  Iinject + Vresting/Rm;
    else {
        // TheCsimError.add("LifNeuron::fieldChangeNotify: Rm <= 0!\n"); return -1;
    }
    return 0;
}

int CbLifNeuron::advance(AdvanceInfo const &ai )
{
    bool register hasFired = false;

    if (nStepsInRefr > 0) {
        --nStepsInRefr;
    } else  {
        // all synapses have added the contributions to Isyn
        // we add I0
        double Itot = Isyn + I0;
        double Gtot = Gsyn + 1.0/Rm;

        if (Inoise > 0.0) {     
                        Itot += (noise_gen() * Inoise);     
        }
        
        // Add additional noise (custom implemented in derived classes)                 
        Itot += currentNoiseInput();
        Gtot += conductanceNoiseInput();        

        // do the exponential Euler integration step
        C1 = exp( - _dt / (Cm/Gtot) );
        Vm = C1*Vm+(1.0-C1)*(Itot/Gtot);

        if ( Vm >= Vthresh ) {
            // Note that the neuron has fired!
            hasFired = true;
            // calc number of steps how long we are refractory
            nStepsInRefr = (int)( Trefract / ai.dt.in_sec() ) - 1;
            // reset to 'Vreset'
            Vm = Vreset;
        }
    }

    // clear synaptic input for next time step
    clearSynapticInput();

    // Return proper value
    if( hasFired ) {
        out_port.setSpike( ai );
        return ADVANCEFLAG_HASSPIKED;
    } else {
        return 0;
    }
}


        

---