HHNeuronTraubMiles91.h

Go to the documentation of this file.

#ifndef HHNEURONTRAUBMILES91_H_
#define HHNEURONTRAUBMILES91_H_

#include "ODESystemBasedSpikingNeuron.h"


class HHNeuronTraubMiles91 : public ODESystemBasedSpikingNeuron {

        SIMOBJECT( HHNeuronTraubMiles91, AdvancePhase::One )

    public:

        float gbar_Na;

        float E_Na;

        float gbar_K;

        float E_K;

        HHNeuronTraubMiles91(
            float Rm       = 100e6,
            float Cm       = 2e-10,
            float Vresting =-0.06,
            float Vthresh  = 0.0,
            float Vinit    =-0.06,
            float Trefract = 5e-3,
            float Inoise   = 0.0,
            float Iinject  = 0.0 ) : ODESystemBasedSpikingNeuron( 4 ) {
              
            this->Rm       = Rm;
            this->Cm       = Cm;
            this->Vresting = Vresting;
            this->Vthresh  = Vthresh;
            this->Vinit    = Vinit;
            this->Trefract = Trefract;
            this->Inoise   = Inoise;
            this->Iinject  = Iinject;

            gbar_Na = 0.2 * 1e-4;
            E_Na    = 50e-3;
            gbar_K  = 0.06 * 1e-4;
            E_K     = -90e-3;
        };

        double alpha_m( double V ) {
            return 1000 * 0.32 * ( 13 - V ) / ( exp( ( 13 - V ) / 4 ) - 1 );
        }
        double beta_m( double V ) {
            return 1000 * 0.28 * ( V - 40 ) / ( exp( ( V - 40 ) / 5 ) - 1 );
        }
        double infty_m( double V ) {
            return alpha_m( V ) / ( beta_m( V ) + alpha_m( V ) );
        }

        double alpha_h( double V ) {
            return 1000 * 0.128 * exp( ( 17 - V ) / 18 );
        }
        double beta_h( double V ) {
            return 1000 * 4 / ( 1 + exp( ( 40 - V ) / 5 ) );
        }
        double infty_h( double V ) {
            return alpha_h( V ) / ( beta_h( V ) + alpha_h( V ) );
        }

        double alpha_n( double V ) {
            return 1000 * 0.032 * ( 15 - V ) / ( exp( ( 15 - V ) / 5 ) - 1 );
        }
        double beta_n( double V ) {
            return 1000 * 0.5 * exp( ( 10 - V ) / 40 );
        }
        double infty_n( double V ) {
            return alpha_n( V ) / ( beta_n( V ) + alpha_n( V ) );
        }

        virtual void derivatives( double t, const double y[], double f[] ) {
            // y[0] ... Vm, y[1] ... m, y[2] ... h, y[3] ... n
            double V = y[ 0 ];

            f[ 0 ] = 1.0 / Cm * (
                         - gbar_Na * pow( y[1], 3 ) * y[2] * ( V - E_Na )
                         - gbar_K * pow( y[3], 4 ) * ( V - E_K )
                         + I0
                         - G0 * V
                     );

            double v2 = V * 1000.0 + 63.0;

            f[1] = alpha_m( v2 ) * ( 1 - y[1] ) - beta_m( v2 ) * y[1];

            f[2] = alpha_h( v2 ) * ( 1 - y[2] ) - beta_h( v2 ) * y[2];

            f[3] = alpha_n( v2 ) * ( 1 - y[3] ) - beta_n( v2 ) * y[3];

        };

        virtual int reset( double dt ) {

            double y0[ 4 ];

            double v2 = Vinit * 1000 + 63;

            y0[0] = Vinit;
            y0[1] = infty_m( v2 );
            y0[2] = infty_h( v2 );
            y0[3] = infty_n( v2 );

            double gNa = gbar_Na * pow( infty_m( v2 ), 3 ) * infty_h( v2 );
            double gK  = gbar_K  * pow( infty_n( v2 ), 4 );

            double Gtot_init = 1.0 / Rm + gNa + gK;
            double Ich_init = gNa * E_Na + gK * E_K;

            Em = Rm * ( Vresting * Gtot_init - Ich_init );

            ODESystemBasedSpikingNeuron::reset( dt, y0 );

            return 0;
        };

};

#endif /*HHNEURONTRAUBMILES91_H_*/

---