RandomNeuron.h

Go to the documentation of this file.

#pragma once

namespace FiringRateSim
{
        namespace Neurons
        {
                class FAST_NET_PORT RandomNeuron  : public Neuron 
                {
                protected:
                        float m_fltITime;

                        unsigned char m_iIntrinsicTypeDefault;

                        unsigned char m_iIntrinsicType;

                        float m_fltIntrinsic;

                        float m_fltIlinit;

                        float m_fltIl;

                        AnimatSim::Gains::Gain *m_lpCurrentGraph;

                        AnimatSim::Gains::Gain *m_lpBurstGraph;

                        AnimatSim::Gains::Gain *m_lpIBurstGraph;

                        void HighCurrentOn();
                        void LowCurrentOn();

                        virtual float CalculateIntrinsicCurrent(FiringRateModule *lpModule, float fltInputCurrent);

                public:
                        RandomNeuron();
                        virtual ~RandomNeuron();

                        float ITime();
                        void ITime(float fltVal);

                        unsigned char IntrinsicType();
                        void IntrinsicType(unsigned char iVal);

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

                        float Il();
                        void Il(float fltVal);

                        float Ilinit();
                        void Ilinit(float fltVal);

                        virtual unsigned char NeuronType();
                                                                        
                        virtual void Copy(CStdSerialize *lpSource);

                        AnimatSim::Gains::Gain *CurrentDistribution() {return m_lpCurrentGraph;};
                        void CurrentDistribution(AnimatSim::Gains::Gain *lpGain);
                        void CurrentDistribution(std::string strXml);

                        AnimatSim::Gains::Gain *BurstLengthDistribution() {return m_lpBurstGraph;};
                        void BurstLengthDistribution(AnimatSim::Gains::Gain *lpGain);
                        void BurstLengthDistribution(std::string strXml);

                        AnimatSim::Gains::Gain *InterbusrtLengthDistribution() {return m_lpIBurstGraph;};
                        void InterbusrtLengthDistribution(AnimatSim::Gains::Gain *lpGain);
                        void InterbusrtLengthDistribution(std::string strXml);

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

                        virtual bool SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError = true);
                        virtual void QueryProperties(CStdPtrArray<TypeProperty> &aryProperties);
                        virtual void ResetSimulation();

                        virtual void Load(CStdXml &oXml);
                };

        }                       //Neurons
}                               //FiringRateSim