synapseGroup.h

Go to the documentation of this file.

#pragma once

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

// GeNN includes
#include "initSparseConnectivitySnippet.h"
#include "neuronGroup.h"
#include "newPostsynapticModels.h"
#include "newWeightUpdateModels.h"
#include "synapseMatrixType.h"

//------------------------------------------------------------------------
// SynapseGroup
//------------------------------------------------------------------------
class SynapseGroup
{
public:
    SynapseGroup(const std::string name, SynapseMatrixType matrixType, unsigned int delaySteps,
                 const WeightUpdateModels::Base *wu, const std::vector<double> &wuParams, const std::vector<NewModels::VarInit> &wuVarInitialisers, const std::vector<NewModels::VarInit> &wuPreVarInitialisers, const std::vector<NewModels::VarInit> &wuPostVarInitialisers,
                 const PostsynapticModels::Base *ps, const std::vector<double> &psParams, const std::vector<NewModels::VarInit> &psVarInitialisers,
                 NeuronGroup *srcNeuronGroup, NeuronGroup *trgNeuronGroup,
                 const InitSparseConnectivitySnippet::Init &connectivityInitialiser);
    SynapseGroup(const SynapseGroup&) = delete;
    SynapseGroup() = delete;

    //------------------------------------------------------------------------
    // Enumerations
    //------------------------------------------------------------------------
    enum class SpanType
    {
        POSTSYNAPTIC,
        PRESYNAPTIC
    };

    //------------------------------------------------------------------------
    // Public methods
    //------------------------------------------------------------------------
    NeuronGroup *getSrcNeuronGroup(){ return m_SrcNeuronGroup; }
    NeuronGroup *getTrgNeuronGroup(){ return m_TrgNeuronGroup; }

    void setTrueSpikeRequired(bool req){ m_TrueSpikeRequired = req; }
    void setSpikeEventRequired(bool req){ m_SpikeEventRequired = req; }
    void setEventThresholdReTestRequired(bool req){ m_EventThresholdReTestRequired = req; }

    void setPSModelMergeTarget(const std::string &targetName)
    {
        m_PSModelTargetName = targetName;
    }


    void setWUVarZeroCopyEnabled(const std::string &varName, bool enabled)
    {
        setWUVarMode(varName, enabled ? VarMode::LOC_ZERO_COPY_INIT_HOST : VarMode::LOC_HOST_DEVICE_INIT_HOST);
    }


    void setPSVarZeroCopyEnabled(const std::string &varName, bool enabled)
    {
        setPSVarMode(varName, enabled ? VarMode::LOC_ZERO_COPY_INIT_HOST : VarMode::LOC_HOST_DEVICE_INIT_HOST);
    }


    void setWUVarMode(const std::string &varName, VarMode mode);


    void setWUPreVarMode(const std::string &varName, VarMode mode);
    

    void setWUPostVarMode(const std::string &varName, VarMode mode);
    

    void setPSVarMode(const std::string &varName, VarMode mode);


    void setInSynVarMode(VarMode mode) { m_InSynVarMode = mode; }


    void setSparseConnectivityVarMode(VarMode mode){ m_SparseConnectivityVarMode = mode; }


    void setDendriticDelayVarMode(VarMode mode) { m_DendriticDelayVarMode = mode; }


    void setMaxConnections(unsigned int maxConnections);


    void setMaxSourceConnections(unsigned int maxPostConnections);
    
    void setMaxDendriticDelayTimesteps(unsigned int maxDendriticDelay);
    

    void setSpanType(SpanType spanType);

    void setBackPropDelaySteps(unsigned int timesteps);

    void initDerivedParams(double dt);
    void calcKernelSizes(unsigned int blockSize, unsigned int &paddedKernelIDStart);

    //------------------------------------------------------------------------
    // Public const methods
    //------------------------------------------------------------------------
    std::pair<unsigned int, unsigned int> getPaddedKernelIDRange() const{ return m_PaddedKernelIDRange; }

    const std::string &getName() const{ return m_Name; }

    SpanType getSpanType() const{ return m_SpanType; }
    unsigned int getDelaySteps() const{ return m_DelaySteps; }
    unsigned int getBackPropDelaySteps() const{ return m_BackPropDelaySteps; }
    unsigned int getMaxConnections() const{ return m_MaxConnections; }
    unsigned int getMaxSourceConnections() const{ return m_MaxSourceConnections; }
    unsigned int getMaxDendriticDelayTimesteps() const{ return m_MaxDendriticDelayTimesteps; }
    SynapseMatrixType getMatrixType() const{ return m_MatrixType; }

    VarMode getInSynVarMode() const { return m_InSynVarMode; }

    VarMode getSparseConnectivityVarMode() const{ return m_SparseConnectivityVarMode; }

    VarMode getDendriticDelayVarMode() const{ return m_DendriticDelayVarMode; }

    unsigned int getPaddedDynKernelSize(unsigned int blockSize) const;
    unsigned int getPaddedPostLearnKernelSize(unsigned int blockSize) const;

    const NeuronGroup *getSrcNeuronGroup() const{ return m_SrcNeuronGroup; }
    const NeuronGroup *getTrgNeuronGroup() const{ return m_TrgNeuronGroup; }

    int getClusterHostID() const{ return m_TrgNeuronGroup->getClusterHostID(); }
    int getClusterDeviceID() const{ return m_TrgNeuronGroup->getClusterDeviceID(); }

    bool isTrueSpikeRequired() const{ return m_TrueSpikeRequired; }
    bool isSpikeEventRequired() const{ return m_SpikeEventRequired; }
    bool isEventThresholdReTestRequired() const{ return m_EventThresholdReTestRequired; }

    const WeightUpdateModels::Base *getWUModel() const{ return m_WUModel; }

    const std::vector<double> &getWUParams() const{ return m_WUParams; }
    const std::vector<double> &getWUDerivedParams() const{ return m_WUDerivedParams; }
    const std::vector<NewModels::VarInit> &getWUVarInitialisers() const{ return m_WUVarInitialisers; }
    const std::vector<NewModels::VarInit> &getWUPreVarInitialisers() const{ return m_WUPreVarInitialisers; }
    const std::vector<NewModels::VarInit> &getWUPostVarInitialisers() const{ return m_WUPostVarInitialisers; }
    const std::vector<double> getWUConstInitVals() const;

    const PostsynapticModels::Base *getPSModel() const{ return m_PSModel; }

    const std::vector<double> &getPSParams() const{ return m_PSParams; }
    const std::vector<double> &getPSDerivedParams() const{ return m_PSDerivedParams; }
    const std::vector<NewModels::VarInit> &getPSVarInitialisers() const{ return m_PSVarInitialisers; }
    const std::vector<double> getPSConstInitVals() const;

    const InitSparseConnectivitySnippet::Init &getConnectivityInitialiser() const{ return m_ConnectivityInitialiser; }

    const std::string &getPSModelTargetName() const{ return m_PSModelTargetName; }
    bool isPSModelMerged() const{ return m_PSModelTargetName != getName(); }

    bool isZeroCopyEnabled() const;
    bool isWUVarZeroCopyEnabled(const std::string &var) const{ return (getWUVarMode(var) & VarLocation::ZERO_COPY); }
    bool isPSVarZeroCopyEnabled(const std::string &var) const{ return (getPSVarMode(var) & VarLocation::ZERO_COPY); }

    VarMode getWUVarMode(const std::string &var) const;

    VarMode getWUVarMode(size_t index) const{ return m_WUVarMode[index]; }

    VarMode getWUPreVarMode(const std::string &var) const;

    VarMode getWUPreVarMode(size_t index) const{ return m_WUPreVarMode[index]; }

    VarMode getWUPostVarMode(const std::string &var) const;

    VarMode getWUPostVarMode(size_t index) const{ return m_WUPostVarMode[index]; }

    VarMode getPSVarMode(const std::string &var) const;

    VarMode getPSVarMode(size_t index) const{ return m_PSVarMode[index]; }

    void addExtraGlobalConnectivityInitialiserParams(std::map<string, string> &kernelParameters) const;
    void addExtraGlobalNeuronParams(std::map<string, string> &kernelParameters) const;
    void addExtraGlobalSynapseParams(std::map<string, string> &kernelParameters) const;
    void addExtraGlobalPostLearnParams(std::map<string, string> &kernelParameters) const;
    void addExtraGlobalSynapseDynamicsParams(std::map<string, string> &kernelParameters) const;

    std::string getPresynapticAxonalDelaySlot(const std::string &devPrefix) const;

    std::string getPostsynapticBackPropDelaySlot(const std::string &devPrefix) const;

    std::string getDendriticDelayOffset(const std::string &devPrefix, const std::string &offset = "") const;

    bool isDendriticDelayRequired() const;

    bool isPSInitRNGRequired(VarInit varInitMode) const;

    bool isWUInitRNGRequired(VarInit varInitMode) const;

    bool isPSDeviceVarInitRequired() const;

    bool isWUDeviceVarInitRequired() const;

    bool isWUDevicePreVarInitRequired() const;

    bool isWUDevicePostVarInitRequired() const;

    bool isDeviceSparseConnectivityInitRequired() const;

    bool isDeviceInitRequired() const;

    bool isDeviceSparseInitRequired() const;


    bool canRunOnCPU() const;

private:
    //------------------------------------------------------------------------
    // Private methods
    //------------------------------------------------------------------------
    void addExtraGlobalSimParams(const std::string &prefix, const std::string &suffix, const NewModels::Base::StringPairVec &extraGlobalParameters,
                                 std::map<std::string, std::string> &kernelParameters) const;
    void addExtraGlobalPostLearnParams(const std::string &prefix, const std::string &suffix, const NewModels::Base::StringPairVec &extraGlobalParameters,
                                       std::map<std::string, std::string> &kernelParameters) const;
    void addExtraGlobalSynapseDynamicsParams(const std::string &prefix, const std::string &suffix, const NewModels::Base::StringPairVec &extraGlobalParameters,
                                             std::map<std::string, std::string> &kernelParameters) const;

    //------------------------------------------------------------------------
    // Members
    //------------------------------------------------------------------------
    std::pair<unsigned int, unsigned int> m_PaddedKernelIDRange;

    std::string m_Name;

    SpanType m_SpanType;

    unsigned int m_DelaySteps;

    unsigned int m_BackPropDelaySteps;

    unsigned int m_MaxConnections;
    
    unsigned int m_MaxSourceConnections;

    unsigned int m_MaxDendriticDelayTimesteps;
    
    SynapseMatrixType m_MatrixType;

    NeuronGroup *m_SrcNeuronGroup;

    NeuronGroup *m_TrgNeuronGroup;

    bool m_TrueSpikeRequired;

    bool m_SpikeEventRequired;

    bool m_EventThresholdReTestRequired;

    VarMode m_InSynVarMode;

    VarMode m_DendriticDelayVarMode;

    const WeightUpdateModels::Base *m_WUModel;

    std::vector<double> m_WUParams;

    std::vector<double> m_WUDerivedParams;

    std::vector<NewModels::VarInit> m_WUVarInitialisers;

    std::vector<NewModels::VarInit> m_WUPreVarInitialisers;

    std::vector<NewModels::VarInit> m_WUPostVarInitialisers;
    
    const PostsynapticModels::Base *m_PSModel;

    std::vector<double> m_PSParams;

    std::vector<double> m_PSDerivedParams;

    std::vector<NewModels::VarInit> m_PSVarInitialisers;

    std::vector<VarMode> m_WUVarMode;

    std::vector<VarMode> m_WUPreVarMode;

    std::vector<VarMode> m_WUPostVarMode;

    std::vector<VarMode> m_PSVarMode;

    InitSparseConnectivitySnippet::Init m_ConnectivityInitialiser;

    VarMode m_SparseConnectivityVarMode;


    std::string m_PSModelTargetName;
};