snn_datastructures.h

Go to the documentation of this file.

/* * Copyright (c) 2016 Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* 3. The names of its contributors may not be used to endorse or promote
*    products derived from this software without specific prior written
*    permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* *********************************************************************************************** *
* CARLsim
* created by: (MDR) Micah Richert, (JN) Jayram M. Nageswaran
* maintained by:
* (MA) Mike Avery <averym@uci.edu>
* (MB) Michael Beyeler <mbeyeler@uci.edu>,
* (KDC) Kristofor Carlson <kdcarlso@uci.edu>
* (TSC) Ting-Shuo Chou <tingshuc@uci.edu>
* (HK) Hirak J Kashyap <kashyaph@uci.edu>
*
* CARLsim v1.0: JM, MDR
* CARLsim v2.0/v2.1/v2.2: JM, MDR, MA, MB, KDC
* CARLsim3: MB, KDC, TSC
* CARLsim4: TSC, HK
* CARLsim5: HK, JX, KC
* CARLsim6: LN, JX, KC, KW
*
* CARLsim available from http://socsci.uci.edu/~jkrichma/CARLsim/
* Ver 12/31/2021
*/

#ifndef _SNN_DATASTRUCTURES_H_
#define _SNN_DATASTRUCTURES_H_



// include CUDA version-dependent macros and include files
#ifndef __NO_CUDA__
    #include <cuda_version_control.h>
    #include <curand.h>
#endif




enum MemType {
    CPU_MEM,     
    GPU_MEM,     
};

enum conType_t { CONN_RANDOM, CONN_ONE_TO_ONE, CONN_FULL, CONN_FULL_NO_DIRECT, CONN_GAUSSIAN, CONN_USER_DEFINED, CONN_UNKNOWN};

enum SNNState {
    CONFIG_SNN,
    COMPILED_SNN,
    PARTITIONED_SNN,
    EXECUTABLE_SNN
};

typedef struct DelayInfo_s {
    short  delay_index_start;
    short  delay_length;
} DelayInfo;

typedef struct SynInfo_s {
    int gsId; 
    int nId; 
} SynInfo;

typedef struct STDPConfig_s {
    STDPConfig_s() : WithSTDP(false), WithESTDP(false), WithISTDP(false),
        WithESTDPtype(UNKNOWN_STDP), WithISTDPtype(UNKNOWN_STDP), WithESTDPcurve(UNKNOWN_CURVE), WithISTDPcurve(UNKNOWN_CURVE)
    {}
    bool WithSTDP;
    bool WithESTDP;             // LN2021 FIXME: consolidate E/I as it is connection based now
    bool WithISTDP;
    STDPType WithESTDPtype;     // LN2021 FIXME: dito
    STDPType WithISTDPtype;     
    STDPCurve WithESTDPcurve;   // LN2021 FIXME: dito
    STDPCurve WithISTDPcurve;
    float        TAU_PLUS_INV_EXC;
    float        TAU_MINUS_INV_EXC;
    float        ALPHA_PLUS_EXC;
    float        ALPHA_MINUS_EXC;
    float        GAMMA;     // LN2021 FIXME: apply unit (C++11) or variant (C++17)
    float        KAPPA;     
    float        OMEGA;     
    float        TAU_PLUS_INV_INB;      // LN2021 FIXME : redundant, see dito
    float        TAU_MINUS_INV_INB; 
    float        ALPHA_PLUS_INB;    
    float        ALPHA_MINUS_INB;   
    float        BETA_LTP;          // LN2021 FIXME: variant
    float        BETA_LTD;          
    float        LAMBDA;
    float        DELTA;
#ifdef LN_I_CALC_TYPES
    // PKA_PLC_MOD              // LN2021 FIXME: when applying variant
    int          NM_PKA;
    int          NM_PLC;
    float        W_PLC;
    float        W_PKA;
#endif
} STDPConfig;

typedef struct STPConfig_s {
    STPConfig_s() : WithSTP(false), STP_A(-1.0f), STP_U(-1.0f), STP_tau_u_inv(-1.0f), STP_tau_x_inv(-1.0f)
    {}

    bool WithSTP;
    float STP_A; // scaling factor
    float STP_U;
    float STP_tau_u_inv; // facilitatory
    float STP_tau_x_inv; // depressive
} STPConfig;

typedef struct HomeostasisConfig_s {
    HomeostasisConfig_s() : WithHomeostasis(false), baseFiring(-1.0f), baseFiringSD(-1.0f),
                            avgTimeScale(-1.0f), avgTimeScaleInv(-1.0f), avgTimeScaleDecay(-1.0f),
                            homeostasisScale(-1.0f)
    {}

    bool WithHomeostasis;
    float baseFiring;
    float baseFiringSD;
    float avgTimeScale;
    float avgTimeScaleInv;
    float avgTimeScaleDecay;
    float homeostasisScale;
} HomeostasisConfig;

typedef struct NeuromodulatorConfig_s {
    NeuromodulatorConfig_s() : baseDP(1.0f), base5HT(1.0f), baseACh(1.0f), baseNE(1.0f),
        decayDP(0.99f), decay5HT(0.99f), decayACh(0.99f), decayNE(0.99f),
        releaseDP(0.04f), release5HT(0.04f), releaseACh(0.04f), releaseNE(0.04f),
        activeDP(true), active5HT(true), activeACh(true), activeNE(true)
    {}

    float baseDP;   
    float base5HT;  
    float baseACh;  
    float baseNE;   
    
    float decayDP;  
    float decay5HT; 
    float decayACh; 
    float decayNE;  

    float       releaseDP;      
    float       release5HT;     
    float       releaseACh;     
    float       releaseNE;      

    bool        activeDP;       
    bool        active5HT;      
    bool        activeACh;      
    bool        activeNE;       
} NeuromodulatorConfig;

#ifdef LN_I_CALC_TYPES
typedef struct ConductanceConfig_s {
    ConductanceConfig_s(): dAMPA(.0), rNMDA(.0), dNMDA(.0), sNMDA(.0), dGABAa(.0), rGABAb(.0), dGABAb(.0), sGABAb(.0) {};
    // rollbacked back, due to .. backward compatibilty,  needs to be copied from sim / network like ... icalctype  see \todo   compileNetwork ... setupNetwork etc
    // apply same defaults as in SNNinit former global .. to ensure backward compatibility (deprecated)
    //ConductanceConfig_s() {
    //  dAMPA = float(1.0 - 1.0 / 5.0);     // some default decay and rise times
    //  rNMDA = float(1.0 - 1.0 / 10.0);
    //  dNMDA = float(1.0 - 1.0 / 150.0);
    //  sNMDA = float(1.0);
    //  dGABAa = float(1.0 - 1.0 / 6.0);
    //  rGABAb = float(1.0 - 1.0 / 100.0);
    //  dGABAb = float(1.0 - 1.0 / 150.0);
    //  sGABAb = float(1.0);
    //};

    float dAMPA;             
    float rNMDA;             
    float dNMDA;             
    float sNMDA;             
    float dGABAa;            
    float rGABAb;            
    float dGABAb;            
    float sGABAb;            
} ConductanceConfig;




typedef struct ACNE12Config_s {
    ACNE12Config_s() : p1(.0f), p2(.0f) {};
    float p1;            
    float p2;            
} ACNE12Config;
 
typedef struct NM4wConfig_s {
    float w[NM_NE+3] = { 1.f, 1.f, 1.f, 1.f, 0.25f, 1.0f }; 
} NM4wConfig;

typedef struct NM4STPConfig_s {
    bool WithNM4STP                 = false;
    float w_STP_U[NM_NE + 3]        = { 1.f, 0.f, 0.f, 0.f, 1.f, 1.f };
    float w_STP_tau_u[NM_NE + 3]    = { 1.f, 0.f, 0.f, 0.f, 1.f, 1.f };
    float w_STP_tau_x[NM_NE + 3]    = { 1.f, 0.f, 0.f, 0.f, 1.f, 1.f };
} NM4STPConfig;


#endif



typedef struct ConnectionInfo_s {
    int grpSrc;
    int grpDest;
    int nSrc;
    int nDest;
    int srcGLoffset;
    float initWt;
    float maxWt;
    int preSynId;
    short int connId;
    uint8_t delay;
    // bool withSTDP;

    bool operator== (const struct ConnectionInfo_s& conn) {
        return (nSrc + srcGLoffset == conn.nSrc);
    }
} ConnectionInfo;

typedef struct ConnectConfig_s
{
#ifdef LN_I_CALC_TYPES
    ConnectConfig_s(): icalcType(UNKNOWN_ICALC) {};
#endif
    int                      grpSrc;
    int                      grpDest;
    uint8_t                  maxDelay;
    uint8_t                  minDelay;
    float                    maxWt;
    float                    initWt;
    float                    minWt;
    RadiusRF                 connRadius;
    float                    mulSynFast; 
    float                    mulSynSlow; 
    int                      connectionMonitorId; // ToDo: move to ConnectConfigMD
    uint32_t                 connProp;
    ConnectionGeneratorCore* conn;
    conType_t                type;
    float                    connProbability; 
    short int                connId; 
    int                      numberOfConnections; // ToDo: move to ConnectConfigMD
    STDPConfig stdpConfig;
#ifdef LN_I_CALC_TYPES
    IcalcType                icalcType; 
#endif
} ConnectConfig;

typedef struct ConnectConfigMD_s {
    ConnectConfigMD_s() : gConnId(-1), lConnId(-1), connectionMonitorId(-1), numberOfConnections(-1)
    {}
    int gConnId;
    int lConnId;
    int connectionMonitorId;
    int numberOfConnections;
} ConnectConfigMD;

typedef struct ConnectConfigRT_s {

    float* mulSynFast; 
    float* mulSynSlow; 

    int          grpSrc;
    int          grpDest;

    // LN2021 FIXME refact   ptxas error : File uses too much global constant data (0x105c0 bytes, 0x10000 max)

    bool         WithSTDP;          
    bool         WithESTDP;         
    bool         WithISTDP;         
    STDPType     WithESTDPtype;     
    STDPType     WithISTDPtype;     
    STDPCurve    WithESTDPcurve;    
    STDPCurve    WithISTDPcurve;    
    float        TAU_PLUS_INV_EXC;  
    float        TAU_MINUS_INV_EXC; 
    float        ALPHA_PLUS_EXC;    
    float        ALPHA_MINUS_EXC;   
    float        GAMMA;             
    float        KAPPA;             
    float        OMEGA;             
    float        TAU_PLUS_INV_INB;  
    float        TAU_MINUS_INV_INB; 
    float        ALPHA_PLUS_INB;    
    float        ALPHA_MINUS_INB;   
    float        BETA_LTP;          
    float        BETA_LTD;          
    float        LAMBDA;            
    float        DELTA;             
#ifdef LN_I_CALC_TYPES
    int          NM_PKA;            
    int          NM_PLC;            
    float        W_PKA;             
    float        W_PLC;             
    IcalcType    icalcType;         
#endif
} ConnectConfigRT;

typedef struct compConnectionInfo_s {
    int                             grpSrc, grpDest;
    short int                       connId;
}compConnectionInfo;

typedef struct compConnectConfig_s {
    int                         grpSrc, grpDest;
    short int                   connId;
} compConnectConfig;

typedef struct NeuralDynamicsConfig_s {
    NeuralDynamicsConfig_s() : Izh_a(-1.0f), Izh_a_sd(-1.0f), Izh_b(-1.0f), Izh_b_sd(-1.0f),
                               Izh_c(-1.0f), Izh_c_sd(-1.0f), Izh_d(-1.0f), Izh_d_sd(-1.0f),
                               Izh_C(-1.0f), Izh_C_sd(-1.0f), Izh_k(-1.0f), Izh_k_sd(-1.0f),
                               Izh_vr(-1.0f), Izh_vr_sd(1.0f), Izh_vt(1.0f), Izh_vt_sd(-1.0f),
                               Izh_vpeak(-1.0f), Izh_vpeak_sd(-1.0f), lif_tau_m(-1), 
                               lif_tau_ref(-1), lif_vTh(1.0f), lif_vReset(0.0f), lif_minRmem(1.0f),
                               lif_maxRmem(1.0f)
    {}
    float       Izh_C;
    float       Izh_C_sd;
    float       Izh_k;
    float       Izh_k_sd;
    float       Izh_vr;
    float       Izh_vr_sd;
    float       Izh_vt;
    float       Izh_vt_sd;
    float       Izh_vpeak;
    float       Izh_vpeak_sd;
    float       Izh_a;
    float       Izh_a_sd;
    float       Izh_b;
    float       Izh_b_sd;
    float       Izh_c;
    float       Izh_c_sd;
    float       Izh_d;
    float       Izh_d_sd;
    int         lif_tau_m; 
    int         lif_tau_ref;
    float       lif_vTh;
    float       lif_vReset;
    double      lif_minRmem;
    double      lif_maxRmem;
} NeuralDynamicsConfig;

typedef struct GroupConfig_s {
    GroupConfig_s() : grpName("N/A"), preferredNetId(-2), type(0), numN(-1), isSpikeGenerator(false), spikeGenFunc(NULL), 
    WithSTDP(false), WithDA_MOD(false)
#ifdef LN_I_CALC_TYPES
        , icalcType(UNKNOWN_ICALC)
        , with_NMDA_rise(false)
        , with_GABAb_rise(false)
#endif
#ifdef LN_AXON_PLAST    
        , WithAxonPlast(false) 
        , AxonPlast_TAU(25)
#endif
    {}

    // properties of neural group size and location
    std::string  grpName;
    int          preferredNetId;
    unsigned int type;
    int          numN;
    bool isSpikeGenerator;
    bool withParamModel_9; 
    bool isLIF;
    bool withCompartments;

    float compCouplingUp;
    float compCouplingDown;

    bool WithSTDP;      
    bool WithDA_MOD;    
#ifdef LN_I_CALC_TYPES
    bool WithPKA_PLC_MOD; // 
#endif

    SpikeGeneratorCore* spikeGenFunc;

    Grid3D grid; //<! location information of neurons
    NeuralDynamicsConfig neuralDynamicsConfig;
    // STDPConfig stdpConfig;
    STPConfig stpConfig;
    HomeostasisConfig homeoConfig;
    NeuromodulatorConfig neuromodulatorConfig;
#ifdef LN_I_CALC_TYPES
    IcalcType icalcType;  
    bool with_NMDA_rise;  
    bool with_GABAb_rise; 
    ConductanceConfig conductanceConfig; 
    ACNE12Config acneConfig; 
    NM4wConfig nm4wConfig; 
    NM4STPConfig nm4StpConfig;  
#endif
#ifdef LN_AXON_PLAST
    bool WithAxonPlast; // 2022 VTE, Wavefront
    int AxonPlast_TAU; // tau of the eligibity trace, e.g. 10, e_i(t+1) = e_i(t)(1.0f - 1.0f/AxonPlast_TAU)
#endif
} GroupConfig;

typedef struct GroupConfigMD_s {
    GroupConfigMD_s() : gGrpId(-1), gStartN(-1), gEndN(-1),
                        lGrpId(-1), lStartN(-1), lEndN(-1),
                        netId(-1), maxOutgoingDelay(1), fixedInputWts(true), hasExternalConnect(false),
                        LtoGOffset(0), GtoLOffset(0), numPostSynapses(0), numPreSynapses(0), Noffset(0),
                        spikeMonitorId(-1), neuronMonitorId(-1), groupMonitorId(-1), currTimeSlice(1000), sliceUpdateTime(0), homeoId(-1), ratePtr(NULL)
    {}

    int gGrpId;
    int gStartN;
    int gEndN;
    int netId;
    int lGrpId;
    int lStartN;
    int lEndN;
    int LtoGOffset;
    int GtoLOffset;
    int numPostSynapses;
    int numPreSynapses;
    int maxOutgoingDelay;
    bool fixedInputWts;
    bool hasExternalConnect;
    int spikeMonitorId;
    int neuronMonitorId;
    int groupMonitorId;
    float refractPeriod;
    int currTimeSlice; 
    int sliceUpdateTime;
    int homeoId;
    int Noffset; 
    PoissonRate* ratePtr;

    bool operator== (const struct GroupConfigMD_s& grp) {
        return (gGrpId == grp.gGrpId);
    }
} GroupConfigMD;

typedef struct GroupConfigRT_s {
    int          netId;         
    int          gGrpId;        
    int          gStartN;       
    int          gEndN;         
    int          lGrpId;        
    int          lStartN;       
    int          lEndN;         
    int          LtoGOffset;    
    int          GtoLOffset;    
    unsigned int Type;          
    int          numN;          
    int          numPostSynapses;   
    int          numPreSynapses;    
    bool         isSpikeGenerator;  
    bool         isSpikeGenFunc;    
    bool         WithSTP;           
    bool         WithSTDP;          
    bool         WithDA_MOD;  // \todo LN smell
    // bool         WithESTDP;         //!< published by GroupConfig \sa GroupConfig
    // bool         WithISTDP;         //!< published by GroupConfig \sa GroupConfig
    // STDPType     WithESTDPtype;     //!< published by GroupConfig \sa GroupConfig
    // STDPType     WithISTDPtype;     //!< published by GroupConfig \sa GroupConfig
    // STDPCurve    WithESTDPcurve;    //!< published by GroupConfig \sa GroupConfig
    // STDPCurve    WithISTDPcurve;    //!< published by GroupConfig \sa GroupConfig
    bool         WithHomeostasis;   
    bool         FixedInputWts;     
    bool         hasExternalConnect;
    int          Noffset;           
    int8_t       MaxDelay;          

    float        STP_A;             
    float        STP_U;             
    float        STP_tau_u_inv;     
    float        STP_tau_x_inv;     
    // float        TAU_PLUS_INV_EXC;  //!< published by GroupConfig \sa GroupConfig
    // float        TAU_MINUS_INV_EXC; //!< published by GroupConfig \sa GroupConfig
    // float        ALPHA_PLUS_EXC;    //!< published by GroupConfig \sa GroupConfig
    // float        ALPHA_MINUS_EXC;   //!< published by GroupConfig \sa GroupConfig
    // float        GAMMA;             //!< published by GroupConfig \sa GroupConfig
    // float        KAPPA;             //!< published by GroupConfig \sa GroupConfig
    // float        OMEGA;             //!< published by GroupConfig \sa GroupConfig
    // float        TAU_PLUS_INV_INB;  //!< published by GroupConfig \sa GroupConfig
    // float        TAU_MINUS_INV_INB; //!< published by GroupConfig \sa GroupConfig
    // float        ALPHA_PLUS_INB;    //!< published by GroupConfig \sa GroupConfig
    // float        ALPHA_MINUS_INB;   //!< published by GroupConfig \sa GroupConfig
    // float        BETA_LTP;          //!< published by GroupConfig \sa GroupConfig
    // float        BETA_LTD;          //!< published by GroupConfig \sa GroupConfig
    // float        LAMBDA;            //!< published by GroupConfig \sa GroupConfig
    // float        DELTA;             //!< published by GroupConfig \sa GroupConfig

    float avgTimeScale;             
    float avgTimeScale_decay;       
    float avgTimeScaleInv;          
    float homeostasisScale;         

                                    // parameters of neuromodulator
    float baseDP;  
    float base5HT; 
    float baseACh; 
    float baseNE;  
    float decayDP; 
    float decay5HT;
    float decayACh;
    float decayNE; 
    float       releaseDP;      
    float       release5HT;     
    float       releaseACh;     
    float       releaseNE;      
    bool        activeDP;       
    bool        active5HT;      
    bool        activeACh;      
    bool        activeNE;       

    bool withParamModel_9; 
    bool isLIF; 

    bool withCompartments;
    float compCouplingUp;
    float compCouplingDown;
    int   compNeighbors[4];
    float compCoupling[4];
    short numCompNeighbors;

#ifdef LN_I_CALC_TYPES  
    unsigned int icalcType; 
    bool with_NMDA_rise;    
    bool with_GABAb_rise;   
    // flattened struct ConductanceConfig (GroupConfig.conductanceConfig)
    float dAMPA;             
    float rNMDA;             
    float dNMDA;             
    float sNMDA;             
    float dGABAa;            
    float rGABAb;            
    float dGABAb;            
    float sGABAb;            
    // flattened struct ACNE12Config (GroupConfig.acne12Config)
    float acne12p1;          
    float acne12p2;          
    // flattened struct NM4wConfig (GroupConfig.nm4wConfig)
    float nm4w[NM_NE+3];     
    
    //flattend struct NM4STPConfig (GroupConfig.nm4StpConfig), requires MAX_GRP_PER_SNN << 128
    bool WithNM4STP;             
    float wstpu[NM_NE + 3];      
    float wstptauu[NM_NE + 3];   
    float wstptaux[NM_NE + 3];   

    //flattend struct NM4STPConfig for MAX_GRP_PER_SNN << 2^16
    // GPU issue:  ptxas error : File uses too much global constant data (0x12140 bytes, 0x10000 max)
    //NM4STPConfig* nm4stp;          //!< Array size = last index + 1 + additional elementsnorm + base

#endif

#ifdef LN_AXON_PLAST
    bool    WithAxonPlast;
    int     AxonPlast_TAU;
#endif


} GroupConfigRT;

typedef struct RuntimeData_s {
    unsigned int spikeCountSec;   
    unsigned int spikeCountD1Sec; 
    unsigned int spikeCountD2Sec; 
    unsigned int spikeCountExtRxD1Sec;
    unsigned int spikeCountExtRxD2Sec;
    unsigned int spikeCount;      
    unsigned int spikeCountD1;    
    unsigned int spikeCountD2;    
    unsigned int nPoissonSpikes;  
    unsigned int spikeCountLastSecLeftD2; 
    unsigned int spikeCountExtRxD2; 
    unsigned int spikeCountExtRxD1; 

    float* voltage; 
    float* nextVoltage; 
    float* recovery;
    float* Izh_C;
    float* Izh_k;
    float* Izh_vr;
    float* Izh_vt;
    float* Izh_vpeak;
    float* Izh_a;
    float* Izh_b;
    float* Izh_c;
    float* Izh_d;
    float* current;
    float* totalCurrent;
    float* extCurrent;
    
    int* lif_tau_m; 
    int* lif_tau_ref;
    int* lif_tau_ref_c; // current refractory of the neuron
    float* lif_vTh;
    float* lif_vReset;
    float* lif_gain;
    float* lif_bias;

    bool* curSpike;

#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVEL
    // conductances and stp values
    float* gNMDA;   
    float* gNMDA_r;
    float* gNMDA_d;
    float* gAMPA;   
    float* gGABAa;  
    float* gGABAb;  
    float* gGABAb_r;
    float* gGABAb_d;

    int* I_set; 

    MemType memType;
    bool allocated; 

    /* Tsodyks & Markram (1998), where the short-term dynamics of synapses is characterized by three parameters:
       U (which roughly models the release probability of a synaptic vesicle for the first spike in a train of spikes),
       maxDelay_ (time constant for recovery from depression), and F (time constant for recovery from facilitation). */
    float* stpx;
    float* stpu;

    unsigned short* Npre;               
    unsigned short* Npre_plastic;       
    float*          Npre_plasticInv;    
    unsigned short* Npost;              

    int* lastSpikeTime; 
    int* synSpikeTime;  

    float* wtChange; 
    float* wt;       
    float* maxSynWt; 
    
    unsigned int* cumulativePost;
    unsigned int* cumulativePre;

    short int* connIdsPreIdx; 
    short int* grpIds;

    SynInfo* postSynapticIds;
    SynInfo* preSynapticIds;

    DelayInfo* postDelayInfo;   
    unsigned int* timeTableD1; 
    unsigned int* timeTableD2; 
    
    int* firingTableD1;
    int* firingTableD2;

#ifdef LN_AXON_PLAST
    unsigned* firingTimesD2; 
#endif

    int** extFiringTableD1; 
    int** extFiringTableD2; 
    
    int* extFiringTableEndIdxD1;
    int* extFiringTableEndIdxD2;

    float* poissonFireRate;
    float* randNum;     
#ifndef __NO_CUDA__
    int2* neuronAllocation;     
    int3* groupIdInfo;          
#endif

    int*  nSpikeCnt;

    float* baseFiringInv; 
    float* baseFiring;
    float* avgFiring;

    float* grpDA;
    float* grp5HT;
    float* grpACh;
    float* grpNE;

    // group monitor assistive buffers
    float* grpDABuffer;
    float* grp5HTBuffer;
    float* grpAChBuffer;
    float* grpNEBuffer;

    // neuron monitor assistive buffers
    float* nVBuffer;
    float* nUBuffer;
    float* nIBuffer;

    unsigned int* spikeGenBits;
#ifndef __NO_CUDA__
    curandGenerator_t gpuRandGen;
#endif
} RuntimeData;

typedef struct GlobalNetworkConfig_s {
    GlobalNetworkConfig_s() : numN(0), numNReg(0), numNPois(0),
                              numNExcReg(0), numNInhReg(0), numNExcPois(0), numNInhPois(0),
                              numSynNet(0), maxDelay(-1), numN1msDelay(0), numN2msDelay(0),
                              simIntegrationMethod(FORWARD_EULER),
                              simNumStepsPerMs(2), timeStep(0.5)
    {}

    int numN;         
    int numNExcReg;   
    int numNInhReg;   
    int numNReg;      
    int numComp;      
    int numNExcPois;  
    int numNInhPois;  
    int numNPois;     
    int numSynNet;    
    int maxDelay;     
    int numN1msDelay; 
    int numN2msDelay; 

    integrationMethod_t simIntegrationMethod; 
    int simNumStepsPerMs;                     
    float timeStep;                           
} GlobalNetworkConfig;


typedef struct NetworkConfigRT_s  {
    // global configuration for maximum axonal delay
    int maxDelay; 

    // configurations for boundries of neural types
    int numN;         
    int numNExcReg;   
    int numNInhReg;   
    int numNReg;      
    int numComp;      
    int numNExcPois;  
    int numNInhPois;  
    int numNPois;     
    int numNSpikeGen; 
    int numNRateGen;  
    int numNExternal; 
    int numNAssigned; 

    // configurations for runtime data sizes
    unsigned int I_setLength; 
    size_t       I_setPitch;  
    size_t       STP_Pitch;   
    int numPostSynNet;        
    int numPreSynNet;         
    int maxNumPostSynN;       
    int maxNumPreSynN;        
    unsigned int maxSpikesD2; 
    unsigned int maxSpikesD1; 

    // configurations for assigned groups and connections
    int numGroups;        
    int numGroupsAssigned; 
    int numConnections;   
    //int numAssignedConnections; //!< number of connections assigned to this local network

    // configurations for execution features
    bool sim_with_fixedwts;
#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVEL
    bool sim_with_conductances;
    bool sim_with_compartments;
    bool sim_with_stdp;
    bool sim_with_modulated_stdp;
    bool sim_with_homeostasis;
    bool sim_with_stp;
    bool sim_in_testing;
    
    // please note that spike monitor and connection monitor don't need this flag because no extra buffer is required
    // for neuron monitor, the kernel allocates extra buffers to store v, u, i values of each monitored neuron
    bool sim_with_nm; // simulation with neuron monitor

    // stdp, da-stdp configurations
    float stdpScaleFactor;
    float wtChangeDecay;   

    // conductance configurations
#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVEL
    bool sim_with_NMDA_rise;  
    bool sim_with_GABAb_rise; 
#ifndef LN_I_CALC_TYPES
    double dAMPA;             
    double rNMDA;             
    double dNMDA;             
    double sNMDA;             
    double dGABAa;            
    double rGABAb;            
    double dGABAb;            
    double sGABAb;            
#endif

    integrationMethod_t simIntegrationMethod; 
    int simNumStepsPerMs;                     
    float timeStep;                           
} NetworkConfigRT;



typedef struct RoutingTableEntry_s {
    RoutingTableEntry_s() : srcNetId(-1), destNetId(-1) {}

    RoutingTableEntry_s(int srcNetId_, int destNetId_) : srcNetId(srcNetId_), destNetId(destNetId_) {}

    int srcNetId;
    int destNetId;

    bool operator== (const struct RoutingTableEntry_s& rte) const {
        return (srcNetId == rte.srcNetId && destNetId == rte.destNetId);
    }
} RoutingTableEntry;



typedef struct ThreadStruct_s {
    void* snn_pointer;
    int netId;
    int lGrpId;
    int startIdx;
    int endIdx;
    int GtoLOffset;
} ThreadStruct;

#endif