neuronGroup.h

Go to the documentation of this file.

#pragma once

// Standard includes
#include <map>
#include <set>
#include <string>
#include <vector>

// GeNN includes
#include "gennExport.h"
#include "neuronModels.h"
#include "variableMode.h"

// Forward declarations
class CurrentSourceInternal;
class SynapseGroupInternal;

//------------------------------------------------------------------------
// NeuronGroup
//------------------------------------------------------------------------
class GENN_EXPORT NeuronGroup
{
public:
    //------------------------------------------------------------------------
    // SpikeEventThreshold
    //------------------------------------------------------------------------
    struct SpikeEventThreshold
    {
        SpikeEventThreshold(const std::string &e, const std::string &s, bool egp, SynapseGroupInternal *sg)
            : eventThresholdCode(e), supportCode(s), synapseStateInThresholdCode(egp), synapseGroup(sg)
        {
        }

        const std::string eventThresholdCode;
        const std::string supportCode;
        const bool synapseStateInThresholdCode;
        SynapseGroupInternal *synapseGroup;

        bool operator < (const SpikeEventThreshold &other) const
        {
            if(other.eventThresholdCode < eventThresholdCode) {
                return false;
            }
            else if(eventThresholdCode < other.eventThresholdCode) {
                return true;
            }

            if(other.supportCode < supportCode) {
                return false;
            }
            else if(supportCode < other.supportCode) {
                return true;
            }

            if(synapseStateInThresholdCode) {
                if(other.synapseGroup < synapseGroup) {
                    return false;
                }
                else if(synapseGroup < other.synapseGroup) {
                    return true;
                }
            }

            return false;
        }

        bool operator == (const SpikeEventThreshold &other) const
        {
            return ((eventThresholdCode == other.eventThresholdCode)
                    && (supportCode == other.supportCode));
        }
    };

    NeuronGroup(const NeuronGroup&) = delete;
    NeuronGroup() = delete;

    //------------------------------------------------------------------------
    // Public methods
    //------------------------------------------------------------------------

    void setSpikeLocation(VarLocation loc) { m_SpikeLocation = loc; }


    void setSpikeEventLocation(VarLocation loc) { m_SpikeEventLocation = loc; }


    void setSpikeTimeLocation(VarLocation loc) { m_SpikeTimeLocation = loc; }
    

    void setPrevSpikeTimeLocation(VarLocation loc) { m_PrevSpikeTimeLocation = loc; }
    

    void setSpikeEventTimeLocation(VarLocation loc) { m_SpikeEventTimeLocation = loc; }
    

    void setPrevSpikeEventTimeLocation(VarLocation loc) { m_PrevSpikeEventTimeLocation = loc; }


    void setVarLocation(const std::string &varName, VarLocation loc);


    void setExtraGlobalParamLocation(const std::string &paramName, VarLocation loc);

    void setSpikeRecordingEnabled(bool enabled) { m_SpikeRecordingEnabled = enabled; }
    
    void setSpikeEventRecordingEnabled(bool enabled) { m_SpikeEventRecordingEnabled = enabled; }

    //------------------------------------------------------------------------
    // Public const methods
    //------------------------------------------------------------------------
    const std::string &getName() const{ return m_Name; }

    unsigned int getNumNeurons() const{ return m_NumNeurons; }

    const NeuronModels::Base *getNeuronModel() const{ return m_NeuronModel; }

    const std::vector<double> &getParams() const{ return m_Params; }
    const std::vector<Models::VarInit> &getVarInitialisers() const{ return m_VarInitialisers; }

    bool isSpikeTimeRequired() const;
    bool isPrevSpikeTimeRequired() const;
    bool isSpikeEventTimeRequired() const;
    bool isPrevSpikeEventTimeRequired() const;
    bool isTrueSpikeRequired() const;
    bool isSpikeEventRequired() const;

    unsigned int getNumDelaySlots() const{ return m_NumDelaySlots; }
    bool isDelayRequired() const{ return (m_NumDelaySlots > 1); }
    bool isZeroCopyEnabled() const;

    VarLocation getSpikeLocation() const{ return m_SpikeLocation; }

    VarLocation getSpikeEventLocation() const{ return m_SpikeEventLocation; }

    VarLocation getSpikeTimeLocation() const{ return m_SpikeTimeLocation; }

    VarLocation getPrevSpikeTimeLocation() const { return m_PrevSpikeTimeLocation; }

    VarLocation getSpikeEventTimeLocation() const { return m_SpikeEventTimeLocation;  }

    VarLocation getPrevSpikeEventTimeLocation() const { return m_PrevSpikeEventTimeLocation; }

    VarLocation getVarLocation(const std::string &varName) const;

    VarLocation getVarLocation(size_t index) const{ return m_VarLocation.at(index); }


    VarLocation getExtraGlobalParamLocation(const std::string &paramName) const;


    VarLocation getExtraGlobalParamLocation(size_t index) const{ return m_ExtraGlobalParamLocation.at(index); }

    bool isSpikeRecordingEnabled() const { return m_SpikeRecordingEnabled; }

    bool isSpikeEventRecordingEnabled() const { return m_SpikeEventRecordingEnabled; }

    bool isSimRNGRequired() const;

    bool isInitRNGRequired() const;

    bool isRecordingEnabled() const;

protected:
    NeuronGroup(const std::string &name, int numNeurons, const NeuronModels::Base *neuronModel,
                const std::vector<double> &params, const std::vector<Models::VarInit> &varInitialisers,
                VarLocation defaultVarLocation, VarLocation defaultExtraGlobalParamLocation);

    //------------------------------------------------------------------------
    // Protected methods
    //------------------------------------------------------------------------
    void checkNumDelaySlots(unsigned int requiredDelay);

    void updatePreVarQueues(const std::string &code);

    void updatePostVarQueues(const std::string &code);

    void addSpkEventCondition(const std::string &code, SynapseGroupInternal *synapseGroup);

    void addInSyn(SynapseGroupInternal *synapseGroup){ m_InSyn.push_back(synapseGroup); }
    void addOutSyn(SynapseGroupInternal *synapseGroup){ m_OutSyn.push_back(synapseGroup); }

    void initDerivedParams(double dt);

    void fusePrePostSynapses(bool fusePSM, bool fusePrePostWUM);

    void injectCurrent(CurrentSourceInternal *source);

    //------------------------------------------------------------------------
    // Protected const methods
    //------------------------------------------------------------------------
    const std::vector<SynapseGroupInternal*> &getInSyn() const{ return m_InSyn; }
    const std::vector<SynapseGroupInternal*> &getFusedPSMInSyn() const{ return m_FusedPSMInSyn; }
    const std::vector<SynapseGroupInternal *> &getFusedWUPostInSyn() const { return m_FusedWUPostInSyn; }
    
    const std::vector<SynapseGroupInternal*> &getOutSyn() const{ return m_OutSyn; }
    const std::vector<SynapseGroupInternal *> &getFusedWUPreOutSyn() const { return m_FusedWUPreOutSyn; }

     const std::vector<SynapseGroupInternal *> &getFusedPreOutputOutSyn() const { return m_FusedPreOutputOutSyn; }   

    const std::vector<CurrentSourceInternal*> &getCurrentSources() const { return m_CurrentSources; }

    const std::vector<double> &getDerivedParams() const{ return m_DerivedParams; }

    const std::set<SpikeEventThreshold> &getSpikeEventCondition() const{ return m_SpikeEventCondition; }

    std::vector<SynapseGroupInternal*> getFusedInSynWithPostCode() const;

    std::vector<SynapseGroupInternal*> getFusedOutSynWithPreCode() const;

    std::vector<SynapseGroupInternal *> getFusedInSynWithPostVars() const;

    std::vector<SynapseGroupInternal *> getFusedOutSynWithPreVars() const;

    bool isVarQueueRequired(const std::string &var) const;
    bool isVarQueueRequired(size_t index) const{ return m_VarQueueRequired[index]; }


    boost::uuids::detail::sha1::digest_type getHashDigest() const;


    boost::uuids::detail::sha1::digest_type getInitHashDigest() const;

    boost::uuids::detail::sha1::digest_type getSpikeQueueUpdateHashDigest() const;

    boost::uuids::detail::sha1::digest_type getPrevSpikeTimeUpdateHashDigest() const;

    boost::uuids::detail::sha1::digest_type getVarLocationHashDigest() const;

private:
    //------------------------------------------------------------------------
    // Private methods
    //------------------------------------------------------------------------
    void updateVarQueues(const std::string &code, const std::string &suffix);

    //------------------------------------------------------------------------
    // Members
    //------------------------------------------------------------------------
    const std::string m_Name;

    const unsigned int m_NumNeurons;

    const NeuronModels::Base *m_NeuronModel;
    const std::vector<double> m_Params;
    std::vector<double> m_DerivedParams;
    std::vector<Models::VarInit> m_VarInitialisers;
    std::vector<SynapseGroupInternal*> m_InSyn;
    std::vector<SynapseGroupInternal*> m_OutSyn;
    std::vector<SynapseGroupInternal*> m_FusedPSMInSyn;
    std::vector<SynapseGroupInternal *> m_FusedWUPostInSyn;
    std::vector<SynapseGroupInternal *> m_FusedWUPreOutSyn;
    std::vector<SynapseGroupInternal *> m_FusedPreOutputOutSyn;
    std::set<SpikeEventThreshold> m_SpikeEventCondition;
    unsigned int m_NumDelaySlots;
    std::vector<CurrentSourceInternal*> m_CurrentSources;

    std::vector<bool> m_VarQueueRequired;

    VarLocation m_SpikeLocation;

    VarLocation m_SpikeEventLocation;

    VarLocation m_SpikeTimeLocation;

    VarLocation m_PrevSpikeTimeLocation;

    VarLocation m_SpikeEventTimeLocation;

    VarLocation m_PrevSpikeEventTimeLocation;

    std::vector<VarLocation> m_VarLocation;

    std::vector<VarLocation> m_ExtraGlobalParamLocation;

    bool m_SpikeRecordingEnabled;

    bool m_SpikeEventRecordingEnabled;
};