modelSpec.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------
   Author: Thomas Nowotny
  
   Institute: Center for Computational Neuroscience and Robotics
              University of Sussex
              Falmer, Brighton BN1 9QJ, UK
  
   email to:  T.Nowotny@sussex.ac.uk
  
   initial version: 2010-02-07
   
   This file contains neuron model declarations.
  
--------------------------------------------------------------------------*/

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
#pragma once

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

// GeNN includes
#include "currentSourceInternal.h"
#include "customUpdateInternal.h"
#include "gennExport.h"
#include "neuronGroupInternal.h"
#include "synapseGroupInternal.h"

#define NO_DELAY 0 

enum FloatType
{
    GENN_FLOAT,
    GENN_DOUBLE,
    GENN_LONG_DOUBLE,
};

enum class TimePrecision
{
    DEFAULT,    
    FLOAT,      
    DOUBLE,     
};


template<typename S>
inline Models::VarInit initVar(const typename S::ParamValues &params)
{
    return Models::VarInit(S::getInstance(), params.getInitialisers());
}


template<typename S>
inline typename std::enable_if<std::is_same<typename S::ParamValues, Snippet::ValueBase<0>>::value, Models::VarInit>::type initVar()
{
   return Models::VarInit(S::getInstance(), {});
}


inline Models::VarInit uninitialisedVar()
{
    return Models::VarInit(InitVarSnippet::Uninitialised::getInstance(), {});
}


template<typename S>
inline InitSparseConnectivitySnippet::Init initConnectivity(const typename S::ParamValues &params)
{
    return InitSparseConnectivitySnippet::Init(S::getInstance(), params.getInitialisers());
}


template<typename S>
inline typename std::enable_if<std::is_same<typename S::ParamValues, Snippet::ValueBase<0>>::value, InitSparseConnectivitySnippet::Init>::type initConnectivity()
{
    return InitSparseConnectivitySnippet::Init(S::getInstance(), {});
}


inline InitSparseConnectivitySnippet::Init uninitialisedConnectivity()
{
    return InitSparseConnectivitySnippet::Init(InitSparseConnectivitySnippet::Uninitialised::getInstance(), {});
}


template<typename S>
inline InitToeplitzConnectivitySnippet::Init initToeplitzConnectivity(const typename S::ParamValues &params)
{
    return InitToeplitzConnectivitySnippet::Init(S::getInstance(), params.getInitialisers());
}


template<typename S>
inline typename std::enable_if<std::is_same<typename S::ParamValues, Snippet::ValueBase<0>>::value, InitToeplitzConnectivitySnippet::Init>::type initToeplitzConnectivity()
{
    return InitToeplitzConnectivitySnippet::Init(S::getInstance(), {});
}

inline Models::VarReference createVarRef(const NeuronGroup *ng, const std::string &varName)
{
    return Models::VarReference::createVarRef(ng, varName);
}

inline Models::VarReference createVarRef(const CurrentSource *cs, const std::string &varName)
{
    return Models::VarReference::createVarRef(cs, varName);
}

inline Models::VarReference createVarRef(const CustomUpdate *cu, const std::string &varName)
{
    return Models::VarReference::createVarRef(cu, varName);
}

inline Models::VarReference createPSMVarRef(const SynapseGroup *sg, const std::string &varName)
{
    return Models::VarReference::createPSMVarRef(sg, varName);
}

inline Models::VarReference createWUPreVarRef(const SynapseGroup *sg, const std::string &varName)
{
    return Models::VarReference::createWUPreVarRef(sg, varName);
}

inline Models::VarReference createWUPostVarRef(const SynapseGroup *sg, const std::string &varName)
{
    return Models::VarReference::createWUPostVarRef(sg, varName);
}

inline Models::WUVarReference createWUVarRef(const SynapseGroup *sg, const std::string &varName,
                                             const SynapseGroup *transposeSG = nullptr, const std::string &transposeVarName = "")
{
    return Models::WUVarReference(sg, varName, transposeSG, transposeVarName);
}

inline Models::WUVarReference createWUVarRef(const CustomUpdateWU *cu, const std::string &varName)
{
    return Models::WUVarReference(cu, varName);
}

inline Models::EGPReference createEGPRef(const NeuronGroup *ng, const std::string &egpName)
{
    return Models::EGPReference::createEGPRef(ng, egpName);
}

inline Models::EGPReference createEGPRef(const CurrentSource *cs, const std::string &egpName)
{
    return Models::EGPReference::createEGPRef(cs, egpName);
}

inline Models::EGPReference createEGPRef(const CustomUpdate *cu, const std::string &egpName)
{
    return Models::EGPReference::createEGPRef(cu, egpName);
}

inline Models::EGPReference createEGPRef(const CustomUpdateWU *cu, const std::string &egpName)
{
    return Models::EGPReference::createEGPRef(cu, egpName);
}

inline Models::EGPReference createPSMEGPRef(const SynapseGroup *sg, const std::string &egpName)
{
    return Models::EGPReference::createPSMEGPRef(sg, egpName);
}

inline Models::EGPReference createWUEGPRef(const SynapseGroup *sg, const std::string &egpName)
{
    return Models::EGPReference::createWUEGPRef(sg, egpName);
}

//----------------------------------------------------------------------------
// ModelSpec
//----------------------------------------------------------------------------
class GENN_EXPORT ModelSpec
{
public:
    // Typedefines
    //=======================
    typedef std::map<std::string, NeuronGroupInternal>::value_type NeuronGroupValueType;
    typedef std::map<std::string, SynapseGroupInternal>::value_type SynapseGroupValueType;
    typedef std::map<std::string, CurrentSourceInternal>::value_type CurrentSourceValueType;
    typedef std::map<std::string, CustomUpdateInternal>::value_type CustomUpdateValueType;
    typedef std::map<std::string, CustomUpdateWUInternal>::value_type CustomUpdateWUValueType;

    //typedef std::map<std::string, CustomUpdateInternal>::value_type CustomUpdateValueType;

    ModelSpec();
    ModelSpec(const ModelSpec&) = delete;
    ModelSpec &operator=(const ModelSpec &) = delete;
    ~ModelSpec();

    // PUBLIC MODEL FUNCTIONS
    //=======================
    void setName(const std::string &name){ m_Name = name; }

    void setPrecision(FloatType);

    void setTimePrecision(TimePrecision timePrecision){ m_TimePrecision = timePrecision; }

    void setDT(double dt){ m_DT = dt; }

    void setTiming(bool timingEnabled){ m_TimingEnabled = timingEnabled; }

    void setSeed(unsigned int rngSeed){ m_Seed = rngSeed; }


    void setDefaultVarLocation(VarLocation loc){ m_DefaultVarLocation = loc; }


    void setDefaultExtraGlobalParamLocation(VarLocation loc){ m_DefaultExtraGlobalParamLocation = loc; }


    void setDefaultSparseConnectivityLocation(VarLocation loc){ m_DefaultSparseConnectivityLocation = loc; }

    void setDefaultNarrowSparseIndEnabled(bool enabled){ m_DefaultNarrowSparseIndEnabled = enabled; }


    void setMergePostsynapticModels(bool merge){ m_ShouldFusePostsynapticModels = merge; }


    void setFusePostsynapticModels(bool fuse) { m_ShouldFusePostsynapticModels = fuse; }
    

    void setFusePrePostWeightUpdateModels(bool fuse){ m_ShouldFusePrePostWeightUpdateModels = fuse; }

    void setBatchSize(unsigned int batchSize) { m_BatchSize = batchSize;  }

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

    const std::string &getPrecision() const{ return m_Precision; }

    std::string getTimePrecision() const;

    double getDT() const { return m_DT; }

    unsigned int getSeed() const { return m_Seed; }

    bool isTimingEnabled() const{ return m_TimingEnabled; }

    unsigned int getBatchSize() const { return m_BatchSize;  }

    // PUBLIC NEURON FUNCTIONS
    //========================
    unsigned int getNumNeurons() const;

    NeuronGroup *findNeuronGroup(const std::string &name){ return static_cast<NeuronGroup*>(findNeuronGroupInternal(name)); }


    template<typename NeuronModel>
    NeuronGroup *addNeuronPopulation(const std::string &name, unsigned int size, const NeuronModel *model,
                                     const typename NeuronModel::ParamValues &paramValues,
                                     const typename NeuronModel::VarValues &varInitialisers)
    {
        // Add neuron group to map
        auto result = m_LocalNeuronGroups.emplace(std::piecewise_construct,
            std::forward_as_tuple(name),
            std::forward_as_tuple(name, size, model,
                                  paramValues.getInitialisers(), varInitialisers.getInitialisers(), 
                                  m_DefaultVarLocation, m_DefaultExtraGlobalParamLocation));

        if(!result.second) {
            throw std::runtime_error("Cannot add a neuron population with duplicate name:" + name);
        }
        else {
            return &result.first->second;
        }
    }


    template<typename NeuronModel>
    NeuronGroup *addNeuronPopulation(const std::string &name, unsigned int size,
                                     const typename NeuronModel::ParamValues &paramValues, const typename NeuronModel::VarValues &varInitialisers)
    {
        return addNeuronPopulation<NeuronModel>(name, size, NeuronModel::getInstance(), paramValues, varInitialisers);
    }

    // PUBLIC SYNAPSE FUNCTIONS
    //=========================
    SynapseGroup *findSynapseGroup(const std::string &name);    


    template<typename WeightUpdateModel, typename PostsynapticModel>
    SynapseGroup *addSynapsePopulation(const std::string &name, SynapseMatrixType mtype, unsigned int delaySteps, const std::string& src, const std::string& trg,
                                       const WeightUpdateModel *wum, const typename WeightUpdateModel::ParamValues &weightParamValues, const typename WeightUpdateModel::VarValues &weightVarInitialisers, const typename WeightUpdateModel::PreVarValues &weightPreVarInitialisers, const typename WeightUpdateModel::PostVarValues &weightPostVarInitialisers,
                                       const PostsynapticModel *psm, const typename PostsynapticModel::ParamValues &postsynapticParamValues, const typename PostsynapticModel::VarValues &postsynapticVarInitialisers,
                                       const InitSparseConnectivitySnippet::Init &connectivityInitialiser = uninitialisedConnectivity())
    {
        auto uninitialisedToeplitz = InitToeplitzConnectivitySnippet::Init(InitToeplitzConnectivitySnippet::Uninitialised::getInstance(), {});
        return addSynapsePopulation(name, mtype, delaySteps, src, trg,
                                    wum, weightParamValues, weightVarInitialisers, weightPreVarInitialisers, weightPostVarInitialisers,
                                    psm, postsynapticParamValues, postsynapticVarInitialisers,
                                    connectivityInitialiser, uninitialisedToeplitz);
    }


    template<typename WeightUpdateModel, typename PostsynapticModel>
    SynapseGroup *addSynapsePopulation(const std::string &name, SynapseMatrixType mtype, unsigned int delaySteps, const std::string& src, const std::string& trg,
                                       const WeightUpdateModel *wum, const typename WeightUpdateModel::ParamValues &weightParamValues, const typename WeightUpdateModel::VarValues &weightVarInitialisers, const typename WeightUpdateModel::PreVarValues &weightPreVarInitialisers, const typename WeightUpdateModel::PostVarValues &weightPostVarInitialisers,
                                       const PostsynapticModel *psm, const typename PostsynapticModel::ParamValues &postsynapticParamValues, const typename PostsynapticModel::VarValues &postsynapticVarInitialisers,
                                       const InitToeplitzConnectivitySnippet::Init &connectivityInitialiser)
    {
        auto uninitialisedToeplitz = InitToeplitzConnectivitySnippet::Init(InitToeplitzConnectivitySnippet::Uninitialised::getInstance(), {});
        return addSynapsePopulation(name, mtype, delaySteps, src, trg,
                                    wum, weightParamValues, weightVarInitialisers, weightPreVarInitialisers, weightPostVarInitialisers,
                                    psm, postsynapticParamValues, postsynapticVarInitialisers,
                                    uninitialisedConnectivity(), connectivityInitialiser);
    }


    template<typename WeightUpdateModel, typename PostsynapticModel>
    SynapseGroup *addSynapsePopulation(const std::string &name, SynapseMatrixType mtype, unsigned int delaySteps, const std::string& src, const std::string& trg,
                                       const typename WeightUpdateModel::ParamValues &weightParamValues, const typename WeightUpdateModel::VarValues &weightVarInitialisers,
                                       const typename PostsynapticModel::ParamValues &postsynapticParamValues, const typename PostsynapticModel::VarValues &postsynapticVarInitialisers,
                                       const InitSparseConnectivitySnippet::Init &connectivityInitialiser = uninitialisedConnectivity())
    {
        // Create empty pre and postsynaptic weight update variable initialisers
        typename WeightUpdateModel::PreVarValues weightPreVarInitialisers;
        typename WeightUpdateModel::PostVarValues weightPostVarInitialisers;

        return addSynapsePopulation(name, mtype, delaySteps, src, trg,
                                    WeightUpdateModel::getInstance(), weightParamValues, weightVarInitialisers, weightPreVarInitialisers, weightPostVarInitialisers,
                                    PostsynapticModel::getInstance(), postsynapticParamValues, postsynapticVarInitialisers,
                                    connectivityInitialiser);
    }


    template<typename WeightUpdateModel, typename PostsynapticModel>
    SynapseGroup *addSynapsePopulation(const std::string &name, SynapseMatrixType mtype, unsigned int delaySteps, const std::string& src, const std::string& trg,
                                       const typename WeightUpdateModel::ParamValues &weightParamValues, const typename WeightUpdateModel::VarValues &weightVarInitialisers,
                                       const typename PostsynapticModel::ParamValues &postsynapticParamValues, const typename PostsynapticModel::VarValues &postsynapticVarInitialisers,
                                       const InitToeplitzConnectivitySnippet::Init &connectivityInitialiser)
    {
        // Create empty pre and postsynaptic weight update variable initialisers
        typename WeightUpdateModel::PreVarValues weightPreVarInitialisers;
        typename WeightUpdateModel::PostVarValues weightPostVarInitialisers;

        return addSynapsePopulation(name, mtype, delaySteps, src, trg,
                                    WeightUpdateModel::getInstance(), weightParamValues, weightVarInitialisers, weightPreVarInitialisers, weightPostVarInitialisers,
                                    PostsynapticModel::getInstance(), postsynapticParamValues, postsynapticVarInitialisers,
                                    connectivityInitialiser);
    }


    template<typename WeightUpdateModel, typename PostsynapticModel>
    SynapseGroup *addSynapsePopulation(const std::string &name, SynapseMatrixType mtype, unsigned int delaySteps, const std::string& src, const std::string& trg,
                                       const typename WeightUpdateModel::ParamValues &weightParamValues, const typename WeightUpdateModel::VarValues &weightVarInitialisers, const typename WeightUpdateModel::PreVarValues &weightPreVarInitialisers, const typename WeightUpdateModel::PostVarValues &weightPostVarInitialisers,
                                       const typename PostsynapticModel::ParamValues &postsynapticParamValues, const typename PostsynapticModel::VarValues &postsynapticVarInitialisers,
                                       const InitSparseConnectivitySnippet::Init &connectivityInitialiser = uninitialisedConnectivity())
    {
        return addSynapsePopulation(name, mtype, delaySteps, src, trg,
                                    WeightUpdateModel::getInstance(), weightParamValues, weightVarInitialisers, weightPreVarInitialisers, weightPostVarInitialisers,
                                    PostsynapticModel::getInstance(), postsynapticParamValues, postsynapticVarInitialisers,
                                    connectivityInitialiser);

    }


    template<typename WeightUpdateModel, typename PostsynapticModel>
    SynapseGroup *addSynapsePopulation(const std::string &name, SynapseMatrixType mtype, unsigned int delaySteps, const std::string& src, const std::string& trg,
                                       const typename WeightUpdateModel::ParamValues &weightParamValues, const typename WeightUpdateModel::VarValues &weightVarInitialisers, const typename WeightUpdateModel::PreVarValues &weightPreVarInitialisers, const typename WeightUpdateModel::PostVarValues &weightPostVarInitialisers,
                                       const typename PostsynapticModel::ParamValues &postsynapticParamValues, const typename PostsynapticModel::VarValues &postsynapticVarInitialisers,
                                       const InitToeplitzConnectivitySnippet::Init &connectivityInitialiser)
    {
        return addSynapsePopulation(name, mtype, delaySteps, src, trg,
                                    WeightUpdateModel::getInstance(), weightParamValues, weightVarInitialisers, weightPreVarInitialisers, weightPostVarInitialisers,
                                    PostsynapticModel::getInstance(), postsynapticParamValues, postsynapticVarInitialisers,
                                    connectivityInitialiser);

    }

    

    template<typename PostsynapticModel>
    SynapseGroup *addSlaveSynapsePopulation(const std::string &name, const std::string &weightSharingMasterName, unsigned int delaySteps, const std::string &src, const std::string &trg,
                                            const PostsynapticModel *psm, const typename PostsynapticModel::ParamValues &postsynapticParamValues, const typename PostsynapticModel::VarValues &postsynapticVarInitialisers)
    {
        // Get source and target neuron groups
        auto srcNeuronGrp = findNeuronGroupInternal(src);
        auto trgNeuronGrp = findNeuronGroupInternal(trg);

        // Find weight sharing master group
        auto masterGrp = findSynapseGroupInternal(weightSharingMasterName);
        const auto *wum = masterGrp->getWUModel();

        // If the weight sharing master has individuak weights and any are read-write, give error
        const auto wumVars = wum->getVars();
        if((masterGrp->getMatrixType() & SynapseMatrixWeight::INDIVIDUAL) &&
           std::any_of(wumVars.cbegin(), wumVars.cend(), 
                       [](const Models::Base::Var &v) 
                       { 
                           return (v.access == VarAccess::READ_WRITE); 
                       }))
        {
            throw std::runtime_error("Individual synapse variables can only be shared if they are read-only");
        }

        // Check that population sizes match
        if ((srcNeuronGrp->getNumNeurons() != masterGrp->getSrcNeuronGroup()->getNumNeurons())
            || (trgNeuronGrp->getNumNeurons() != masterGrp->getTrgNeuronGroup()->getNumNeurons()))
        {
            throw std::runtime_error("Size of populations connected by shared weights must match");
        }

        // If weight update model has any pre or postsynaptic variables, give error
        // **THINK** this could be supported but quite what the semantics are is ambiguous
        if(!wum->getPreVars().empty() || !wum->getPostVars().empty()) {
            throw std::runtime_error("Synapse groups with pre and postsynpatic variables cannot be shared");
        }

        // Add synapse group to map
        auto uninitialisedToeplitz = InitToeplitzConnectivitySnippet::Init(InitToeplitzConnectivitySnippet::Uninitialised::getInstance(), {});
        auto result = m_LocalSynapseGroups.emplace(
            std::piecewise_construct,
            std::forward_as_tuple(name),
            std::forward_as_tuple(name, masterGrp, masterGrp->getMatrixType(), delaySteps,
                                  wum, masterGrp->getWUParams(), masterGrp->getWUVarInitialisers(), masterGrp->getWUPreVarInitialisers(), masterGrp->getWUPostVarInitialisers(),
                                  psm, postsynapticParamValues.getInitialisers(), postsynapticVarInitialisers.getInitialisers(),
                                  srcNeuronGrp, trgNeuronGrp, masterGrp->getConnectivityInitialiser(), uninitialisedToeplitz,
                                  m_DefaultVarLocation, m_DefaultExtraGlobalParamLocation, m_DefaultSparseConnectivityLocation, m_DefaultNarrowSparseIndEnabled));

        if(!result.second) {
            throw std::runtime_error("Cannot add a synapse population with duplicate name:" + name);
        }
        else {
            return &result.first->second;
        }
    }


    template<typename PostsynapticModel>
    SynapseGroup *addSlaveSynapsePopulation(const std::string &name, const std::string &weightSharingMasterName, unsigned int delaySteps, const std::string &src, const std::string &trg,
                                            const typename PostsynapticModel::ParamValues &postsynapticParamValues, const typename PostsynapticModel::VarValues &postsynapticVarInitialisers)
    {
        return addSlaveSynapsePopulation(name, weightSharingMasterName, delaySteps, src, trg,
                                         PostsynapticModel::getInstance(), postsynapticParamValues, postsynapticVarInitialisers);
    }

    // PUBLIC CURRENT SOURCE FUNCTIONS
    //================================
    CurrentSource *findCurrentSource(const std::string &name);


    template<typename CurrentSourceModel>
    CurrentSource *addCurrentSource(const std::string &currentSourceName, const CurrentSourceModel *model,
                                    const std::string &targetNeuronGroupName,
                                    const typename CurrentSourceModel::ParamValues &paramValues,
                                    const typename CurrentSourceModel::VarValues &varInitialisers)
    {
        auto targetGroup = findNeuronGroupInternal(targetNeuronGroupName);

        // Add current source to map
        auto result = m_LocalCurrentSources.emplace(std::piecewise_construct,
            std::forward_as_tuple(currentSourceName),
            std::forward_as_tuple(currentSourceName, model, paramValues.getInitialisers(),
                                  varInitialisers.getInitialisers(), targetGroup, 
                                  m_DefaultVarLocation, m_DefaultExtraGlobalParamLocation));

        if(!result.second) {
            throw std::runtime_error("Cannot add a current source with duplicate name:" + currentSourceName);
        }
        else {
            targetGroup->injectCurrent(&result.first->second);
            return &result.first->second;
        }
    }


    template<typename CurrentSourceModel>
    CurrentSource *addCurrentSource(const std::string &currentSourceName, const std::string &targetNeuronGroupName,
                                    const typename CurrentSourceModel::ParamValues &paramValues,
                                    const typename CurrentSourceModel::VarValues &varInitialisers)
    {
        return addCurrentSource<CurrentSourceModel>(currentSourceName, CurrentSourceModel::getInstance(),
                                targetNeuronGroupName, paramValues, varInitialisers);
    }


    template<typename CustomUpdateModel>
    CustomUpdate *addCustomUpdate(const std::string &name, const std::string &updateGroupName, const CustomUpdateModel *model,
                                  const typename CustomUpdateModel::ParamValues &paramValues,
                                  const typename CustomUpdateModel::VarValues &varInitialisers,
                                  const typename CustomUpdateModel::VarReferences &varReferences,
                                  const typename CustomUpdateModel::EGPReferences &egpReferences = {})
    {
         // Add neuron group to map
        auto result = m_CustomUpdates.emplace(std::piecewise_construct,
            std::forward_as_tuple(name),
            std::forward_as_tuple(name, updateGroupName, model,
                                  paramValues.getInitialisers(), varInitialisers.getInitialisers(), varReferences.getInitialisers(),
                                  egpReferences.getInitialisers(), m_DefaultVarLocation, m_DefaultExtraGlobalParamLocation));

        if(!result.second) {
            throw std::runtime_error("Cannot add a custom update with duplicate name:" + name);
        }
        else {
            return &result.first->second;
        }
    }


    template<typename CustomUpdateModel>
    CustomUpdateWU *addCustomUpdate(const std::string &name, const std::string &updateGroupName,
                                    const CustomUpdateModel *model, const typename CustomUpdateModel::ParamValues &paramValues,
                                    const typename CustomUpdateModel::VarValues &varInitialisers,
                                    const typename CustomUpdateModel::WUVarReferences &varReferences,
                                    const typename CustomUpdateModel::EGPReferences &egpReferences = {})
    {
        // Add neuron group to map
        auto result = m_CustomWUUpdates.emplace(std::piecewise_construct,
            std::forward_as_tuple(name),
            std::forward_as_tuple(name, updateGroupName, model,
                                  paramValues.getInitialisers(), varInitialisers.getInitialisers(), varReferences.getInitialisers(),
                                  egpReferences.getInitialisers(), m_DefaultVarLocation, m_DefaultExtraGlobalParamLocation));

        if(!result.second) {
            throw std::runtime_error("Cannot add a custom update with duplicate name:" + name);
        }
        else {
            return &result.first->second;
        }
    }


    template<typename CustomUpdateModel>
    CustomUpdate *addCustomUpdate(const std::string &name, const std::string &updateGroupName,
                                  const typename CustomUpdateModel::ParamValues &paramValues,
                                  const typename CustomUpdateModel::VarValues &varInitialisers,
                                  const typename CustomUpdateModel::VarReferences &varReferences,
                                  const typename CustomUpdateModel::EGPReferences &egpReferences = {})
    {
        return addCustomUpdate<CustomUpdateModel>(name, updateGroupName, CustomUpdateModel::getInstance(),
                                                  paramValues, varInitialisers, varReferences, egpReferences);
    }



    template<typename CustomUpdateModel>
    CustomUpdateWU *addCustomUpdate(const std::string &name, const std::string &updateGroupName,
                                    const typename CustomUpdateModel::ParamValues &paramValues,
                                    const typename CustomUpdateModel::VarValues &varInitialisers,
                                    const typename CustomUpdateModel::WUVarReferences &varReferences,
                                    const typename CustomUpdateModel::EGPReferences &egpReferences = {})
    {
        return addCustomUpdate<CustomUpdateModel>(name, updateGroupName, CustomUpdateModel::getInstance(),
                                                  paramValues, varInitialisers, varReferences, egpReferences);
    }

protected:
    //--------------------------------------------------------------------------
    // Protected methods
    //--------------------------------------------------------------------------
    void finalize();

    //--------------------------------------------------------------------------
    // Protected const methods
    //--------------------------------------------------------------------------
    std::string scalarExpr(double) const;

    bool zeroCopyInUse() const;

    bool isRecordingInUse() const;

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

    const std::map<std::string, NeuronGroupInternal> &getNeuronGroups() const{ return m_LocalNeuronGroups; }

    const std::map<std::string, SynapseGroupInternal> &getSynapseGroups() const{ return m_LocalSynapseGroups; }

    const std::map<std::string, CurrentSourceInternal> &getLocalCurrentSources() const{ return m_LocalCurrentSources; }

    const std::map<std::string, CustomUpdateInternal> &getCustomUpdates() const { return m_CustomUpdates; }
    const std::map<std::string, CustomUpdateWUInternal> &getCustomWUUpdates() const { return m_CustomWUUpdates; }

private:
    //--------------------------------------------------------------------------
    // Private methods
    //--------------------------------------------------------------------------
    NeuronGroupInternal *findNeuronGroupInternal(const std::string &name);
    
    SynapseGroupInternal *findSynapseGroupInternal(const std::string &name);

    template<typename WeightUpdateModel, typename PostsynapticModel>
    SynapseGroup *addSynapsePopulation(const std::string &name, SynapseMatrixType mtype, unsigned int delaySteps, const std::string& src, const std::string& trg,
                                       const WeightUpdateModel *wum, const typename WeightUpdateModel::ParamValues &weightParamValues, const typename WeightUpdateModel::VarValues &weightVarInitialisers, const typename WeightUpdateModel::PreVarValues &weightPreVarInitialisers, const typename WeightUpdateModel::PostVarValues &weightPostVarInitialisers,
                                       const PostsynapticModel *psm, const typename PostsynapticModel::ParamValues &postsynapticParamValues, const typename PostsynapticModel::VarValues &postsynapticVarInitialisers,
                                       const InitSparseConnectivitySnippet::Init &connectivityInitialiser, const InitToeplitzConnectivitySnippet::Init &toeplitzConnectivityInitialiser)
    {
        // Get source and target neuron groups
        auto srcNeuronGrp = findNeuronGroupInternal(src);
        auto trgNeuronGrp = findNeuronGroupInternal(trg);

        // Add synapse group to map
        auto result = m_LocalSynapseGroups.emplace(
            std::piecewise_construct,
            std::forward_as_tuple(name),
            std::forward_as_tuple(name, nullptr, mtype, delaySteps,
                                  wum, weightParamValues.getInitialisers(), weightVarInitialisers.getInitialisers(), weightPreVarInitialisers.getInitialisers(), weightPostVarInitialisers.getInitialisers(),
                                  psm, postsynapticParamValues.getInitialisers(), postsynapticVarInitialisers.getInitialisers(),
                                  srcNeuronGrp, trgNeuronGrp,
                                  connectivityInitialiser, toeplitzConnectivityInitialiser, 
                                  m_DefaultVarLocation, m_DefaultExtraGlobalParamLocation,
                                  m_DefaultSparseConnectivityLocation, m_DefaultNarrowSparseIndEnabled));

        if(!result.second) {
            throw std::runtime_error("Cannot add a synapse population with duplicate name:" + name);
        }
        else {
            return &result.first->second;
        }
    }

    //--------------------------------------------------------------------------
    // Private members
    //--------------------------------------------------------------------------
    std::map<std::string, NeuronGroupInternal> m_LocalNeuronGroups;

    std::map<std::string, SynapseGroupInternal> m_LocalSynapseGroups;

    std::map<std::string, CurrentSourceInternal> m_LocalCurrentSources;

    std::map<std::string, CustomUpdateInternal> m_CustomUpdates;
    std::map<std::string, CustomUpdateWUInternal> m_CustomWUUpdates;

    std::string m_Name;

    std::string m_Precision;

    TimePrecision m_TimePrecision;

    double m_DT;

    bool m_TimingEnabled;

    unsigned int m_Seed;

    VarLocation m_DefaultVarLocation;

    VarLocation m_DefaultExtraGlobalParamLocation;

    VarLocation m_DefaultSparseConnectivityLocation; 

    bool m_DefaultNarrowSparseIndEnabled;


    bool m_ShouldFusePostsynapticModels; 
    

    bool m_ShouldFusePrePostWeightUpdateModels;

    unsigned int m_BatchSize;
};

// Typedefine NNmodel for backward compatibility
typedef ModelSpec NNmodel;