snn.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, KC, JX, KW
 *
 * CARLsim available from http://socsci.uci.edu/~jkrichma/CARLsim/
 * Ver 12/31/2016
 */

/*
 * Common Abbreviations used in CARLsim
 * snn/SNN: spiking neural network
 * stp/STP: short-term plasticity
 * stdp/STDP: spike-timing dependent plasticity
 * syn/SYN: synapse
 * wt/WT: weight
 * exc/Exc: excitatory
 * inh/Inh: inhibitory
 * grp: group
 * nid/NId/NID: neuron id
 * gid/GId/GID: group id
 *
 * conn: connection
 * min: minimum
 * max: maximum
 * num: number
 * mem: memory
 * id/Id/ID: identification
 * info: information
 * cnt: count
 * curr: current
 * mon: monitor
 * reg/Reg: regurlar
 * pois/Pois: poisson
 */
#ifndef _SNN_GOLD_H_
#define _SNN_GOLD_H_


//{ LN fixes for CARLsim6
//#define LN_FIX_DA_DECAY_GPU
//#define LN_FIX_DA_DECAY_CPU
//#define LN_FIX_ALL_DECAY_CPU
//#define LN_FIX_ALL_DECAY_GPU
//}

//{ LN feat for CARLsim6
//#define LN_UPDATE_CURSPIKES
//#define LN_UPDATE_CURSPIKES_MT
//}

//{ LN feat for CARLsim6, performance Issue Setup
//#define LN_FIX_CONNLIST_
//#define LN_SETUP_NETWORK_MT;  // featFastSetup LN 20201108
//}


#include <map>
#include <list>
#include <cmath>
#include <cstring>
#include <cassert>
#include <cstdio>
#include <climits>

// experimental
#include <mutex>

#include <carlsim.h>
#include <callback_core.h>

#include <snn_definitions.h>
#include <snn_datastructures.h>

// #include <spike_buffer.h>
#include <poisson_rate.h>

class SpikeMonitor;
class SpikeMonitorCore;
class NeuronMonitor;
class NeuronMonitorCore;
class ConnectionMonitorCore;
class ConnectionMonitor;

class SpikeBuffer;



class SNN {

public:

    SNN(const std::string& name, SimMode preferredSimMode, LoggerMode loggerMode, int randSeed);


    ~SNN();

    // +++++ PUBLIC PROPERTIES ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //

    const static unsigned int MAJOR_VERSION = 6; 
    const static unsigned int MINOR_VERSION = 0; 



    // +++++ PUBLIC METHODS: SETTING UP A SIMULATION ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //

    // NOTE: there should be no default argument values in here, this should be handled by the user interface


    short int connect(int gIDpre, int gIDpost, const std::string& _type, float initWt, float maxWt, float prob,
        uint8_t minDelay, uint8_t maxDelay, RadiusRF radius,
        float mulSynFast, float mulSynSlow, bool synWtType);

    /* Creates synaptic projections using a callback mechanism.
     *
     * \param _grpIdPre:ID of the pre-synaptic group
     * \param _grpIdPost ID of the post-synaptic group
     * \param _conn: pointer to an instance of class ConnectionGenerator
     * \param _synWtType: (optional) connection type, either SYN_FIXED or SYN_PLASTIC, default = SYN_FIXED
     * \return number of created synaptic projections
     */
    short int connect(int gIDpre, int gIDpost, ConnectionGeneratorCore* conn, float mulSynFast, float mulSynSlow,
        bool synWtType);

    /* Creates synaptic projections using a callback mechanism.
    *
    * \param _grpId1:ID lower layer group
    * \param _grpId2 ID upper level group
    */
    short int connectCompartments(int grpIdLower, int grpIdUpper);


    int createGroup(const std::string& grpName, const Grid3D& grid, int neurType, int preferredPartition, ComputingBackend preferredBackend);


    int createGroupLIF(const std::string& grpName, const Grid3D& grid, int neurType, int preferredPartition, ComputingBackend preferredBackend);


    int createSpikeGeneratorGroup(const std::string& grpName, const Grid3D& grid, int neurType, int preferredPartition, ComputingBackend preferredBackend);

    void setCompartmentParameters(int grpId, float couplingUp, float couplingDown);

#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVE

    void setConductances(bool isSet, int tdAMPA, int trNMDA, int tdNMDA, int tdGABAa, int trGABAb, int tdGABAb);

#ifdef LN_I_CALC_TYPES

     // \todo LN transfer doc
    void setConductances(int grpId, bool isSet, int tdAMPA, int trNMDA, int tdNMDA, int tdGABAa, int trGABAb, int tdGABAb);

    void setNM4weighted(int grpId, IcalcType type, float wDA, float w5HT, float wACh, float wNE, float wNorm, float wBase);
#endif


    void setHomeostasis(int grpId, bool isSet, float homeoScale, float avgTimeScale);

    void setHomeoBaseFiringRate(int groupId, float baseFiring, float baseFiringSD);

    void setIntegrationMethod(integrationMethod_t method, int numStepsPerMs);


    void setNeuronParameters(int grpId, 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);

    void setNeuronParametersLIF(int grpId, int tau_m, int tau_ref, float vTh, float vReset, double minRmem, double maxRmem);


    void setNeuronParameters(int grpId, 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_a, float izh_a_sd, float izh_b, float izh_b_sd,
        float izh_vpeak, float izh_vpeak_sd, float izh_c, float izh_c_sd,
        float izh_d, float izh_d_sd);


    void setNeuromodulator(int grpId, float baseDP, float tauDP, float base5HT, float tau5HT,
        float baseACh, float tauACh, float baseNE, float tauNE);

    void setNeuromodulator(int grpId,
        float baseDP, float tauDP, float releaseDP, bool activeDP,
        float base5HT, float tau5HT, float release5HT, bool active5HT,
        float baseACh, float tauACh, float releaseAch, bool activeACh,
        float baseNE, float tauNE, float releaseNE, bool activeNE);


    /*
     * \brief STDP must be defined post-synaptically; that is, if STP should be implemented on the connections from group 0 to group 1,
     * call setSTP on group 1. Fore details on the phenomeon, see (for example) (Bi & Poo, 2001).
     * \param[in] grpId ID of the neuron group
     * \param[in] isSet_enable set to true to enable STDP for this group
     * \param[in] type STDP type (STANDARD, DA_MOD)
     * \param[in] alphaPlus max magnitude for LTP change
     * \param[in] tauPlus decay time constant for LTP
     * \param[in] alphaMinus max magnitude for LTD change (leave positive)
     * \param[in] tauMinus decay time constant for LTD
     */
    void setESTDP(int preGrpId, int postGrpId, bool isSet, STDPType type, STDPCurve curve, float alphaPlus, float tauPlus, float alphaMinus, float tauMinus, float gamma);

#ifdef LN_I_CALC_TYPES
    /*
     * \brief STDP 
     * \param[in] ...
     */
    void setESTDP(int preGrpId, int postGrpId, bool isSet, STDPType type, STDPCurve curve, float alphaPlus, float tauPlus, float alphaMinus, float tauMinus, int nm_pka, float w_pka, int nm_plc, float w_plc);
    void setConnectionModulation(int preGrpId, int postGrpId, IcalcType icalcType);
#endif

    /*
     * \brief STDP must be defined post-synaptically; that is, if STP should be implemented on the connections from group 0 to group 1,
     * call setSTP on group 1. Fore details on the phenomeon, see (for example) (Bi & Poo, 2001).
     * \param[in] grpId ID of the neuron group
     * \param[in] isSet_enable set to true to enable STDP for this group
     * \param[in] type STDP type (STANDARD, DA_MOD)
     * \param[in] curve STDP curve
     * \param[in] ab1 magnitude for LTP change
     * \param[in] ab2 magnitude for LTD change (leave positive)
     * \param[in] tau1, the interval for LTP
     * \param[in] tau2, the interval for LTD
     */
    void setISTDP(int preGrpId, int postGrpId, bool isSet, STDPType type, STDPCurve curve, float ab1, float ab2, float tau1, float tau2);

    void setSTP(int grpId, bool isSet, float STP_U, float STP_tau_u, float STP_tau_x);


#ifdef LN_I_CALC_TYPES
    void setNM4STP(int grpId, float wSTP_U[], float wSTP_tau_u[], float wSTP_tau_x[]);
#endif



    void setWeightAndWeightChangeUpdate(UpdateInterval wtANDwtChangeUpdateInterval, bool enableWtChangeDecay, float wtChangeDecay);



    // +++++ PUBLIC METHODS: RUNNING A SIMULATION +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //

    int runNetwork(int _nsec, int _nmsec, bool printRunSummary);

    void setupNetwork();

#ifdef LN_SETUP_NETWORK_MT
    // LN experimental
    void setupNetworkMT();
#endif

    // +++++ PUBLIC METHODS: INTERACTING WITH A SIMULATION ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //

    // adds a bias to every weight in the connection
    void biasWeights(short int connId, float bias, bool updateWeightRange = false);

    void exitSimulation(int val = 1);

    /*
     * \brief After calling SNN::loadSimulation, you should run SNN::runNetwork before calling fclose(fp).
     * \param fid: file pointer
     * \sa SNN::saveSimulation()
     */
    void loadSimulation(FILE* fid);

    // multiplies every weight with a scaling factor
    void scaleWeights(short int connId, float scale, bool updateWeightRange = false);


    GroupMonitor* setGroupMonitor(int grpId, FILE* fid, int mode = 0);


    ConnectionMonitor* setConnectionMonitor(int grpIdPre, int grpIdPost, FILE* fid);

    void setExternalCurrent(int grpId, const std::vector<float>& current);

    void setSpikeGenerator(int grpId, SpikeGeneratorCore* spikeGenFunc);


    SpikeMonitor* setSpikeMonitor(int gid, FILE* fid);


    NeuronMonitor* setNeuronMonitor(int gid, FILE* fid);


    void setSpikeRate(int grpId, PoissonRate* spikeRate, int refPeriod);

    void setWeight(short int connId, int neurIdPre, int neurIdPost, float weight, bool updateWeightRange = false);

    void startTesting(bool shallUpdateWeights = true);

    void stopTesting();

    void updateConnectionMonitor(short int connId = ALL);

    void updateGroupMonitor(int grpId = ALL);

    
#ifdef LN_UPDATE_CURSPIKES
    void updateCurSpike(std::vector<bool>& firings, int netId);
#endif
#ifdef LN_UPDATE_CURSPIKES_MT
    void updateCurSpikeMT(std::vector<bool>& firings, int netId);
#endif 

#ifdef LN_AXON_PLAST    
    void findWavefrontPath(std::vector<int>& path, std::vector<float>& eligibility, int netId, int grpId, int startNId, int goalNId);
    bool updateDelays(int gGrpIdPre, int gGrpIdPost, std::vector<std::tuple<int, int, uint8_t>> connDelays);
    void printEntrails(char* buffer, unsigned length, int gGrpIdPre, int gGrpIdPost);
#endif

    void updateSpikeMonitor(int grpId = ALL);

    void updateNeuronMonitor(int grpId = ALL);

    /*
     * \param fid file pointer
     */
    void saveSimulation(FILE* fid, bool saveSynapseInfo = false);

    //void writePopWeights(std::string fname, int gIDpre, int gIDpost);


    // +++++ PUBLIC METHODS: LOGGING / PLOTTING +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //

    const FILE* getLogFpInf() { return fpInf_; }
    const FILE* getLogFpErr() { return fpErr_; }
    const FILE* getLogFpDeb() { return fpDeb_; }
    const FILE* getLogFpLog() { return fpLog_; }

    void setLogsFp(FILE* fpInf = NULL, FILE* fpErr = NULL, FILE* fpDeb = NULL, FILE* fpLog = NULL);


    // +++++ PUBLIC METHODS: GETTERS / SETTERS ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //

    short int getConnectId(int grpIdPre, int grpIdPost); 
    ConnectConfig getConnectConfig(short int connectId); 
    ConnSTDPInfo getConnSTDPInfo(short int connId);

    RangeDelay getDelayRange(short int connId);


    uint8_t* getDelays(int gGrpIdPre, int gGrpIdPost, int& numPreN, int& numPostN);

    Grid3D getGroupGrid3D(int grpId);
    int getGroupId(std::string grpName);
    std::string getGroupName(int grpId);
    GroupNeuromodulatorInfo getGroupNeuromodulatorInfo(int grpId);

    LoggerMode getLoggerMode() { return loggerMode_; }

    // get functions for GroupInfo
    int getGroupStartNeuronId(int gGrpId) { return groupConfigMDMap[gGrpId].gStartN; }
    int getGroupEndNeuronId(int gGrpId) { return groupConfigMDMap[gGrpId].gEndN; }
    int getGroupNumNeurons(int gGrpId) { return groupConfigMap[gGrpId].numN; }

    std::string getNetworkName() { return networkName_; }

    Point3D getNeuronLocation3D(int neurId);
    Point3D getNeuronLocation3D(int grpId, int relNeurId);

    int getNeuronId(int gGrpId, Point3D location); 
    //int getRelNeuronId(int gGrpId, int x, int y, int z);  //!< normalized primtive bravis lattice 


    int getNumConnections() { return numConnections; }
    int getNumSynapticConnections(short int connectionId);      
    int getNumCompartmentConnections() { return numCompartmentConnections; }
    int getNumGroups() { return numGroups; }
    int getNumNeurons() { return glbNetworkConfig.numN; }
    int getNumNeuronsReg() { return glbNetworkConfig.numNReg; }
    int getNumNeuronsRegExc() { return glbNetworkConfig.numNExcReg; }
    int getNumNeuronsRegInh() { return glbNetworkConfig.numNInhReg; }
    int getNumNeuronsGen() { return glbNetworkConfig.numNPois; }
    int getNumNeuronsGenExc() { return glbNetworkConfig.numNExcPois; }
    int getNumNeuronsGenInh() { return glbNetworkConfig.numNInhPois; }
    int getNumSynapses() { return glbNetworkConfig.numSynNet; }

    int getRandSeed() { return randSeed_; }

    int getSimTime() { return simTime; }
    int getSimTimeSec() { return simTimeSec; }
    int getSimTimeMs() { return simTimeMs; }

    SpikeMonitor* getSpikeMonitor(int grpId);

    SpikeMonitorCore* getSpikeMonitorCore(int grpId);

    NeuronMonitor* getNeuronMonitor(int grpId);

    NeuronMonitorCore* getNeuronMonitorCore(int grpId);

    float* getCurrent() { return managerRuntimeData.current; }

    std::vector< std::vector<float> > getWeightMatrix2D(short int connId);

    std::vector<float> getConductanceAMPA(int grpId);
    std::vector<float> getConductanceNMDA(int grpId);
    std::vector<float> getConductanceGABAa(int grpId);
    std::vector<float> getConductanceGABAb(int grpId);

    float* getSTPu() { return managerRuntimeData.stpu; }

    float* getSTPx() { return managerRuntimeData.stpx; }

    bool isConnectionPlastic(short int connId);

    RangeWeight getWeightRange(short int connId);

    bool isExcitatoryGroup(int gGrpId) { return (groupConfigMap[gGrpId].type & TARGET_AMPA) || (groupConfigMap[gGrpId].type & TARGET_NMDA); }
    bool isInhibitoryGroup(int gGrpId) { return (groupConfigMap[gGrpId].type & TARGET_GABAa) || (groupConfigMap[gGrpId].type & TARGET_GABAb); }
    bool isPoissonGroup(int gGrpId) { return (groupConfigMap[gGrpId].type & POISSON_NEURON); }
    bool isDopaminergicGroup(int gGrpId) { return (groupConfigMap[gGrpId].type & TARGET_DA); }
    // LN2021 \todo LN

    bool isGroupWithHomeostasis(int grpId);

#ifdef LN_I_CALC_TYPES
    bool isGroupWith(int grpId, IcalcType icalcType) { return groupConfigMap[grpId].icalcType == icalcType; };
    bool isGroupWithCOBA(int grpId) { return isGroupWith(grpId, COBA); };
    bool isGroupWithCUBA(int grpId) { return isGroupWith(grpId, CUBA); };
    bool isGroupWithNMDARise(int grpId) { return false; };
    bool isGroupWithGABAbRise(int grpId) { return false; };

    IcalcType getIcalcType(int grpId) { return groupConfigMap[grpId].icalcType; };
  
    // factors
    void getConductanceConfig(int grpId, float &dAMPA, float &rNMDA, float &dNMDA, float &dGABAa, float &rGABAb, float &dGABAb) {
        auto config = groupConfigMap[grpId].conductanceConfig;
        dAMPA = config.dAMPA;
        rNMDA = config.rNMDA;
        dNMDA = config.dNMDA;
        dGABAa = config.dGABAa;
        rGABAb = config.rGABAb;
        dGABAb = config.dGABAb;
    };
    
    // times 
    void getConductanceConfig(int grpId, int& tdAMPA, int& trNMDA, int& tdNMDA, int& tdGABAa, int& trGABAb, int& tdGABAb) {

        //double d = 1.0 / (1.0 - 0.833333313);
        //float f = 1.0f / (1.0f - 0.833333313f);
        //int i = std::round<int>(f);

        // \todo LN ensure at set that float does not goes below min precision

        auto config = groupConfigMap[grpId].conductanceConfig;
        tdAMPA = round(1.0f / (1.0f - config.dAMPA));   
        trNMDA = abs(config.rNMDA) < 0.000001f ? 0 : round(1.0f / (1.0f - config.rNMDA));
        tdNMDA = round(1.0f / (1.0f - config.dNMDA));
        tdGABAa = round(1.0f / (1.0f - config.dGABAa));
        trGABAb = abs(config.rGABAb) < 0.000001f ? 0 : round(1.0f / (1.0f - config.rGABAb));
        tdGABAb = round(1.0f / (1.0f - config.dGABAb));
    };
#endif 

    double getRFDist3D(const RadiusRF& radius, const Point3D& pre, const Point3D& post);
    bool isPoint3DinRF(const RadiusRF& radius, const Point3D& pre, const Point3D& post);

    bool isSimulationWithCompartments() { return sim_with_compartments; }
#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVEL
    bool isSimulationWithCOBA() { return sim_with_conductances; }
    bool isSimulationWithCUBA() { return !sim_with_conductances; }
    bool isSimulationWithNMDARise() { return sim_with_NMDA_rise; }
    bool isSimulationWithGABAbRise() { return sim_with_GABAb_rise; }
    bool isSimulationWithFixedWeightsOnly() { return sim_with_fixedwts; }
    bool isSimulationWithHomeostasis() { return sim_with_homeostasis; }
    bool isSimulationWithPlasticWeights() { return !sim_with_fixedwts; }
    bool isSimulationWithSTDP() { return sim_with_stdp; }
    bool isSimulationWithSTP() { return sim_with_stp; }


#ifndef __NO_CUDA__
    // GPU backend: utility function
    static int cudaDeviceCount();
    static void cudaDeviceDescription(unsigned ithGPU, const char **desc);
#else
    static int cudaDeviceCount() { return 0; }
    static void cuda_device_description(unsigned , const char **) {};
#endif



    // **************************************************************************************************************** //
    // PRIVATE METHODS
    // **************************************************************************************************************** //

private:
    void SNNinit();

    void advSimStep();

    void allocateManagerRuntimeData();

    int assignGroup(int gGrpId, int availableNeuronId);
    int assignGroup(std::list<GroupConfigMD>::iterator grpIt, int localGroupId, int availableNeuronId);
    void generateGroupRuntime(int netId, int lGrpId);
    void generatePoissonGroupRuntime(int netId, int lGrpId);
    void generateConnectionRuntime(int netId);
    void generateCompConnectionRuntime(int netId);

    void generateRuntimeNetworkConfigs();
    void generateRuntimeGroupConfigs();
    void generateRuntimeConnectConfigs();

    void collectGlobalNetworkConfigC();
    void compileConnectConfig(); 
    void compileGroupConfig();

    void collectGlobalNetworkConfigP();

    void connectNetwork();
    inline void connectNeurons(int netId, int srcGrp, int destGrp, int srcN, int destN, short int connId, int externalNetId);
    inline void connectNeurons(int netId, int _grpSrc, int _grpDest, int _nSrc, int _nDest, short int _connId, float initWt, float maxWt, uint8_t delay, int externalNetId);
    void connectFull(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal);
    void connectOneToOne(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal);
    void connectRandom(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal);
    void connectGaussian(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal);
    void connectUserDefined(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal);

#ifdef LN_SETUP_NETWORK_MT
    void connectNetworkMT();  
    inline void connectNeuronsMT(std::mutex &mtx, int netId, int srcGrp, int destGrp, int srcN, int destN, short int connId, int externalNetId);
    void connectRandomMT(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal);
#endif

    void deleteObjects();           

    void findMaxNumSynapsesGroups(int* _maxNumPostSynGrp, int* _maxNumPreSynGrp);
    void findMaxNumSynapsesNeurons(int _netId, int& _maxNumPostSynN, int& _maxNumPreSynN);
    void findMaxSpikesD1D2(int netId, unsigned int& _maxSpikesD1, unsigned int& _maxSpikesD2);
    void findNumSynapsesNetwork(int netId, int& _numPostSynNet, int& _numPreSynNet); 
    void findNumN(int _netId, int& _numN, int& _nunNExternal, int& numNAssigned,
        int& _numNReg, int& _numNExcReg, int& _numNInhReg,
        int& _numNPois, int& _numNExcPois, int& _numNInhPois);
    void findNumNSpikeGenAndOffset(int _netId);

    void generatePostSynapticSpike(int preNId, int postNId, int synId, int tD, int netId);
    void fillSpikeGenBits(int netId);
    void userDefinedSpikeGenerator(int gGrpId);

    float generateWeight(int connProp, float initWt, float maxWt, int nid, int grpId);

    void verifyNetwork();

    void verifySTDP();

    void verifyHomeostasis();

    void verifyCompartments();

    //void verifyNumNeurons();

    void compileSNN();

    void partitionSNN();
    void generateRuntimeSNN();

#ifdef LN_SETUP_NETWORK_MT
    void partitionSNNMT();  // featFastSetup LN 20201108
#endif

     //int poissonSpike(int currTime, float frate, int refractPeriod);

    void printConnectionInfo(short int connId);
    void printConnectionInfo(int netId, std::list<ConnectConfig>::iterator connIt);
    void printGroupInfo(int grpId);
    void printGroupInfo(int netId, std::list<GroupConfigMD>::iterator grpIt);
    void printSimSummary(); 
    void printStatusConnectionMonitor(int connId = ALL);
    void printStatusGroupMonitor(int gGrpId = ALL);
    void printStatusSpikeMonitor(int gGrpId = ALL);
    void printSikeRoutingInfo();

    int loadSimulation_internal(bool onlyPlastic);

    void resetConductances(int netId);
    void resetCurrent(int netId);
    void resetFiringInformation(); 
    void resetGroupConfigs(bool deallocate = false);
    void resetNeuromodulator(int netId, int lGrpId);
    void resetNeuron(int netId, int lGrpId, int lNId);
    void resetMonitors(bool deallocate = false);
    void resetConnectionConfigs(bool deallocate = false);
    void deleteManagerRuntimeData();
    void resetPoissonNeuron(int netId, int lGrpId, int lNId); 
    void resetPropogationBuffer();
    void resetSynapse(int netId, bool changeWeights = false);
    void resetTimeTable();
    void resetFiringTable();
    void routeSpikes();
    void transferSpikes(void* dest, int destNetId, void* src, int srcNetId, int size);
    void resetTiming();

    inline SynInfo SET_CONN_ID(int nid, int sid, int grpId);

    void setGrpTimeSlice(int grpId, int timeSlice); 
    int setRandSeed(int seed);  

    void startTiming();
    void stopTiming();

    void generateUserDefinedSpikes();

    void allocateManagerSpikeTables();

    bool updateTime(); 

    float getCompCurrent(int netid, int lGrpId, int lneurId, float const0 = 0.0f, float const1 = 0.0f);

    // Abstract layer for setupNetwork() and runNetwork()
    void allocateSNN(int netId);
    void clearExtFiringTable();
    void convertExtSpikesD1(int netId, int startIdx, int endIdx, int GtoLOffset);
    void convertExtSpikesD2(int netId, int startIdx, int endIdx, int GtoLOffset);
    void doCurrentUpdate();
    void doSTPUpdateAndDecayCond();
    void deleteRuntimeData();
    void findFiring();
    void globalStateUpdate();
    void resetSpikeCnt(int gGrpId);
    void shiftSpikeTables();
    void spikeGeneratorUpdate();
    void updateTimingTable();
    void updateWeights();
    void updateNetworkConfig(int netId);

    // Abstract layer for trasferring data (local-to-global copy)
    void fetchConductanceAMPA(int gGrpId);
    void fetchConductanceNMDA(int gGrpId);
    void fetchConductanceGABAa(int gGrpId);
    void fetchConductanceGABAb(int gGrpId);
    void fetchNetworkSpikeCount();
    void fetchNeuronSpikeCount(int gGrpId);
    void fetchSTPState(int gGrpId);

    // Abstract layer for trasferring data (local-to-local copy)
    void fetchSpikeTables(int netId);
    void fetchNeuronStateBuffer(int netId, int lGrpId);
    void fetchGroupState(int netId, int lGrpId);
    void fetchWeightState(int netId, int lGrpId);
    void fetchGrpIdsLookupArray(int netId);
    void fetchConnIdsLookupArray(int netId);
    void fetchLastSpikeTime(int netId);
    void fetchCurSpike(int netId); 
    void fetchRandNum(int netId); 
    void fetchPoissonFireRate(int netId); 
    void fetchSpikeGenBits(int netId); 
    void fetchPreConnectionInfo(int netId);
    void fetchPostConnectionInfo(int netId);
    void fetchSynapseState(int netId);
    void fetchExtFiringTable(int netId);
    void fetchTimeTable(int netId);
    void writeBackTimeTable(int netId);

#ifndef __NO_CUDA__
    // GPU implementation for setupNetwork() and runNetwork()
    void allocateSNN_GPU(int netId); 
    void assignPoissonFiringRate_GPU(int netId);
    void clearExtFiringTable_GPU(int netId);
    void convertExtSpikesD1_GPU(int netId, int startIdx, int endIdx, int GtoLOffset);
    void convertExtSpikesD2_GPU(int netId, int startIdx, int endIdx, int GtoLOffset);
    void doCurrentUpdateD1_GPU(int netId);
    void doCurrentUpdateD2_GPU(int netId);
    void doSTPUpdateAndDecayCond_GPU(int netId);
    void deleteRuntimeData_GPU(int netId);      
    void findFiring_GPU(int netId);
    void globalStateUpdate_C_GPU(int netId);
    void globalStateUpdate_N_GPU(int netId);
    void globalStateUpdate_G_GPU(int netId);
    void resetSpikeCnt_GPU(int netId, int lGrpId); 
    void shiftSpikeTables_F_GPU(int netId);
    void shiftSpikeTables_T_GPU(int netId);
    void spikeGeneratorUpdate_GPU(int netId);
    void updateTimingTable_GPU(int netId);
    void updateWeights_GPU(int netId);
#else
    void allocateSNN_GPU(int netId) { assert(false); } 
    void assignPoissonFiringRate_GPU(int netId) { assert(false); }
    void clearExtFiringTable_GPU(int netId) { assert(false); }
    void convertExtSpikesD1_GPU(int netId, int startIdx, int endIdx, int GtoLOffset) { assert(false); }
    void convertExtSpikesD2_GPU(int netId, int startIdx, int endIdx, int GtoLOffset) { assert(false); }
    void doCurrentUpdateD1_GPU(int netId) { assert(false); }
    void doCurrentUpdateD2_GPU(int netId) { assert(false); }
    void doSTPUpdateAndDecayCond_GPU(int netId) { assert(false); }
    void deleteRuntimeData_GPU(int netId) { assert(false); }        
    void findFiring_GPU(int netId) { assert(false); }
    void globalStateUpdate_C_GPU(int netId) { assert(false); }
    void globalStateUpdate_N_GPU(int netId) { assert(false); }
    void globalStateUpdate_G_GPU(int netId) { assert(false); }
    void resetSpikeCnt_GPU(int netId, int lGrpId) { assert(false); } 
    void shiftSpikeTables_F_GPU(int netId) { assert(false); }
    void shiftSpikeTables_T_GPU(int netId) { assert(false); }
    void spikeGeneratorUpdate_GPU(int netId) { assert(false); }
    void updateTimingTable_GPU(int netId) { assert(false); }
    void updateWeights_GPU(int netId) { assert(false); }
#endif

#ifndef __NO_CUDA__
    // GPU backend: utility function
    void allocateGroupId(int netId);
    int  allocateStaticLoad(int netId, int bufSize);
    void checkAndSetGPUDevice(int netId);
    void checkDestSrcPtrs(RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem, int grpId, int destOffset);
    int configGPUDevice();
    void initGPU(int netId);
#else
    //int configGPUDevice() { return 0; }  
#endif

#ifndef __NO_CUDA__
    // GPU backend: data transfer functions
    void copyAuxiliaryData(int netId, int lGrpId, RuntimeData* dest, cudaMemcpyKind kind, bool allocateMem);
    void copyConductanceAMPA(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem, int destOffset);
    void copyConductanceNMDA(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem, int destOffset);
    void copyConductanceGABAa(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem, int destOffset);
    void copyConductanceGABAb(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem, int destOffset);
    void copyPreConnectionInfo(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem);
    void copyPostConnectionInfo(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem);
    void copyExternalCurrent(int netId, int lGrpId, RuntimeData* dest, cudaMemcpyKind kind, bool allocateMem);
    void copyNeuronParameters(int netId, int lGrpId, RuntimeData* dest, cudaMemcpyKind kind, bool allocateMem);
    void copyGroupState(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem);
    void copyNeuronState(int netId, int lGrpId, RuntimeData* dest, cudaMemcpyKind kind, bool allocateMem);
    void copyNeuronStateBuffer(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem);
    void copyNeuronSpikeCount(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem, int destOffset);
    void copySynapseState(int netId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem);
    void copySTPState(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem);
    void copyWeightState(int netId, int lGrpId, cudaMemcpyKind kind);
    void copyNetworkConfig(int netId, cudaMemcpyKind kind);
    void copyGroupConfigs(int netId);
    void copyConnectConfigs(int netId);
    void copyGrpIdsLookupArray(int netId, cudaMemcpyKind kind);
    void copyConnIdsLookupArray(int netId, cudaMemcpyKind kind);
    void copyLastSpikeTime(int netId, cudaMemcpyKind kind);
    void copyCurSpikes(int netId, cudaMemcpyKind kind); // LN20201101 featSpikes    
    void copyRandNum(int netId, cudaMemcpyKind kind); // LN20201101 featSpikes  
    void copyPoissonFireRate(int netId, cudaMemcpyKind kind); // LN20201102 featSpikes  
    void copySpikeGenBits(int netId, cudaMemcpyKind kind); // LN20201101 featSpikes     
    void copyNetworkSpikeCount(int netId, cudaMemcpyKind kind,
        unsigned int* spikeCountD1, unsigned int* spikeCountD2,
        unsigned int* spikeCountExtD1, unsigned int* spikeCountExtD2);
    void copySpikeTables(int netId, cudaMemcpyKind kind);
    void copyTimeTable(int netId, cudaMemcpyKind kind);
    void copyExtFiringTable(int netId, cudaMemcpyKind kind);
#else
    #define cudaMemcpyKind int
    #define cudaMemcpyHostToHost 0
    #define cudaMemcpyHostToDevice 0
    #define cudaMemcpyDeviceToHost 0
    #define cudaMemcpyDeviceToDevice 0
    #define cudaMemcpyDefault 0

    void copyAuxiliaryData(int netId, int lGrpId, RuntimeData* dest, cudaMemcpyKind kind, bool allocateMem) { assert(false); }
    void copyConductanceAMPA(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem, int destOffset) { assert(false); }
    void copyConductanceNMDA(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem, int destOffset) { assert(false); }
    void copyConductanceGABAa(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem, int destOffset) { assert(false); }
    void copyConductanceGABAb(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem, int destOffset) { assert(false); }
    void copyPreConnectionInfo(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem) { assert(false); }
    void copyPostConnectionInfo(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem) { assert(false); }
    void copyExternalCurrent(int netId, int lGrpId, RuntimeData* dest, cudaMemcpyKind kind, bool allocateMem) { assert(false); }
    void copyNeuronParameters(int netId, int lGrpId, RuntimeData* dest, cudaMemcpyKind kind, bool allocateMem) { assert(false); }
    void copyGroupState(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem) { assert(false); }
    void copyNeuronState(int netId, int lGrpId, RuntimeData* dest, cudaMemcpyKind kind, bool allocateMem) { assert(false); }
    void copyNeuronStateBuffer(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem) { assert(false); }
    void copyNeuronSpikeCount(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem, int destOffset) { assert(false); }
    void copySynapseState(int netId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem) { assert(false); }
    void copySTPState(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, cudaMemcpyKind kind, bool allocateMem) { assert(false); }
    void copyWeightState(int netId, int lGrpId, cudaMemcpyKind kind) { assert(false); }
    void copyNetworkConfig(int netId, cudaMemcpyKind kind) { assert(false); }
    void copyGroupConfigs(int netId) { assert(false); }
    void copyGrpIdsLookupArray(int netId, cudaMemcpyKind kind) { assert(false); }
    void copyConnIdsLookupArray(int netId, cudaMemcpyKind kind) { assert(false); }
    void copyLastSpikeTime(int netId, cudaMemcpyKind kind) { assert(false); }
    void copyCurSpikes(int netId, cudaMemcpyKind kind) { assert(false); }  // LN20201101 featSpikes
    void copyPoissonFireRate(int netId, cudaMemcpyKind kind) { assert(false); }  // LN20201102 featSpikes
    void copyRandNum(int netId, cudaMemcpyKind kind) { assert(false); }  // LN20201101 featSpikes
    void copySpikeGenBits(int netId, cudaMemcpyKind kind) { assert(false); }  // LN20201101 featSpikes
    void copyNetworkSpikeCount(int netId, cudaMemcpyKind kind,
    unsigned int* spikeCountD1, unsigned int* spikeCountD2,
    unsigned int* spikeCountExtD1, unsigned int* spikeCountExtD2) { assert(false); }
    void copySpikeTables(int netId, cudaMemcpyKind kind) { assert(false); }
    void copyTimeTable(int netId, cudaMemcpyKind kind) { assert(false); }
    void copyExtFiringTable(int netId, cudaMemcpyKind kind) { assert(false); }
#endif

    // CPU implementation for setupNetwork() and runNetwork()

    //allocates runtime data on CPU memory
    void allocateSNN_CPU(int netId); 

    // runNetwork functions - multithreaded in LINUX using pthreads
#ifdef __NO_PTHREADS__
    void assignPoissonFiringRate_CPU(int netId);
    void clearExtFiringTable_CPU(int netId);
    void convertExtSpikesD2_CPU(int netId, int startIdx, int endIdx, int GtoLOffset);
    void convertExtSpikesD1_CPU(int netId, int startIdx, int endIdx, int GtoLOffset);
    void doCurrentUpdateD2_CPU(int netId);
    void doCurrentUpdateD1_CPU(int netId);
    void doSTPUpdateAndDecayCond_CPU(int netId);
    void deleteRuntimeData_CPU(int netId);
    void findFiring_CPU(int netId);
    void globalStateUpdate_CPU(int netId);
    void resetSpikeCnt_CPU(int netId, int lGrpId); 
    void shiftSpikeTables_CPU(int netId);
    void spikeGeneratorUpdate_CPU(int netId);
    void updateTimingTable_CPU(int netId);
    void updateWeights_CPU(int netId);
#else // for APPLE and Win systems - returns a void* to pthread_create - only differ in the return type compared to the counterparts above
    void* assignPoissonFiringRate_CPU(int netId);
    void* clearExtFiringTable_CPU(int netId);
    void* convertExtSpikesD2_CPU(int netId, int startIdx, int endIdx, int GtoLOffset);
    void* convertExtSpikesD1_CPU(int netId, int startIdx, int endIdx, int GtoLOffset);
    void* doCurrentUpdateD2_CPU(int netId);
    void* doCurrentUpdateD1_CPU(int netId);
    void* doSTPUpdateAndDecayCond_CPU(int netId);
    void* deleteRuntimeData_CPU(int netId);
    void* findFiring_CPU(int netId);
    void* globalStateUpdate_CPU(int netId);
    void* resetSpikeCnt_CPU(int netId, int lGrpId); 
    void* shiftSpikeTables_CPU(int netId);
    void* spikeGeneratorUpdate_CPU(int netId);
    void* updateTimingTable_CPU(int netId);
    void* updateWeights_CPU(int netId);

    // static multithreading helper methods for the above CPU runNetwork() methods
    static void* helperAssignPoissonFiringRate_CPU(void*);
    static void* helperClearExtFiringTable_CPU(void*);
    static void* helperConvertExtSpikesD2_CPU(void*);
    static void* helperConvertExtSpikesD1_CPU(void*);
    static void* helperDoCurrentUpdateD2_CPU(void*);
    static void* helperDoCurrentUpdateD1_CPU(void*);
    static void* helperDoSTPUpdateAndDecayCond_CPU(void*);
    static void* helperDeleteRuntimeData_CPU(void*);
    static void* helperFindFiring_CPU(void*);
    static void* helperGlobalStateUpdate_CPU(void*);
    static void* helperResetSpikeCnt_CPU(void*);
    static void* helperShiftSpikeTables_CPU(void*);
    static void* helperSpikeGeneratorUpdate_CPU(void*);
    static void* helperUpdateTimingTable_CPU(void*);
    static void* helperUpdateWeights_CPU(void*);
#endif

    // CPU computing backend: data transfer function
    void copyAuxiliaryData(int netId, int lGrpId, RuntimeData* dest, bool allocateMem);
    void copyConductanceAMPA(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, bool allocateMem, int destOffset);
    void copyConductanceNMDA(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, bool allocateMem, int destOffset);
    void copyConductanceGABAa(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, bool allocateMem, int destOffset);
    void copyConductanceGABAb(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, bool allocateMem, int destOffset);
    void copyPreConnectionInfo(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, bool allocateMem);
    void copyPostConnectionInfo(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, bool allocateMem);
    void copyExternalCurrent(int netId, int lGrpId, RuntimeData* dest, bool allocateMem);
    void copyNeuronParameters(int netId, int lGrpId, RuntimeData* dest, bool allocateMem);  
    void copyGroupState(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, bool allocateMem);
    void copyNeuronStateBuffer(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, bool allocateMem);
    void copyNeuronState(int netId, int lGrpId, RuntimeData* dest, bool allocateMem);   
    void copyNeuronSpikeCount(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, bool allocateMem, int destOffset);    
    void copySynapseState(int netId, RuntimeData* dest, RuntimeData* src, bool allocateMem);    
    void copySTPState(int netId, int lGrpId, RuntimeData* dest, RuntimeData* src, bool allocateMem);    
    void copyWeightState(int netId, int lGrpId);
    void copyNetworkConfig(int netId);
    void copyGrpIdsLookupArray(int netId);
    void copyConnIdsLookupArray(int netId);
    void copyLastSpikeTime(int netId);
    void copyCurSpikes(int netId); // LN20201101 featSpikes
    void copyRandNum(int netId); // LN20201101 featSpikes
    void copyPoissonFireRate(int netId); // LN20201102 featSpikes
    void copySpikeGenBits(int netId); // LN20201101 featSpikes
    void copyNetworkSpikeCount(int netId,
    unsigned int* spikeCountD1, unsigned int* spikeCountD2,
    unsigned int* spikeCountExtD1, unsigned int* spikeCountExtD2);
    void copySpikeTables(int netId);
    void copyTimeTable(int netId, bool toManager);
    void copyExtFiringTable(int netId);
    
    // CPU backend: utility function
    void firingUpdateSTP(int lNId, int lGrpId, int netId);
    void updateLTP(int lNId, int lGrpId, int netId);
    void resetFiredNeuron(int lNId, short int lGrpId, int netId);
    bool getPoissonSpike(int lNId, int netId);
    bool getSpikeGenBit(unsigned int nIdPos, int netId);

    
#ifdef LN_AXON_PLAST
    void findWavefrontPath_CPU(std::vector<int>& path, std::vector<float>& eligibility, int netId, int grpId, int startNId, int goalNId);
    bool updateDelays_CPU(int netId, int lGrpIdPre, int lGrpIdPost, std::vector<std::tuple<int, int, uint8_t>> connDelays);
    void printEntrails_CPU(char* buffer, unsigned length, int netId, int lGrpIdPre, int lGrpIdPost);
#ifndef __NO_CUDA__
    bool updateDelays_GPU(int netId, int lGrpIdPre, int lGrpIdPost, std::vector<std::tuple<int, int, uint8_t>> connDelays);
    void printEntrails_GPU(int netId, int lGrpIdPre, int lGrpIdPost);
    void printEntrails_GPU(char* buffer, unsigned length, int netId, int lGrpIdPre, int lGrpIdPost);
#else                      
    bool updateDelays_GPU(int netId, int lGrpIdPre, int lGrpIdPost, std::vector<std::tuple<int, int, uint8_t>> connDelays) { assert(false); }
    void printEntrails_GPU(int netId, int lGrpIdPre, int lGrpIdPost) { assert(false); }
    void printEntrails_GPU(char* buffer, unsigned length, int netId, int lGrpIdPre, int lGrpIdPost) { assert(false); }
#endif

#endif

    // +++++ PRIVATE PROPERTIES +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //
    SNNState snnState; 
    FILE* loadSimFID;

    const std::string networkName_; 
    const LoggerMode loggerMode_;   
    const SimMode preferredSimMode_;
    const int randSeed_;            

    int numGPUs;    
    int numCores;   

    int numAvailableGPUs; 

    bool simulatorDeleted;
    bool spikeRateUpdated;

    bool sim_in_testing;

    int numGroups;      
    int numConnections; 
    int numCompartmentConnections; 

    std::map<int, GroupConfig> groupConfigMap;   
    std::map<int, GroupConfigMD> groupConfigMDMap; 
    std::map<int, ConnectConfig> connectConfigMap; 
    std::map<int, compConnectConfig> compConnectConfigMap; 

    // data structure assisting network partitioning
    std::list<GroupConfigMD> groupPartitionLists[MAX_NET_PER_SNN];
    std::list<ConnectConfig> localConnectLists[MAX_NET_PER_SNN];
    std::list<ConnectConfig> externalConnectLists[MAX_NET_PER_SNN];
    std::list<compConnectConfig> localCompConnectLists[MAX_NET_PER_SNN];


#ifdef LN_FIX_CONNLIST_
    std::vector<ConnectionInfo> connectionLists[MAX_NET_PER_SNN];
#else
    std::list<ConnectionInfo> connectionLists[MAX_NET_PER_SNN];
#endif
    std::list<RoutingTableEntry> spikeRoutingTable;

    float       *mulSynFast;    
    float       *mulSynSlow;    

    SpikeBuffer* spikeBuf;

#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVEL
    bool sim_with_conductances; 
    bool sim_with_NMDA_rise;    
    bool sim_with_GABAb_rise;   
#define LN_I_CALC_TYPES__REQUIRED_FOR_BACKWARD_COMPAT
    double dAMPA;               
    double rNMDA;               
    double dNMDA;               
    double sNMDA;               
    double dGABAa;              
    double rGABAb;              
    double dGABAb;              
    double sGABAb;              

    bool sim_with_compartments;
    bool sim_with_fixedwts;
    bool sim_with_stdp;
    bool sim_with_modulated_stdp;
    bool sim_with_homeostasis;
    bool sim_with_stp;
    bool sim_with_spikecounters; 

    GlobalNetworkConfig glbNetworkConfig; 

    //time and timestep
    int simTimeRunStart; 
    int simTimeRunStop;  
    int simTimeLastRunSummary; 
    int simTimeMs;      
    int simTimeSec;     
    int simTime;        

#ifndef __NO_CUDA__
    StopWatchInterface* timer;
#endif
    float cumExecutionTime;
    float lastExecutionTime;
    float prevExecutionTime;
    float executionTime;

    FILE*   fpInf_; 
    FILE*   fpErr_; 
    FILE*   fpDeb_; 
    FILE*   fpLog_;

    // keep track of number of SpikeMonitor/SpikeMonitorCore objects
    int numSpikeMonitor;
    SpikeMonitorCore*  spikeMonCoreList[MAX_GRP_PER_SNN];
    SpikeMonitor*      spikeMonList[MAX_GRP_PER_SNN];

    // neuron monitor variables
    int numNeuronMonitor;
    NeuronMonitor*     neuronMonList[MAX_GRP_PER_SNN];
    NeuronMonitorCore* neuronMonCoreList[MAX_GRP_PER_SNN];

    // \FIXME \DEPRECATED this one moved to group-based
    long int    simTimeLastUpdSpkMon_; 

    int numSpikeGenGrps;

    // keep track of number of GroupMonitor/GroupMonitorCore objects
    int numGroupMonitor;
    GroupMonitorCore*   groupMonCoreList[MAX_GRP_PER_SNN];
    GroupMonitor*       groupMonList[MAX_GRP_PER_SNN];

    // neuron monitor variables
    //NeuronMonitorCore* neurBufferCallback[MAX_]
    //int numNeuronMonitor;

    // connection monitor variables
    int numConnectionMonitor;
    ConnectionMonitorCore* connMonCoreList[MAX_CONN_PER_SNN];
    ConnectionMonitor*     connMonList[MAX_CONN_PER_SNN];

    RuntimeData runtimeData[MAX_NET_PER_SNN];
    RuntimeData managerRuntimeData;

    typedef struct ManagerRuntimeDataSize_s {
        unsigned int maxMaxSpikeD1;
        unsigned int maxMaxSpikeD2;
        int maxNumN;
        int maxNumNReg;
        int maxNumNSpikeGen;
        int maxNumNPois; 
        int maxNumNAssigned;
        int maxNumGroups;
        int maxNumConnections;
        int maxNumPostSynNet;
        int maxNumPreSynNet;
        int maxNumNPerGroup;
        int glbNumN;
        int glbNumNReg;
    } ManagerRuntimeDataSize;

    ManagerRuntimeDataSize managerRTDSize;

    // runtime configurations
    NetworkConfigRT networkConfigs[MAX_NET_PER_SNN]; 
    GroupConfigRT   groupConfigs[MAX_NET_PER_SNN][MAX_GRP_PER_SNN];
    ConnectConfigRT connectConfigs[MAX_NET_PER_SNN][MAX_CONN_PER_SNN]; 

    // weight update parameter
    int wtANDwtChangeUpdateInterval_;
    int wtANDwtChangeUpdateIntervalCnt_;
    float stdpScaleFactor_;
    float wtChangeDecay_; 
};

#endif