CsNeuronGroup.h

Go to the documentation of this file.

#pragma once

namespace AnimatCarlSim
{

        class ANIMAT_CARL_SIM_PORT CsNeuronGroup : public AnimatSim::Node, public SpikeMonitor 
        {
        protected:
                CsNeuralModule *m_lpCsModule;

                unsigned int m_uiNeuronCount;

                //The type of these neurons. Either EXCITATORY_NEURON or INHIBITORY_NEURON
                int m_iNeuralType;

                int m_iGroupID;

                float m_fltA;

                float m_fltStdA;

                float m_fltB;

                float m_fltStdB;

                float m_fltC;

                float m_fltStdC;

                float m_fltD;

                float m_fltStdD;
                
                bool m_bEnableCOBA;

                float m_fltTauAMPA;

                float m_fltTauNMDA;

                float m_fltTauGABAa;

                float m_fltTauGABAb;

                bool m_bEnableSTP;

                float m_fltU;

                float m_fltTauDepression;

                float m_fltTauFacilitation;

                bool m_bEnableSTDP;

                float m_fltMaxLTP;

                float m_fltTauLTP;

                float m_fltMaxLTD;

                float m_fltTauLTD;


                float m_fltGroupFiringRate;

                float m_fltGroupTotalSpikes;
                
                float m_fltSpikeFake;

                int m_iCollectWholePopulation;

                CStdMap<int, int> m_aryCollectSpikeData;

                std::multimap<int, unsigned long> m_arySpikeTimes;

                unsigned long m_lLastUpdateTime;

                unsigned long m_lTotalSpikesCollected;

#ifndef STD_DO_NOT_ADD_BOOST
                        boost::interprocess::interprocess_mutex m_AccessRecentSpikes;
#endif


        public:
                CsNeuronGroup();
                virtual ~CsNeuronGroup();

                virtual void SetCARLSimulation();

                CsNeuralModule *GetCsModule() {return m_lpCsModule;};

                virtual void NeuronCount(unsigned int iVal);
                virtual unsigned int NeuronCount();

                virtual void NeuralType(std::string strType);
                virtual void NeuralType(int iVal);
                virtual int NeuralType();

                virtual void GroupID(int iVal);
                virtual int GroupID();

                virtual void A(float fltVal);
                virtual float A();

                virtual void StdA(float fltVal);
                virtual float StdA();

                virtual void B(float fltVal);
                virtual float B();

                virtual void StdB(float fltVal);
                virtual float StdB();

                virtual void C(float fltVal);
                virtual float C();

                virtual void StdC(float fltVal);
                virtual float StdC();

                virtual void D(float fltVal);
                virtual float D();

                virtual void StdD(float fltVal);
                virtual float StdD();

                virtual void EnableCOBA(bool bVal);
                virtual bool EnableCOBA();

                virtual void TauAMPA(float fltVal);
                virtual float TauAMPA();

                virtual void TauNMDA(float fltVal);
                virtual float TauNMDA();

                virtual void TauGABAa(float fltVal);
                virtual float TauGABAa();

                virtual void TauGABAb(float fltVal);
                virtual float TauGABAb();

                virtual void EnableSTP(bool bVal);
                virtual bool EnableSTP();

                virtual void U(float fltVal);
                virtual float U();

                virtual void TauDepression(float fltVal);
                virtual float TauDepression();

                virtual void TauFacilitation(float fltVal);
                virtual float TauFacilitation();

                virtual void EnableSTDP(bool bVal);
                virtual bool EnableSTDP();

                virtual void MaxLTP(float fltVal);
                virtual float MaxLTP();

                virtual void TauLTP(float fltVal);
                virtual float TauLTP();

                virtual void MaxLTD(float fltVal);
                virtual float MaxLTD();

                virtual void TauLTD(float fltVal);
                virtual float TauLTD();

                virtual void CollectFromWholePopulation(bool bVal);
                virtual bool CollectFromWholePopulation();

                virtual std::multimap<int, unsigned long> *SpikeTimes();
                
#ifndef STD_DO_NOT_ADD_BOOST
                boost::interprocess::interprocess_mutex *AccessRecentSpikes() {return &m_AccessRecentSpikes;};

                boost::signals2::signal<void (int, int, long)> MonitoredSpikeEvent;
#endif

                virtual void IncrementCollectSpikeDataForNeuron(int iIdx);
                virtual void DecrementCollectSpikeDataForNeuron(int iIdx);
                virtual bool CollectingSpikeDataForNeuron(int iIdx);

                virtual void update(CpuSNN* s, int grpId, unsigned int* NeuronIds, unsigned int *timeCounts, unsigned int total_spikes, float firing_Rate);

                virtual void AddExternalNodeInput(int iTargetDataType, float fltInput);
                virtual void Copy(CStdSerialize *lpSource);

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

#pragma region DataAccesMethods
                virtual bool SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError = true);
                virtual void QueryProperties(CStdPtrArray<TypeProperty> &aryProperties);
                virtual float *GetDataPointer(const std::string &strDataType);
#pragma endregion

                virtual void Load(CStdXml &oXml);
        };

}                               //AnimatCarlSim