IntegrateFireSim/Neuron.h

Go to the documentation of this file.

#pragma once

class IntegrateFireNeuralModule;

namespace IntegrateFireSim
{
        class ADV_NEURAL_PORT Neuron : public AnimatSim::Node
        {
        protected:
                IntegrateFireNeuralModule *m_lpIGFModule;


        // LOADABLE PARAMETERS

                static double m_dSpikePeak;

                static double m_dSpikeStrength;

                static double m_dAHPEquilPot;

                static double m_dCaEquilPot;

                static double m_dAbsoluteRefr;

                static long m_lAbsoluteRefr;

                int m_iNeuronID;

                bool m_bZapped;

                // individual, basic properties
                        double m_dRestingPot;

                        double m_dSize;

                        double m_dTimeConst;

                        double m_dCm;

                        double m_dInitialThresh;

                        double m_dRelativeAccom;

                        double m_dAccomTimeConst;

                        double m_dAHPAmp;

                        double m_dAHPTimeConst;

        // burster properties
                        double m_dGMaxCa;

                        double m_dVM;           

                        double m_dSM;   

                        double m_dMTimeConst;   

                        double m_dVH;

                        double m_dSH;

                        double m_dHTimeConst;

                        CStdArray<double> m_aryTonicInputPeriod;

                        CStdArray<int> m_aryTonicInputPeriodType;

                        double m_dToniCurrentStimulusulus;

                        double m_dNoise;

                        CStdPtrArray<IonChannel> m_aryIonChannels;

                        CaActivation *m_lpCaActive;

                        CaActivation *m_lpCaInactive;

                        bool m_bBurstInitAtBottom;

        // WORKING STUFF
                static double m_dDT;

                double m_dMemPot;

                double m_dNewMemPot;

                double m_dThresh;

                bool m_bSpike;          // spike flag

                // electrical synapse current
                double m_dElecSynCur;

                double m_dElecSynCond;

                // non-spiking chemical synapse current
                double m_dNonSpikingSynCur;

                double m_dNonSpikingSynCond;

                // calculation stuff
                long m_lRefrCountDown;

                double m_dDCTH; 

                double m_dDGK;  

                double m_dGK;   

                double m_dGTot; 
                
                float m_fltGTotal; 

                double m_dStim;

                float m_fltAdapterI;

                float m_fltAdapterMemoryI;  

                float m_fltExternalI;

                float m_fltChannelI;

                float m_fltChannelMemoryI;

                float m_fltTotalI;

                float m_fltTotalMemoryI;

                float m_fltICaMemory;
                
                float m_fltMemPot;

                float m_fltThresholdMemory;  

                float m_fltElecSynCurMemory;

                float m_fltSpikingSynCurMemory;

                float m_fltNonSpikingSynCurMemory;

                float m_fltSpike;

                int m_iIonChannels;

                // for bursting 
                double m_dM;

                double m_dH;

                float m_fltEMemory;

                //Vars to calculate the firing frequency of this neuron.
                double m_fltLastSpikeTime;

                float m_fltFiringFreq;

                //Used to return the membrane conductance of this neuron in GetDataPointers.
                float m_fltGm;

                float m_fltVrest;

                CStdArray<double> m_arySynG;    
                
                CStdArray<double> m_aryFacilSponSynG;   

                CStdArray<double> m_aryNextSponSynTime; 

                CStdArray<double> m_aryDG;      

                CStdArray<double> m_aryFacilD;          

                virtual IonChannel *LoadIonChannel(CStdXml &oXml);
                IonChannel *FindIonChannel(std::string strID, bool bThrowError);

        protected:
                //void ClearSpikeTimes();
                //void StoreSpikeForFreqAnalysis(IntegrateFireNeuralModule *lpNS);
                void CalculateFiringFreq(IntegrateFireNeuralModule *lpNS);
                virtual void AddIonChannel(std::string strXml, bool bDoNotInit);
                virtual void RemoveIonChannel(std::string strID, bool bThrowError = true);
        
        public:
                Neuron();
                virtual ~Neuron();
                virtual void Load(CStdXml &oXml);

#pragma region Accessor-Mutators

                int NeuronID();
                void NeuronID(int iID);

                virtual bool Enabled();
                virtual void Enabled(bool bValue);

                virtual void AddExternalI(float fltVal);

        // ENGINE
                double GetRestingPot();
                double GetMemPot();
                double GetThresh();
                bool GetSpike();
                bool GetZapped();
                void IncrementStim(double stim);
                void InElectricalSynapseCurr(double cur);
                void InElectricalSynapseCond(double cond);
                void IncNonSpikingSynCurr(double cur);
                void IncNonSpikingSynCond(double cond);

                CStdPtrArray<IonChannel> *IonChannels();

                void RestingPotential(double dVal) ;
                double RestingPotential();

                void Size(double dVal);
                double Size();

                void TimeConstant(double dVal);
                double TimeConstant();

                void InitialThreshold(double dVal) ;
                double InitialThreshold();

                void RelativeAccomodation(double dVal);
                double RelativeAccomodation();

                void AccomodationTimeConstant(double dVal);
                double AccomodationTimeConstant();

                void AHPAmplitude(double dVal);
                double AHPAmplitude();

                void AHPTimeConstant(double dVal);
                double AHPTimeConstant();

                void BurstGMaxCa(double dVal);
                double BurstGMaxCa();

                void BurstVm(double dVal);
                double BurstVm();

                void BurstSm(double dVal);
                double BurstSm();

                void BurstMTimeConstant(double dVal);
                double BurstMTimeConstant();

                void BurstVh(double dVal);
                double BurstVh();

                void BurstSh(double dVal);
                double BurstSh();

                void BurstHTimeConstant(double dVal);
                double BurstHTimeConstant();

                void BurstInitAtBottom(bool bVal);
                bool BurstInitAtBottom();
                
                void TonicStimulus(double dblVal);
                double TonicStimulus();
                
                void TonicNoise(double dblVal);
                double TonicNoise();

#pragma endregion

                void PreCalc(IntegrateFireNeuralModule *lpNS);
                void CalcUpdate(IntegrateFireNeuralModule *lpNS);
                void CalcUpdateFinal(IntegrateFireNeuralModule *lpNS);
                void PostCalc(IntegrateFireNeuralModule *lpNS);

                virtual int FindIonChannelListPos(std::string strID, bool bThrowError = true);

                //Node Overrides
#pragma region DataAccesMethods
                virtual float *GetDataPointer(const std::string &strDataType);
                virtual bool SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError = true);
                virtual void QueryProperties(CStdPtrArray<TypeProperty> &aryProperties);
                virtual bool AddItem(const std::string &strItemType, const std::string &strXml, bool bThrowError = true, bool bDoNotInit = false);
                virtual bool RemoveItem(const std::string &strItemType, const std::string &strID, bool bThrowError = true);
#pragma endregion

                virtual void AddExternalNodeInput(int iTargetDataType, float fltInput);
                virtual void ResetSimulation();
                //Node Overrides
                                        
                virtual void SetSystemPointers(Simulator *lpSim, Structure *lpStructure,  AnimatSim::Behavior::NeuralModule *lpModule, Node *lpNode, bool bVerify);
                virtual void VerifySystemPointers();

        friend class IntegrateFireSim::IntegrateFireNeuralModule;
        };

}                               //IntegrateFireSim