ODESystemBasedSpikingNeuron.h

Go to the documentation of this file.

//
// C++ Interface: ODESystemBasedSpikingNeuron
//
// Description:
//
//
// Author: Thomas Natschläger <tnatschl@lichtenberg>, (C) 2007
//
// Copyright: See COPYING file that comes with this distribution
//
//
#ifndef ODESYSTEMBASEDSPIKINGNEURON_H
#define ODESYSTEMBASEDSPIKINGNEURON_H

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

class ODESystemBasedSpikingNeuron : public SimObject, public SingleOutputSpikeSender, public ConductanceInputTarget, public odeiv::ODESystem {
    public:

        ODESystemBasedSpikingNeuron( size_t dim );

        virtual ~ODESystemBasedSpikingNeuron();

        float Rm;

        float Cm;

        float Vresting;

        float Vthresh;

        float Vinit;

        double Em;

        float Trefract;

        float Inoise;

        float Iinject;

        virtual int init(InitializeInfo *ii);

        virtual int adjust( double dt );

        int reset( double dt, double *y0 );

        virtual int advance( AdvanceInfo const & );

        virtual void copySolverStateToFields() {
            Vm = solver->y(0);
        }

        virtual double getVm() {
            return solver->y(0);
        }

        //


        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 this->dimension();
        };

        virtual PortType outputPortType( port_t o ) const {
            if ( o == 0 )
                return spiking;
            else if ( o <= this->dimension() )
                return analog;
            else
                return undefined;
        };

        virtual PortType inputPortType( port_t i ) const {
            return undefined;
        };

        virtual double getAnalogOutput(analog_port_id_t port = 0) const {
            return solver->y(port-1);
        };


        //


        virtual void clearSynapticInput( void ) {
            Isyn = Gsyn = 0;
        };

        virtual void currentInput( double i) {
            Isyn += i;
        };

        virtual void conductanceInput( double g, double Erev ) {
            Gsyn += g;
            Isyn += ( g * Erev );
        };


    protected:

        double Vm;

        odeiv::Solver *solver;

        int nStepsInRefr;

        static ThreadSpecificRandomDistribution< NormalDistribution > noise;

        double Isyn;

        double Gsyn;

        // summation variables to be passed to the method derivates()
        double G0, I0;

};

#endif

---