FiringRateSim/Neuron.h

#pragma once

namespace FiringRateSim
{

        namespace Neurons
        {
                class FAST_NET_PORT Neuron : public AnimatSim::Node   
                {
                protected:
                        FiringRateModule *m_lpFRModule;

                        float m_fltCn;

                        float m_fltInvCn;       

                        float m_fltGn;          

                        float m_fltFmin;                

                        float m_fltGain;        

                        float m_fltExternalI;   

                        float m_fltIntrinsicI; 

                        float m_fltSynapticI;   

                        float m_fltAdapterI; 
                        
                        float m_fltAdapterMemoryI;  

                        float m_fltTotalMemoryI; 

                        float m_fltVNoiseMax; 

                        bool m_bUseNoise;    

                        bool m_bGainType; 

                        float m_fltDCTH;

                        float m_fltAccomTimeMod;

                        float m_fltAccomTimeConst;

                        float m_fltRelativeAccom;

                        bool m_bUseAccom;

                        float m_fltVn;     

                        float m_fltFiringFreq;  

                        float m_aryVn[2];               

                        float m_fltVNoise;      

                        float m_fltVth;                 

                        float m_fltVthi;    

                        float m_fltVthadd;

                        float m_aryVth[2];              

                        float m_fltVrest;      

                        float m_fltVndisp;      

                        float m_fltVthdisp;             

                        float m_fltIinit;

                        float m_fltInitTime;

                        CStdPtrArray<Synapse> m_arySynapses;

                        virtual float CalculateFiringFrequency(float fltVn, float fltVth);
                        virtual float CalculateSynapticCurrent(FiringRateModule *lpModule);
                        virtual float CalculateIntrinsicCurrent(FiringRateModule *lpModule, float fltInputCurrent);

                        Synapse *LoadSynapse(CStdXml &oXml);

                public:
                        Neuron();
                        virtual ~Neuron();

                        virtual float Cn();
                        virtual void Cn(float fltVal);

                        virtual float Gn();
                        virtual void Gn(float fltVal);

                        virtual float Vth();
                        virtual void Vth(float fltVal);

                        virtual float Fmin();
                        virtual void Fmin(float fltVal);

                        virtual float Gain();
                        virtual void Gain(float fltVal);

                        virtual float ExternalI();
                        virtual void ExternalI(float fltVal);
                        virtual void AddExternalI(float fltVal);

                        virtual float IntrinsicCurrent();
                        virtual void IntrinsicCurrent(float fltVal);

                        virtual float Vrest();
                        virtual void Vrest(float fltVal);

                        virtual float VNoiseMax();
                        virtual void VNoiseMax(float fltVal);

                        virtual bool UseNoise();
                        virtual void UseNoise(bool bVal);

                        virtual bool UseAccom();
                        virtual void UseAccom(bool bVal);

                        virtual float RelativeAccommodation();
                        virtual void RelativeAccommodation(float fltVal);

                        virtual float AccommodationTimeConstant();
                        virtual void AccommodationTimeConstant(float fltVal);

                        virtual float Iinit();
                        virtual void Iinit(float fltVal);

                        virtual float InitTime();
                        virtual void InitTime(float fltVal);

                        virtual bool GainType();
                        virtual void GainType(bool bVal);

                        virtual float Vn();
                        virtual float FiringFreq(FiringRateModule *lpModule);

                        virtual unsigned char NeuronType();

                        virtual CStdPtrArray<Synapse> *GetSynapses();

                        virtual void Copy(CStdSerialize *lpSource);

                        virtual void AddSynapse(Synapse *lpSynapse);
                        virtual void AddSynapse(std::string strXml, bool bDoNotInit);
                        virtual void RemoveSynapse(int iIndex);
                        virtual void RemoveSynapse(std::string strID, bool bThrowError = true);
                        virtual Synapse *GetSynapse(int iIndex);
                        virtual int TotalSynapses();
                        virtual void ClearSynapses();
                        virtual int FindSynapseListPos(std::string strID, bool bThrowError = true);

                        virtual void AddExternalNodeInput(int iTargetDataType, float fltInput);

                        virtual void SetSystemPointers(Simulator *lpSim, Structure *lpStructure, NeuralModule *lpModule, Node *lpNode, bool bVerify);
                        virtual void VerifySystemPointers();
                        virtual void Initialize();
                        virtual void TimeStepModified();
                        virtual void ResetSimulation();
                        virtual void StepSimulation();

                        virtual void InjectCurrent(float fltVal);

#pragma region SnapshotMethods
                        virtual long CalculateSnapshotByteSize();
                        virtual void SaveKeyFrameSnapshot(byte *aryBytes, long &lIndex);
                        virtual void LoadKeyFrameSnapshot(byte *aryBytes, long &lIndex);
#pragma endregion

#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 Load(CStdXml &oXml);
                };

        }                       //Neurons
}                               //FiringRateSim