CsSpikingCurrentSynapse.h

Go to the documentation of this file.

#pragma once

namespace AnimatCarlSim
{

        class ANIMAT_CARL_SIM_PORT CsSpikingCurrentSynapse : public AnimatSim::Link   
        {
        protected:
                std::string m_strFromID;

                std::string m_strToID;

                CsNeuronGroup *m_lpFromNeuron;

                AnimatSim::Node *m_lpToNeuron;
                
                float m_fltPulseDecay;

                float m_fltPulseMagnitude;

                float m_fltPulseSign;

                float m_fltPulseTC;

                bool m_bWholePopulation;

                CStdMap<int, int> m_aryCells;
                
                int m_iStepsPerTest;

                int m_iStepsPerTestCount;

                //Keeps track of the current Test time to check for spikes
                unsigned long m_ulSpikeTestTime;

                float m_fltCurrentMagnitude;

                float m_fltAppliedCurrent;

                float m_fltDecrementCurrent;

                long m_lTotalSpikesAdded;

                CStdArray<long> m_arySpikeTimes;

                virtual void LoadCells(CStdXml &oXml);

                virtual void ProcessSpikes();
                virtual void CalculateStepsPerTest();

                virtual void MonitorSpikeEventFired(int iGroupID, int iNeuronID, long lTimeIdx);

#ifndef STD_DO_NOT_ADD_BOOST
                        //Signal for when a spike occurs
                        boost::signals2::connection m_MonitoredSpikeEvent;

                        boost::interprocess::interprocess_mutex m_AccessSpikes;
#endif

        public:
                CsSpikingCurrentSynapse();
                virtual ~CsSpikingCurrentSynapse();
                                                                
                static CsSpikingCurrentSynapse *CastToDerived(AnimatBase *lpBase) {return static_cast<CsSpikingCurrentSynapse*>(lpBase);}
                
                virtual void PulseDecay(float fltVal);
                virtual float PulseDecay();

                virtual void PulseCurrent(float fltVal);
                virtual float PulseCurrent();
                
                virtual void Coverage(std::string strType);

                virtual bool WholePopulation();
                virtual void WholePopulation(bool bVal);

                virtual void Cells(std::string strXml);

                CsNeuronGroup *FromNeuron() {return m_lpFromNeuron;};

#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);
#pragma endregion

                virtual void TimeStepModified();
                virtual void VerifySystemPointers();
                virtual void Initialize();
                virtual void ResetSimulation();
                virtual void StepSimulation();
                virtual void Load(CStdXml &oXml);
        };

}                               //AnimatCarlSim