snn_manager.cpp

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/2016
*/

#include <snn.h>
#include <sstream>
#include <algorithm>

#include <connection_monitor.h>
#include <connection_monitor_core.h>
#include <spike_monitor.h>
#include <spike_monitor_core.h>
#include <group_monitor.h>
#include <group_monitor_core.h>
#include <neuron_monitor.h>
#include <neuron_monitor_core.h>

#include <spike_buffer.h>
#include <error_code.h>

// \FIXME what are the following for? why were they all the way at the bottom of this file?

#define COMPACTION_ALIGNMENT_PRE  16
#define COMPACTION_ALIGNMENT_POST 0



// TODO: consider moving unsafe computations out of constructor
SNN::SNN(const std::string& name, SimMode preferredSimMode, LoggerMode loggerMode, int randSeed)
                    : networkName_(name), preferredSimMode_(preferredSimMode), loggerMode_(loggerMode),
                      randSeed_(SNN::setRandSeed(randSeed)) // all of these are const
{
    // move all unsafe operations out of constructor
    SNNinit();
}

// destructor
SNN::~SNN() {
    if (!simulatorDeleted)
        deleteObjects();
}


// make from each neuron in grpId1 to 'numPostSynapses' neurons in grpId2
short int SNN::connect(int grpId1, int grpId2, const std::string& _type, float initWt, float maxWt, float prob,
                        uint8_t minDelay, uint8_t maxDelay, RadiusRF radius,
                        float _mulSynFast, float _mulSynSlow, bool synWtType) {
                        //const std::string& wtType
    int retId=-1;
    assert(grpId1 < numGroups);
    assert(grpId2 < numGroups);
    assert(minDelay <= maxDelay);
    assert(!isPoissonGroup(grpId2));

    //* \deprecated Do these ramp thingies still work?
//    bool useRandWts = (wtType.find("random") != std::string::npos);
//    bool useRampDownWts = (wtType.find("ramp-down") != std::string::npos);
//    bool useRampUpWts = (wtType.find("ramp-up") != std::string::npos);
//    uint32_t connProp = SET_INITWTS_RANDOM(useRandWts)
//      | SET_CONN_PRESENT(1)
//      | SET_FIXED_PLASTIC(synWtType)
//      | SET_INITWTS_RAMPUP(useRampUpWts)
//      | SET_INITWTS_RAMPDOWN(useRampDownWts);
    uint32_t connProp = SET_CONN_PRESENT(1) | SET_FIXED_PLASTIC(synWtType);

    Grid3D szPre = getGroupGrid3D(grpId1);
    Grid3D szPost = getGroupGrid3D(grpId2);

    // initialize configuration of a connection
    ConnectConfig connConfig;

    connConfig.grpSrc   = grpId1;
    connConfig.grpDest  = grpId2;
    connConfig.initWt   = initWt;
    connConfig.maxWt    = maxWt;
    connConfig.maxDelay = maxDelay;
    connConfig.minDelay = minDelay;
//      newInfo->radX             = (radX<0) ? MAX(szPre.x,szPost.x) : radX; // <0 means full connectivity, so the
//      newInfo->radY             = (radY<0) ? MAX(szPre.y,szPost.y) : radY; // effective group size is Grid3D.x. Grab
//      newInfo->radZ             = (radZ<0) ? MAX(szPre.z,szPost.z) : radZ; // the larger of pre / post to connect all
    connConfig.connRadius = radius;
    connConfig.mulSynFast      = _mulSynFast;
    connConfig.mulSynSlow      = _mulSynSlow;
    connConfig.connProp        = connProp;
    connConfig.connProbability = prob;
    connConfig.type            = CONN_UNKNOWN;
    connConfig.connectionMonitorId = -1;
    connConfig.connId = -1;
    connConfig.conn = NULL;
    connConfig.numberOfConnections = 0;

    if ( _type.find("random") != std::string::npos) {
        connConfig.type = CONN_RANDOM;
    }
    //so you're setting the size to be prob*Number of synapses in group info + some standard deviation ...
    else if ( _type.find("full-no-direct") != std::string::npos) {
        connConfig.type = CONN_FULL_NO_DIRECT;
    }
    else if ( _type.find("full") != std::string::npos) {
        connConfig.type = CONN_FULL;
    }
    else if ( _type.find("one-to-one") != std::string::npos) {
        connConfig.type = CONN_ONE_TO_ONE;
    } else if ( _type.find("gaussian") != std::string::npos) {
        connConfig.type   = CONN_GAUSSIAN;
    } else {
        KERNEL_ERROR("Invalid connection type (should be 'random', 'full', 'one-to-one', 'full-no-direct', or 'gaussian')");
        exitSimulation(KERNEL_ERROR_INVALID_CONN);
    }

    // assign connection id
    assert(connConfig.connId == -1);
    connConfig.connId = numConnections;

    KERNEL_DEBUG("CONNECT SETUP: connId=%d, mulFast=%f, mulSlow=%f", connConfig.connId, connConfig.mulSynFast, connConfig.mulSynSlow);

    // store the configuration of a connection
    connectConfigMap[numConnections] = connConfig; // connConfig.connId == numConnections

    assert(numConnections < MAX_CONN_PER_SNN);  // make sure we don't overflow connId
    numConnections++;

    return (numConnections - 1);
}

// make custom connections from grpId1 to grpId2
short int SNN::connect(int grpId1, int grpId2, ConnectionGeneratorCore* conn, float _mulSynFast, float _mulSynSlow,
                        bool synWtType) {
    int retId=-1;

    assert(grpId1 < numGroups);
    assert(grpId2 < numGroups);

    // initialize the configuration of a connection
    ConnectConfig connConfig;
    STDPConfig stdpConfig;

    connConfig.grpSrc   = grpId1;
    connConfig.grpDest  = grpId2;
    connConfig.initWt     = 0.0f;
    connConfig.maxWt      = 0.0f;
    connConfig.maxDelay = MAX_SYN_DELAY;
    connConfig.minDelay = 1;
    connConfig.mulSynFast = _mulSynFast;
    connConfig.mulSynSlow = _mulSynSlow;
    connConfig.connProp = SET_CONN_PRESENT(1) | SET_FIXED_PLASTIC(synWtType);
    connConfig.type = CONN_USER_DEFINED;
    connConfig.conn = conn;
    connConfig.connectionMonitorId = -1;
    connConfig.connId = -1;
    connConfig.numberOfConnections = 0;
    connConfig.stdpConfig = stdpConfig;


    // assign a connection id
    assert(connConfig.connId == -1);
    connConfig.connId = numConnections;

    // store the configuration of a connection
    connectConfigMap[numConnections] = connConfig; // connConfig.connId == numConnections

    assert(numConnections < MAX_CONN_PER_SNN);  // make sure we don't overflow connId
    numConnections++;

    return (numConnections - 1);
}

// make a compartmental connection between two groups
short int SNN::connectCompartments(int grpIdLower, int grpIdUpper) {
    assert(grpIdLower >= 0 && grpIdLower < numGroups);
    assert(grpIdUpper >= 0 && grpIdUpper < numGroups);
    assert(grpIdLower != grpIdUpper);
    assert(!isPoissonGroup(grpIdLower));
    assert(!isPoissonGroup(grpIdUpper));

    // the two groups must be located on the same partition
    assert(groupConfigMap[grpIdLower].preferredNetId == groupConfigMap[grpIdUpper].preferredNetId);

    // this flag must be set if any compartmental connections exist
    // note that grpId.withCompartments is not necessarily set just yet, this will be done in
    // CpuSNN::setCompartmentParameters
    sim_with_compartments = true;

    compConnectConfig compConnConfig;

    compConnConfig.grpSrc = grpIdLower;
    compConnConfig.grpDest = grpIdUpper;
    compConnConfig.connId = -1;

    // assign a connection id
    assert(compConnConfig.connId == -1);
    compConnConfig.connId = numCompartmentConnections;

    // store the configuration of a connection
    compConnectConfigMap[numCompartmentConnections] = compConnConfig;

    numCompartmentConnections++;

    return (numCompartmentConnections - 1);
}

// create group of Izhikevich neurons
// use int for nNeur to avoid arithmetic underflow
int SNN::createGroup(const std::string& grpName, const Grid3D& grid, int neurType, int preferredPartition, ComputingBackend preferredBackend) {
    assert(grid.numX * grid.numY * grid.numZ > 0);
    assert(neurType >= 0);
    assert(numGroups < MAX_GRP_PER_SNN);

    if ( (!(neurType & TARGET_AMPA) && !(neurType & TARGET_NMDA) &&
          !(neurType & TARGET_GABAa) && !(neurType & TARGET_GABAb)) || (neurType & POISSON_NEURON)) {
        KERNEL_ERROR("Invalid type using createGroup... Cannot create poisson generators here.");
        exitSimulation(KERNEL_ERROR_POISSON_1);
    }

    // initialize group configuration
    GroupConfig grpConfig;
    GroupConfigMD grpConfigMD;

    //All groups are non-compartmental by default
    grpConfig.withCompartments = false;

    // init parameters of neural group size and location
    grpConfig.grpName = grpName;
    grpConfig.type = neurType;
    grpConfig.numN = grid.N;

    grpConfig.isSpikeGenerator = false;
    grpConfig.grid = grid;
    grpConfig.isLIF = false;

    grpConfig.WithSTDP = false;
    grpConfig.WithDA_MOD = false;
#ifdef LN_AXON_PLAST
    grpConfig.WithAxonPlast = true;   
    grpConfig.AxonPlast_TAU = 25; 
#endif

    if (preferredPartition == ANY) {
        grpConfig.preferredNetId = ANY;
    } else if (preferredBackend == CPU_CORES) {
        grpConfig.preferredNetId = preferredPartition + CPU_RUNTIME_BASE;
    } else {
        grpConfig.preferredNetId = preferredPartition + GPU_RUNTIME_BASE;
    }

    // assign a global group id
    grpConfigMD.gGrpId = numGroups;

    // store the configuration of a group
    groupConfigMap[numGroups] = grpConfig; // numGroups == grpId
    groupConfigMDMap[numGroups] = grpConfigMD;

    assert(numGroups < MAX_GRP_PER_SNN); // make sure we don't overflow connId
    numGroups++;

    return grpConfigMD.gGrpId;
}

// create group of LIF neurons
// use int for nNeur to avoid arithmetic underflow
int SNN::createGroupLIF(const std::string& grpName, const Grid3D& grid, int neurType, int preferredPartition, ComputingBackend preferredBackend) {
    assert(grid.numX * grid.numY * grid.numZ > 0);
    assert(neurType >= 0);
    assert(numGroups < MAX_GRP_PER_SNN);

    if ( (!(neurType & TARGET_AMPA) && !(neurType & TARGET_NMDA) &&
          !(neurType & TARGET_GABAa) && !(neurType & TARGET_GABAb)) || (neurType & POISSON_NEURON)) {
        KERNEL_ERROR("Invalid type using createGroup... Cannot create poisson generators here.");
        exitSimulation(KERNEL_ERROR_POISSON_2);
    }

    // initialize group configuration
    GroupConfig grpConfig;
    GroupConfigMD grpConfigMD;

    // init parameters of neural group size and location
    grpConfig.grpName = grpName;
    grpConfig.type = neurType;
    grpConfig.numN = grid.N;

    grpConfig.isLIF = true;
    grpConfig.isSpikeGenerator = false;
    grpConfig.grid = grid;

    grpConfig.WithSTDP = false;
    grpConfig.WithDA_MOD = false;
#ifdef LN_AXON_PLAST
    grpConfig.WithAxonPlast = false;
#endif

    if (preferredPartition == ANY) {
        grpConfig.preferredNetId = ANY;
    } else if (preferredBackend == CPU_CORES) {
        grpConfig.preferredNetId = preferredPartition + CPU_RUNTIME_BASE;
    } else {
        grpConfig.preferredNetId = preferredPartition + GPU_RUNTIME_BASE;
    }

    // assign a global group id
    grpConfigMD.gGrpId = numGroups;

    // store the configuration of a group
    groupConfigMap[numGroups] = grpConfig; // numGroups == grpId
    groupConfigMDMap[numGroups] = grpConfigMD;

    assert(numGroups < MAX_GRP_PER_SNN); // make sure we don't overflow connId
    numGroups++;

    return grpConfigMD.gGrpId;
}

// create spike generator group
// use int for nNeur to avoid arithmetic underflow
int SNN::createSpikeGeneratorGroup(const std::string& grpName, const Grid3D& grid, int neurType, int preferredPartition, ComputingBackend preferredBackend) {
    assert(grid.numX * grid.numY * grid.numZ > 0);
    assert(neurType >= 0);
    assert(numGroups < MAX_GRP_PER_SNN);

    // initialize group configuration
    GroupConfig grpConfig;
    GroupConfigMD grpConfigMD;

    //All groups are non-compartmental by default  FIXME:IS THIS NECESSARY?
    grpConfig.withCompartments = false;

    // init parameters of neural group size and location
    grpConfig.grpName = grpName;
    grpConfig.type = neurType | POISSON_NEURON;
    grpConfig.numN = grid.N;
    grpConfig.isSpikeGenerator = true;
    grpConfig.grid = grid;
    grpConfig.isLIF = false;

    grpConfig.WithSTDP = false;
    grpConfig.WithDA_MOD = false;
#ifdef LN_AXON_PLAST
    grpConfig.WithAxonPlast = false;
#endif

    if (preferredPartition == ANY) {
        grpConfig.preferredNetId = ANY;
    }
    else if (preferredBackend == CPU_CORES) {
        grpConfig.preferredNetId = preferredPartition + CPU_RUNTIME_BASE;
    }
    else {
        grpConfig.preferredNetId = preferredPartition + GPU_RUNTIME_BASE;
    }

    // assign a global group id
    grpConfigMD.gGrpId = numGroups;

    // store the configuration of a group
    groupConfigMap[numGroups] = grpConfig;
    groupConfigMDMap[numGroups] = grpConfigMD;

    assert(numGroups < MAX_GRP_PER_SNN); // make sure we don't overflow connId
    numGroups++;
    numSpikeGenGrps++;

    return grpConfigMD.gGrpId;
}

void SNN::setCompartmentParameters(int gGrpId, float couplingUp, float couplingDown) {
    if (gGrpId == ALL) {
        for (int grpId = 0; grpId<numGroups; grpId++) {
            setCompartmentParameters(grpId, couplingUp, couplingDown);
        }
    }
    else {
        groupConfigMap[gGrpId].withCompartments = true;
        groupConfigMap[gGrpId].compCouplingUp = couplingUp;
        groupConfigMap[gGrpId].compCouplingDown = couplingDown;
        glbNetworkConfig.numComp += groupConfigMap[gGrpId].numN;
    }
}

#define LN_I_CALC_TYPES__REQUIRED_FOR_BACKWARD_COMPAT
#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVEL
// set conductance values for a simulation (custom values or disable conductances alltogether)
void SNN::setConductances(bool isSet, int tdAMPA, int trNMDA, int tdNMDA, int tdGABAa, int trGABAb, int tdGABAb) {
    if (isSet) {
        assert(tdAMPA>0); assert(tdNMDA>0); assert(tdGABAa>0); assert(tdGABAb>0);
        assert(trNMDA>=0); assert(trGABAb>=0); // 0 to disable rise times
        assert(trNMDA!=tdNMDA); assert(trGABAb!=tdGABAb); // singularity
    }

    // set conductances globally for all connections
    sim_with_conductances  |= isSet;
    dAMPA  = 1.0-1.0/tdAMPA;
    dNMDA  = 1.0-1.0/tdNMDA;
    dGABAa = 1.0-1.0/tdGABAa;
    dGABAb = 1.0-1.0/tdGABAb;

    if (trNMDA>0) {
        // use rise time for NMDA
        sim_with_NMDA_rise = true;
        rNMDA = 1.0-1.0/trNMDA;

        // compute max conductance under this model to scale it back to 1
        // otherwise the peak conductance will not be equal to the weight
        double tmax = (-tdNMDA*trNMDA*log(1.0*trNMDA/tdNMDA))/(tdNMDA-trNMDA); // t at which cond will be max
        sNMDA = 1.0/(exp(-tmax/tdNMDA)-exp(-tmax/trNMDA)); // scaling factor, 1 over max amplitude
        //assert(!std::isinf<double>(tmax) && !std::isnan<double>(tmax) && tmax >= 0);
        assert(!std::isinf(tmax) && !std::isnan(tmax) && tmax >= 0);
        assert(!std::isinf(sNMDA) && !std::isnan(sNMDA) && sNMDA>0);
    }

    if (trGABAb>0) {
        // use rise time for GABAb
        sim_with_GABAb_rise = true;
        rGABAb = 1.0-1.0/trGABAb;

        // compute max conductance under this model to scale it back to 1
        // otherwise the peak conductance will not be equal to the weight
        double tmax = (-tdGABAb*trGABAb*log(1.0*trGABAb/tdGABAb))/(tdGABAb-trGABAb); // t at which cond will be max
        sGABAb = 1.0/(exp(-tmax/tdGABAb)-exp(-tmax/trGABAb)); // scaling factor, 1 over max amplitude
        assert(!std::isinf(tmax) && !std::isnan(tmax)); assert(!std::isinf(sGABAb) && !std::isnan(sGABAb) && sGABAb>0);
    }

    if (sim_with_conductances) {
        KERNEL_INFO("Running COBA mode:");
        KERNEL_INFO("  - AMPA decay time            = %5d ms", tdAMPA);
        KERNEL_INFO("  - NMDA rise time %s  = %5d ms", sim_with_NMDA_rise?"          ":"(disabled)", trNMDA);
        KERNEL_INFO("  - GABAa decay time           = %5d ms", tdGABAa);
        KERNEL_INFO("  - GABAb rise time %s = %5d ms", sim_with_GABAb_rise?"          ":"(disabled)",trGABAb);
        KERNEL_INFO("  - GABAb decay time           = %5d ms", tdGABAb);
    } else {
        KERNEL_INFO("Running CUBA mode (all synaptic conductances disabled)");
    }
}
#ifdef LN_I_CALC_TYPES
// set conductance values for a group (custom values or disable conductances)
// LN2021
// control conductance values at group level
// same interface design is used in order to maintain backward compatibilty
// Defaul CUBA => singel group(s) opt in to COBA with special paramters; however Network does need to support COBA despite
// Default COBA => single group(s) opt out with CUBA; Network already does support COBA 
// Default CUBA & NMweighted => other context, here irrelevant
void SNN::setConductances(int gGrpId, bool isSet, int tdAMPA, int trNMDA, int tdNMDA, int tdGABAa, int trGABAb, int tdGABAb) {

    if (isSet) {
        assert(tdAMPA > 0); assert(tdNMDA > 0); assert(tdGABAa > 0); assert(tdGABAb > 0);
        assert(trNMDA >= 0); assert(trGABAb >= 0); // 0 to disable rise times
        assert(trNMDA != tdNMDA); assert(trGABAb != tdGABAb); // singularity
    }

    // set conductances globaly for all connections
    sim_with_conductances |= isSet;

    // however,  group default CUBA  => and globally set to COBA 
    // => Default set to UNKNOWN, then how ever it needs to be defined if COBA or CUBA
    // => need some basic to set CUBA ? or use the same interface than isSet = false is used to set CUBA 
    // and sim_with_conductances is .. l

    // globalGroup ID 
    auto &groupConfig = groupConfigMap[gGrpId];
    groupConfig.icalcType = isSet ? COBA : CUBA;  // generic reused method, in CUBA the conductance params are 0

    auto &config = groupConfig.conductanceConfig;
    config.dAMPA = 1.0f-1.0f/tdAMPA;;
    config.dNMDA = 1.0f-1.0f/tdNMDA;
    config.dGABAa = 1.0f-1.0f/tdGABAa;
    config.dGABAb = 1.0f-1.0f/tdGABAb;

    if (trNMDA > 0) {
        // use rise time for NMDA
        sim_with_NMDA_rise = true;
        groupConfig.with_NMDA_rise = true;
        config.rNMDA = 1.0f-1.0f/trNMDA;

        // compute max conductance under this model to scale it back to 1
        // otherwise the peak conductance will not be equal to the weight
        float tmax = (-tdNMDA * trNMDA * log(1.0f * trNMDA / tdNMDA)) / (tdNMDA - trNMDA); // t at which cond will be max
        config.sNMDA = 1.0f / (exp(-tmax / tdNMDA) - exp(-tmax / trNMDA)); // scaling factor, 1 over max amplitude
        assert(!std::isinf(tmax) && !std::isnan(tmax) && tmax >= 0.0f);
        assert(!std::isinf(config.sNMDA) && !std::isnan(config.sNMDA) && config.sNMDA > 0.0f);
        //assert(!std::isinf<float>(tmax) && !std::isnan<float>(tmax) && tmax >= 0.0f);
        //assert(!std::isinf<float>(config.sNMDA) && !std::isnan<float>(config.sNMDA) && config.sNMDA > 0.0f);
    }

    if (trGABAb > 0) {
        // use rise time for GABAb
        sim_with_GABAb_rise = true;
        groupConfig.with_GABAb_rise = true;
        config.rGABAb = 1.0f-1.0f/trGABAb;

        // compute max conductance under this model to scale it back to 1
        // otherwise the peak conductance will not be equal to the weight
        float tmax = (-tdGABAb * trGABAb * log(1.0f * trGABAb / tdGABAb)) / (tdGABAb - trGABAb); // t at which cond will be max
        config.sGABAb = 1.0f / (exp(-tmax / tdGABAb) - exp(-tmax / trGABAb)); // scaling factor, 1 over max amplitude
        assert(!std::isinf(tmax) && !std::isnan(tmax)); assert(!std::isinf(config.sGABAb) && !std::isnan(config.sGABAb) && config.sGABAb > 0.0f); // LN2021 fix gcc
        //assert(!std::isinf<float>(tmax) && !std::isnan<float>(tmax)); assert(!std::isinf<float>(config.sGABAb) && !std::isnan<float>(config.sGABAb) && config.sGABAb > 0.0f);  // obsolete
    }

    if (isSet) {
        KERNEL_INFO("Running group (G:%d) COBA mode:", gGrpId);
        KERNEL_INFO("  - AMPA decay time            = %5d ms", tdAMPA);
        KERNEL_INFO("  - NMDA rise time %s  = %5d ms", (trNMDA > 0) ? "          " : "(disabled)", trNMDA);
        KERNEL_INFO("  - GABAa decay time           = %5d ms", tdGABAa);
        KERNEL_INFO("  - GABAb rise time %s = %5d ms", (trGABAb > 0) ? "          " : "(disabled)", trGABAb);
        KERNEL_INFO("  - GABAb decay time           = %5d ms", tdGABAb);
    }
    else {
        KERNEL_INFO("Running group %d in CUBA mode (synaptic conductances disabled)", gGrpId);
    }
}


void SNN::setNM4weighted(int gGrpId, IcalcType icalc, float wDA, float w5HT, float wACh, float wNE, float wNorm, float wBase) {

    // globalGroup ID 
    auto &groupConfig = groupConfigMap[gGrpId];

    groupConfig.icalcType = icalc;

    auto &w = groupConfig.nm4wConfig.w;

    w[NM_DA]        = wDA;
    w[NM_5HT]       = w5HT;
    w[NM_ACh]       = wACh;
    w[NM_NE]        = wNE;
    w[NM_NE+1]      = wNorm;
    w[NM_NE+2]      = wBase;
    
    KERNEL_INFO("Running group (G:%d) IcalcType: %s", gGrpId, IcalcType_string[icalc]);
    KERNEL_INFO("  - Weights (DA, 5HT, ACh, NE)     = %.1f %.1f %.1f %.1f ", wDA, w5HT, wACh, wNE);
    KERNEL_INFO("  - Normalization/Boost, Base      = %.1f %.1f", wNorm, wBase);

}




#endif

// set homeostasis for group
void SNN::setHomeostasis(int gGrpId, bool isSet, float homeoScale, float avgTimeScale) {
    if (gGrpId == ALL) { // shortcut for all groups
        for(int grpId = 0; grpId < numGroups; grpId++) {
            setHomeostasis(grpId, isSet, homeoScale, avgTimeScale);
        }
    } else {
        // set conductances for a given group
        sim_with_homeostasis                      |= isSet;
        groupConfigMap[gGrpId].homeoConfig.WithHomeostasis    = isSet;
        groupConfigMap[gGrpId].homeoConfig.homeostasisScale   = homeoScale;
        groupConfigMap[gGrpId].homeoConfig.avgTimeScale       = avgTimeScale;
        groupConfigMap[gGrpId].homeoConfig.avgTimeScaleInv    = 1.0f / avgTimeScale;
        groupConfigMap[gGrpId].homeoConfig.avgTimeScaleDecay = (avgTimeScale * 1000.0f - 1.0f) / (avgTimeScale * 1000.0f);

        KERNEL_INFO("Homeostasis parameters %s for %d (%s):\thomeoScale: %f, avgTimeScale: %f",
                    isSet?"enabled":"disabled", gGrpId, groupConfigMap[gGrpId].grpName.c_str(), homeoScale, avgTimeScale);
    }
}

// set a homeostatic target firing rate (enforced through homeostatic synaptic scaling)
void SNN::setHomeoBaseFiringRate(int gGrpId, float baseFiring, float baseFiringSD) {
    if (gGrpId == ALL) { // shortcut for all groups
        for(int grpId = 0; grpId < numGroups; grpId++) {
            setHomeoBaseFiringRate(grpId, baseFiring, baseFiringSD);
        }
    } else {
        // set homeostatsis for a given group
        groupConfigMap[gGrpId].homeoConfig.baseFiring = baseFiring;
        groupConfigMap[gGrpId].homeoConfig.baseFiringSD = baseFiringSD;

        KERNEL_INFO("Homeostatic base firing rate set for %d (%s):\tbaseFiring: %3.3f, baseFiringStd: %3.3f",
                            gGrpId, groupConfigMap[gGrpId].grpName.c_str(), baseFiring, baseFiringSD);
    }
}


void SNN::setIntegrationMethod(integrationMethod_t method, int numStepsPerMs) {
    assert(numStepsPerMs >= 1 && numStepsPerMs <= 100);
    glbNetworkConfig.simIntegrationMethod = method;
    glbNetworkConfig.simNumStepsPerMs = numStepsPerMs;
    glbNetworkConfig.timeStep = 1.0f / numStepsPerMs;
}

// set Izhikevich parameters for group
void SNN::setNeuronParameters(int gGrpId, 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)
{
    assert(gGrpId >= -1);
    assert(izh_a_sd >= 0); assert(izh_b_sd >= 0); assert(izh_c_sd >= 0); assert(izh_d_sd >= 0);

    if (gGrpId == ALL) { // shortcut for all groups
        for(int grpId = 0; grpId < numGroups; grpId++) {
            setNeuronParameters(grpId, izh_a, izh_a_sd, izh_b, izh_b_sd, izh_c, izh_c_sd, izh_d, izh_d_sd);
        }
    } else {
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_a = izh_a;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_a_sd = izh_a_sd;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_b = izh_b;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_b_sd = izh_b_sd;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_c = izh_c;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_c_sd = izh_c_sd;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_d = izh_d;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_d_sd = izh_d_sd;
        groupConfigMap[gGrpId].withParamModel_9 = 0;
        groupConfigMap[gGrpId].isLIF = 0;
    }
}

// set (9) Izhikevich parameters for group
void SNN::setNeuronParameters(int gGrpId, 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)
{
    assert(gGrpId >= -1);
    assert(izh_C_sd >= 0); assert(izh_k_sd >= 0); assert(izh_vr_sd >= 0);
    assert(izh_vt_sd >= 0); assert(izh_a_sd >= 0); assert(izh_b_sd >= 0); assert(izh_vpeak_sd >= 0);
    assert(izh_c_sd >= 0); assert(izh_d_sd >= 0);

    if (gGrpId == ALL) { // shortcut for all groups
        for (int grpId = 0; grpId<numGroups; grpId++) {
            setNeuronParameters(grpId, izh_C, izh_C_sd, izh_k, izh_k_sd, izh_vr, izh_vr_sd, izh_vt, izh_vt_sd,
                izh_a, izh_a_sd, izh_b, izh_b_sd, izh_vpeak, izh_vpeak_sd, izh_c, izh_c_sd,
                izh_d, izh_d_sd);
        }
    }
    else {
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_a = izh_a;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_a_sd = izh_a_sd;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_b = izh_b;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_b_sd = izh_b_sd;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_c = izh_c;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_c_sd = izh_c_sd;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_d = izh_d;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_d_sd = izh_d_sd;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_C = izh_C;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_C_sd = izh_C_sd;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_k = izh_k;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_k_sd = izh_k_sd;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vr = izh_vr;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vr_sd = izh_vr_sd;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vt = izh_vt;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vt_sd = izh_vt_sd;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vpeak = izh_vpeak;
        groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vpeak_sd = izh_vpeak_sd;
        groupConfigMap[gGrpId].withParamModel_9 = 1;
        groupConfigMap[gGrpId].isLIF = 0;
        KERNEL_INFO("Set a nine parameter group!");
    }
}


// set LIF parameters for the group
void SNN::setNeuronParametersLIF(int gGrpId, int tau_m, int tau_ref, float vTh, float vReset, double minRmem, double maxRmem)
{
    assert(gGrpId >= -1);
    assert(tau_m >= 0); assert(tau_ref >= 0); assert(vReset < vTh);
    assert(minRmem >= 0.0f); assert(minRmem <= maxRmem);

    if (gGrpId == ALL) { // shortcut for all groups
        for(int grpId = 0; grpId < numGroups; grpId++) {
            setNeuronParametersLIF(grpId, tau_m, tau_ref, vTh, vReset, minRmem, maxRmem);
        }
    } else {
        groupConfigMap[gGrpId].neuralDynamicsConfig.lif_tau_m = tau_m;
        groupConfigMap[gGrpId].neuralDynamicsConfig.lif_tau_ref = tau_ref;
        groupConfigMap[gGrpId].neuralDynamicsConfig.lif_vTh = vTh;
        groupConfigMap[gGrpId].neuralDynamicsConfig.lif_vReset = vReset;
        groupConfigMap[gGrpId].neuralDynamicsConfig.lif_minRmem = minRmem;
        groupConfigMap[gGrpId].neuralDynamicsConfig.lif_maxRmem = maxRmem;
        groupConfigMap[gGrpId].withParamModel_9 = 0;
        groupConfigMap[gGrpId].isLIF = 1;
    }
}


void SNN::setNeuromodulator(int gGrpId,
    float baseDP, float tauDP,
    float base5HT, float tau5HT,
    float baseACh, float tauACh,
    float baseNE, float tauNE)
{
    return setNeuromodulator(gGrpId,
        baseDP, tauDP, 0.04f, true,
        base5HT, tau5HT, 0.04f, true,
        baseACh, tauACh, 0.04f, true,
        baseNE, tauNE, 0.04f, true);
}

void SNN::setNeuromodulator(int gGrpId, 
    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)
{
    assert(gGrpId >= -1);
    assert(baseDP >= 0.0f); assert(base5HT >= 0.0f); assert(baseACh >= 0.0f); assert(baseNE >= 0.0f);  // LN2021 relexed to non-negative
    assert(tauDP > 0); assert(tau5HT > 0); assert(tauACh > 0); assert(tauNE > 0);

    if (gGrpId == ALL) { // shortcut for all groups
        for (int grpId = 0; grpId < numGroups; grpId++) {
            setNeuromodulator(grpId, 
                baseDP, tauDP, releaseDP, activeDP,
                base5HT, tau5HT, release5HT, active5HT,
                baseACh, tauACh, releaseACh, activeACh,
                baseNE, tauNE, releaseNE, activeNE);
        }
    } else {
        groupConfigMap[gGrpId].neuromodulatorConfig.baseDP = baseDP;
        groupConfigMap[gGrpId].neuromodulatorConfig.decayDP = 1.0f - (1.0f / tauDP);
        groupConfigMap[gGrpId].neuromodulatorConfig.releaseDP = releaseDP;
        groupConfigMap[gGrpId].neuromodulatorConfig.activeDP = activeDP;

        groupConfigMap[gGrpId].neuromodulatorConfig.base5HT = base5HT;
        groupConfigMap[gGrpId].neuromodulatorConfig.decay5HT = 1.0f - (1.0f / tau5HT);
        groupConfigMap[gGrpId].neuromodulatorConfig.release5HT = release5HT;
        groupConfigMap[gGrpId].neuromodulatorConfig.active5HT = active5HT;

        groupConfigMap[gGrpId].neuromodulatorConfig.baseACh = baseACh;
        groupConfigMap[gGrpId].neuromodulatorConfig.decayACh = 1.0f - (1.0f / tauACh);
        groupConfigMap[gGrpId].neuromodulatorConfig.releaseACh = releaseACh;
        groupConfigMap[gGrpId].neuromodulatorConfig.activeACh = activeACh;

        groupConfigMap[gGrpId].neuromodulatorConfig.baseNE = baseNE;
        groupConfigMap[gGrpId].neuromodulatorConfig.decayNE = 1.0f - (1.0f / tauNE);
        groupConfigMap[gGrpId].neuromodulatorConfig.releaseNE = releaseNE;
        groupConfigMap[gGrpId].neuromodulatorConfig.activeNE = activeNE;
    }
}

// set ESTDP params
void SNN::setESTDP(int preGrpId, int postGrpId, bool isSet, STDPType type, STDPCurve curve, float alphaPlus, float tauPlus, float alphaMinus, float tauMinus, float gamma) {
    assert(preGrpId >= -1);
    assert(postGrpId >= -1);
    assert(IS_EXCITATORY_TYPE(groupConfigMap[preGrpId].type) == true);

    if (isSet) {
        assert(type!=UNKNOWN_STDP);
        assert(tauPlus > 0.0f); assert(tauMinus > 0.0f); assert(gamma >= 0.0f);
    }

    short int connId = getConnectId(preGrpId, postGrpId);
    if (connId < 0) {
        KERNEL_ERROR("No connection found from group %d(%s) to group %d(%s)", preGrpId, getGroupName(preGrpId).c_str(),
            postGrpId, getGroupName(postGrpId).c_str());
        exitSimulation(KERNEL_ERROR_CONN_MISSING);
    }

    // set STDP for a given connection
    // set params for STDP curve
    connectConfigMap[connId].stdpConfig.ALPHA_PLUS_EXC      = alphaPlus;
    connectConfigMap[connId].stdpConfig.ALPHA_MINUS_EXC     = alphaMinus;
    connectConfigMap[connId].stdpConfig.TAU_PLUS_INV_EXC    = 1.0f / tauPlus;
    connectConfigMap[connId].stdpConfig.TAU_MINUS_INV_EXC   = 1.0f / tauMinus;
    connectConfigMap[connId].stdpConfig.GAMMA               = gamma;
    connectConfigMap[connId].stdpConfig.KAPPA               = (1 + exp(-gamma / tauPlus)) / (1 - exp(-gamma / tauPlus));
    connectConfigMap[connId].stdpConfig.OMEGA               = alphaPlus * (1 - connectConfigMap[connId].stdpConfig.KAPPA);
    // set flags for STDP function
    connectConfigMap[connId].stdpConfig.WithESTDPtype   = type;
    connectConfigMap[connId].stdpConfig.WithESTDPcurve  = curve;
    connectConfigMap[connId].stdpConfig.WithESTDP       = isSet;
    connectConfigMap[connId].stdpConfig.WithSTDP        |= connectConfigMap[connId].stdpConfig.WithESTDP;
    sim_with_stdp                                       |= connectConfigMap[connId].stdpConfig.WithSTDP;

    groupConfigMap[postGrpId].WithSTDP                  |= connectConfigMap[connId].stdpConfig.WithSTDP;
    groupConfigMap[postGrpId].WithDA_MOD                |= (type == DA_MOD);
#ifdef LN_I_CALC_TYPES
    groupConfigMap[postGrpId].WithPKA_PLC_MOD           |= (type == PKA_PLC_MOD);
#endif

    KERNEL_INFO("E-STDP %s for %s(%d) to %s(%d)", isSet?"enabled":"disabled", groupConfigMap[preGrpId].grpName.c_str(), preGrpId,
                                                                                groupConfigMap[postGrpId].grpName.c_str(), postGrpId);
}

#ifdef LN_I_CALC_TYPES
// set ESTDP params
void SNN::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)
{
    assert(preGrpId >= -1);
    assert(postGrpId >= -1);
    assert(IS_EXCITATORY_TYPE(groupConfigMap[preGrpId].type) == true);

    if (isSet) {
        assert(type != UNKNOWN_STDP);
        assert(tauPlus > 0.0f); assert(tauMinus > 0.0f); 
        assert(w_pka >= 0.0f);  assert(w_plc >= 0.0f);
        assert(nm_pka >= 0);  assert(nm_plc >= 0); 
    }

    short int connId = getConnectId(preGrpId, postGrpId);
    if (connId < 0) {
        KERNEL_ERROR("No connection found from group %d(%s) to group %d(%s)", preGrpId, getGroupName(preGrpId).c_str(),
            postGrpId, getGroupName(postGrpId).c_str());
        exitSimulation(KERNEL_ERROR_CONN_MISSING2);
    }

    // set STDP for a given connection
    // set params for STDP curve
    connectConfigMap[connId].stdpConfig.ALPHA_PLUS_EXC = alphaPlus;
    connectConfigMap[connId].stdpConfig.ALPHA_MINUS_EXC = alphaMinus;
    connectConfigMap[connId].stdpConfig.TAU_PLUS_INV_EXC = 1.0f / tauPlus;
    connectConfigMap[connId].stdpConfig.TAU_MINUS_INV_EXC = 1.0f / tauMinus;
    connectConfigMap[connId].stdpConfig.GAMMA = 0.0f;
    connectConfigMap[connId].stdpConfig.KAPPA = 0.0f;
    connectConfigMap[connId].stdpConfig.OMEGA = 0.0f;
    connectConfigMap[connId].stdpConfig.NM_PKA = nm_pka;
    connectConfigMap[connId].stdpConfig.NM_PLC = nm_plc;
    connectConfigMap[connId].stdpConfig.W_PKA = w_pka;
    connectConfigMap[connId].stdpConfig.W_PLC = w_plc;
    // set flags for STDP function
    connectConfigMap[connId].stdpConfig.WithESTDPtype = type;
    connectConfigMap[connId].stdpConfig.WithESTDPcurve = curve;
    connectConfigMap[connId].stdpConfig.WithESTDP = isSet;
    connectConfigMap[connId].stdpConfig.WithSTDP |= connectConfigMap[connId].stdpConfig.WithESTDP;
    sim_with_stdp |= connectConfigMap[connId].stdpConfig.WithSTDP;

    groupConfigMap[postGrpId].WithSTDP |= connectConfigMap[connId].stdpConfig.WithSTDP;
    groupConfigMap[postGrpId].WithDA_MOD |= (type == DA_MOD);
    groupConfigMap[postGrpId].WithPKA_PLC_MOD |= (type == PKA_PLC_MOD);

    KERNEL_INFO("PKA/PLC E-STDP %s for %s(%d) to %s(%d)", isSet ? "enabled" : "disabled", groupConfigMap[preGrpId].grpName.c_str(), preGrpId,
        groupConfigMap[postGrpId].grpName.c_str(), postGrpId);
}


// 
void SNN::setConnectionModulation(int preGrpId, int postGrpId, IcalcType icalcType)
{
    assert(preGrpId >= -1);
    assert(postGrpId >= -1);

    short int connId = getConnectId(preGrpId, postGrpId);

    connectConfigMap[connId].icalcType = icalcType;
}
#endif


// set ISTDP params
void SNN::setISTDP(int preGrpId, int postGrpId, bool isSet, STDPType type, STDPCurve curve, float ab1, float ab2, float tau1, float tau2) {
    assert(preGrpId >= -1);
    assert(postGrpId >= -1);
    assert(IS_INHIBITORY_TYPE(groupConfigMap[preGrpId].type) == true);

    if (isSet) {
        assert(type != UNKNOWN_STDP);
        assert(tau1 > 0); assert(tau2 > 0);
    }

    short int connId = getConnectId(preGrpId, postGrpId);
    if (connId < 0) {
        KERNEL_ERROR("No connection found from group %d(%s) to group %d(%s)", preGrpId, getGroupName(preGrpId).c_str(),
            postGrpId, getGroupName(postGrpId).c_str());
        exitSimulation(KERNEL_ERROR_CONN_MISSING3);
    }

    // set STDP for a given connection
    // set params for STDP curve
    if (curve == EXP_CURVE) {
        connectConfigMap[connId].stdpConfig.ALPHA_PLUS_INB = ab1;
        connectConfigMap[connId].stdpConfig.ALPHA_MINUS_INB = ab2;
        connectConfigMap[connId].stdpConfig.TAU_PLUS_INV_INB = 1.0f / tau1;
        connectConfigMap[connId].stdpConfig.TAU_MINUS_INV_INB = 1.0f / tau2;
        connectConfigMap[connId].stdpConfig.BETA_LTP        = 0.0f;
        connectConfigMap[connId].stdpConfig.BETA_LTD        = 0.0f;
        connectConfigMap[connId].stdpConfig.LAMBDA          = 1.0f;
        connectConfigMap[connId].stdpConfig.DELTA           = 1.0f;
    } else {
        connectConfigMap[connId].stdpConfig.ALPHA_PLUS_INB = 0.0f;
        connectConfigMap[connId].stdpConfig.ALPHA_MINUS_INB = 0.0f;
        connectConfigMap[connId].stdpConfig.TAU_PLUS_INV_INB = 1.0f;
        connectConfigMap[connId].stdpConfig.TAU_MINUS_INV_INB = 1.0f;
        connectConfigMap[connId].stdpConfig.BETA_LTP        = ab1;
        connectConfigMap[connId].stdpConfig.BETA_LTD        = ab2;
        connectConfigMap[connId].stdpConfig.LAMBDA          = tau1;
        connectConfigMap[connId].stdpConfig.DELTA           = tau2;
    }
    // set flags for STDP function
    //FIXME: separate STDPType to ESTDPType and ISTDPType
    connectConfigMap[connId].stdpConfig.WithISTDPtype   = type;
    connectConfigMap[connId].stdpConfig.WithISTDPcurve  = curve;
    connectConfigMap[connId].stdpConfig.WithISTDP       = isSet;
    connectConfigMap[connId].stdpConfig.WithSTDP       |= connectConfigMap[connId].stdpConfig.WithISTDP;
    sim_with_stdp                                      |= connectConfigMap[connId].stdpConfig.WithSTDP;

    groupConfigMap[postGrpId].WithSTDP                 |= connectConfigMap[connId].stdpConfig.WithSTDP;
    groupConfigMap[postGrpId].WithDA_MOD               |= (type == DA_MOD);
#ifdef LN_I_CALC_TYPES
    groupConfigMap[postGrpId].WithPKA_PLC_MOD          |= (type == PKA_PLC_MOD);
#endif
    KERNEL_INFO("I-STDP %s for %s(%d) to %s(%d)", isSet?"enabled":"disabled", groupConfigMap[preGrpId].grpName.c_str(), preGrpId,
                                                                                groupConfigMap[postGrpId].grpName.c_str(), postGrpId);
}

// set STP params
void SNN::setSTP(int gGrpId, bool isSet, float STP_U, float STP_tau_u, float STP_tau_x) {
    assert(gGrpId >= -1);
    if (isSet) {
        assert(STP_U > 0 && STP_U <= 1); assert(STP_tau_u > 0); assert(STP_tau_x > 0);
    }

    if (gGrpId == ALL) { // shortcut for all groups
        for(int grpId = 0; grpId < numGroups; grpId++) {
            setSTP(grpId, isSet, STP_U, STP_tau_u, STP_tau_x);
        }
    } else {
        // set STP for a given group
        sim_with_stp                                    |= isSet;
        groupConfigMap[gGrpId].stpConfig.WithSTP        = isSet;
        groupConfigMap[gGrpId].stpConfig.STP_A          = (STP_U > 0.0f) ? 1.0 / STP_U : 1.0f; // scaling factor
        groupConfigMap[gGrpId].stpConfig.STP_U          = STP_U;
        groupConfigMap[gGrpId].stpConfig.STP_tau_u_inv  = 1.0f / STP_tau_u; // facilitatory
        groupConfigMap[gGrpId].stpConfig.STP_tau_x_inv  = 1.0f / STP_tau_x; // depressive

        KERNEL_INFO("STP %s for %d (%s):\tA: %1.4f, U: %1.4f, tau_u: %4.0f, tau_x: %4.0f", isSet?"enabled":"disabled",
                    gGrpId, groupConfigMap[gGrpId].grpName.c_str(), groupConfigMap[gGrpId].stpConfig.STP_A, STP_U, STP_tau_u, STP_tau_x);
    }
}


#ifdef LN_I_CALC_TYPES
void SNN::setNM4STP(int gGrpId, float wSTP_U[], float wSTP_tau_u[], float wSTP_tau_x[]) {
    assert(gGrpId >= -1);
    if (!groupConfigMap[gGrpId].stpConfig.WithSTP) {
        KERNEL_ERROR("STP must be set to be targeted");
    }

    auto& config = groupConfigMap[gGrpId].nm4StpConfig;

    config.WithNM4STP = true;

    for (int i = 0; i < NM_NE + 3; i++) {
        config.w_STP_U[i] = wSTP_U[i];
        config.w_STP_tau_u[i] = wSTP_tau_u[i];
        config.w_STP_tau_x[i] = wSTP_tau_x[i];
    }

}
#endif


void SNN::setWeightAndWeightChangeUpdate(UpdateInterval wtANDwtChangeUpdateInterval, bool enableWtChangeDecay, float wtChangeDecay) {
    assert(wtChangeDecay > 0.0f && wtChangeDecay < 1.0f);

    switch (wtANDwtChangeUpdateInterval) {
        case INTERVAL_10MS:
            wtANDwtChangeUpdateInterval_ = 10;
            break;
        case INTERVAL_100MS:
            wtANDwtChangeUpdateInterval_ = 100;
            break;
        case INTERVAL_1000MS:
        default:
            wtANDwtChangeUpdateInterval_ = 1000;
            break;
    }

    if (enableWtChangeDecay) {
        // set up stdp factor according to update interval
        switch (wtANDwtChangeUpdateInterval) {
        case INTERVAL_10MS:
            stdpScaleFactor_ = 0.005f;
            break;
        case INTERVAL_100MS:
            stdpScaleFactor_ = 0.05f;
            break;
        case INTERVAL_1000MS:
        default:
            stdpScaleFactor_ = 0.5f;
            break;
        }
        // set up weight decay
        wtChangeDecay_ = wtChangeDecay;
    } else {
        stdpScaleFactor_ = 1.0f;
        wtChangeDecay_ = 0.0f;
    }

    KERNEL_INFO("Update weight and weight change every %d ms", wtANDwtChangeUpdateInterval_);
    KERNEL_INFO("Weight Change Decay is %s", enableWtChangeDecay? "enabled" : "disable");
    KERNEL_INFO("STDP scale factor = %1.3f, wtChangeDecay = %1.3f", stdpScaleFactor_, wtChangeDecay_);
}




// reorganize the network and do the necessary allocation
// of all variable for carrying out the simulation..
// this code is run only one time during network initialization
void SNN::setupNetwork() {
    switch (snnState) {
    case CONFIG_SNN:
        compileSNN();
    case COMPILED_SNN:
        partitionSNN();
    case PARTITIONED_SNN:
        generateRuntimeSNN();
        break;
    case EXECUTABLE_SNN:
        break;
    default:
        KERNEL_ERROR("Unknown SNN state");
        break;
    }
}

#ifdef LN_SETUP_NETWORK_MT
// LN Test
#include <chrono>
// reorganize the network and do the necessary allocation
// of all variable for carrying out the simulation..
// this code is run only one time during network initialization
void SNN::setupNetworkMT() {
    auto t0 = std::chrono::steady_clock::now();
    auto t1 = std::chrono::steady_clock::now();
    std::chrono::duration<double> d = t1 - t0; // \todo double 
    switch (snnState) {
    case CONFIG_SNN:
        t0 = std::chrono::steady_clock::now();
        compileSNN();
        t1 = std::chrono::steady_clock::now();
        d = t1 - t0;
        printf("compileSNN: %.1fs\n", d);
    case COMPILED_SNN:
        t0 = std::chrono::steady_clock::now();
        partitionSNNMT();
        t1 = std::chrono::steady_clock::now();
        d = t1 - t0;
        printf("partitionSNNMT: %.1fs\n", d);
    case PARTITIONED_SNN:
        t0 = std::chrono::steady_clock::now();
        generateRuntimeSNN();
        t1 = std::chrono::steady_clock::now();
        d = t1 - t0;
        printf("generateRuntimeSNN: %.1fs\n", d);
        break;
    case EXECUTABLE_SNN:
        break;
    default:
        KERNEL_ERROR("Unknown SNN state");
        break;
    }
}
#endif


int SNN::runNetwork(int _nsec, int _nmsec, bool printRunSummary) {
    assert(_nmsec >= 0 && _nmsec < 1000);
    assert(_nsec  >= 0);
    int runDurationMs = _nsec*1000 + _nmsec;
    KERNEL_DEBUG("runNetwork: runDur=%dms, printRunSummary=%s", runDurationMs, printRunSummary?"y":"n");

    // setupNetwork() must have already been called
    assert(snnState == EXECUTABLE_SNN);

    // don't bother printing if logger mode is SILENT
    printRunSummary = (loggerMode_==SILENT) ? false : printRunSummary;

    // first-time run: inform the user the simulation is running now
    if (simTime==0 && printRunSummary) {
        KERNEL_INFO("");
        KERNEL_INFO("******************** Running the simulation on %d GPU(s) and %d CPU(s) ***************************", numGPUs, numCores);
        KERNEL_INFO("");
    }

    // reset all spike counters
    resetSpikeCnt(ALL);

    // store current start time for future reference
    simTimeRunStart = simTime;
    simTimeRunStop  = simTime + runDurationMs;
    assert(simTimeRunStop >= simTimeRunStart); // check for arithmetic underflow

    // ConnectionMonitor is a special case: we might want the first snapshot at t=0 in the binary
    // but updateTime() is false for simTime==0.
    // And we cannot put this code in ConnectionMonitorCore::init, because then the user would have no
    // way to call ConnectionMonitor::setUpdateTimeIntervalSec before...
    if (simTime == 0 && numConnectionMonitor) {
        updateConnectionMonitor();
    }

    // set the Poisson generation time slice to be at the run duration up to MAX_TIME_SLICE 
#if defined(WIN32) && defined(__NO_CUDA__) // LN2021 fix gcc
    setGrpTimeSlice(ALL, std::max<int>(1, std::min<int>(runDurationMs, MAX_TIME_SLICE)));  // LN2021 Fix Issue illegal token, unknown-type c++17 
#else
    setGrpTimeSlice(ALL, std::max(1, std::min(runDurationMs, MAX_TIME_SLICE)));  // LN2021 Fix Issue illegal token, unknown-type c++17 // gcc
#endif
#ifndef __NO_CUDA__
    CUDA_RESET_TIMER(timer);
    CUDA_START_TIMER(timer);
#endif

    //KERNEL_INFO("Reached the advSimStep loop!");

    // if nsec=0, simTimeMs=10, we need to run the simulator for 10 timeStep;
    // if nsec=1, simTimeMs=10, we need to run the simulator for 1*1000+10, time Step;
    for(int i = 0; i < runDurationMs; i++) {
        advSimStep();
        //KERNEL_INFO("Executed an advSimStep!");

        // update weight every updateInterval ms if plastic synapses present
        if (!sim_with_fixedwts && wtANDwtChangeUpdateInterval_ == ++wtANDwtChangeUpdateIntervalCnt_) {
            wtANDwtChangeUpdateIntervalCnt_ = 0; // reset counter
            if (!sim_in_testing) {
                // keep this if statement separate from the above, so that the counter is updated correctly
                updateWeights();
            }
        }

        // Note: updateTime() advance simTime, simTimeMs, and simTimeSec accordingly
        if (updateTime()) {
            // finished one sec of simulation...
            if (numSpikeMonitor) {
                updateSpikeMonitor();
            }
            if (numGroupMonitor) {
                updateGroupMonitor();
            }
            if (numConnectionMonitor) {
                updateConnectionMonitor();
            }
            if (numNeuronMonitor) {
                updateNeuronMonitor();
            }

            shiftSpikeTables();
        }

        fetchNeuronSpikeCount(ALL);
    }

    //KERNEL_INFO("Updated monitors!");

    // user can opt to display some runNetwork summary
    if (printRunSummary) {

        // if there are Monitors available and it's time to show the log, print status for each group
        if (numSpikeMonitor) {
            printStatusSpikeMonitor(ALL);
        }
        if (numConnectionMonitor) {
            printStatusConnectionMonitor(ALL);
        }
        if (numGroupMonitor) {
            printStatusGroupMonitor(ALL);
        }

        // record time of run summary print
        simTimeLastRunSummary = simTime;
    }

    // call updateSpike(Group)Monitor again to fetch all the left-over spikes and group status (neuromodulator)
    updateSpikeMonitor();
    updateGroupMonitor();

    // keep track of simulation time...
#ifndef __NO_CUDA__
    CUDA_STOP_TIMER(timer);
    lastExecutionTime = CUDA_GET_TIMER_VALUE(timer);
    cumExecutionTime += lastExecutionTime;
#endif
    return 0;
}




// adds a bias to every weight in the connection
void SNN::biasWeights(short int connId, float bias, bool updateWeightRange) {
    assert(connId>=0 && connId<numConnections);

    int netId = groupConfigMDMap[connectConfigMap[connId].grpDest].netId;
    int lGrpId = groupConfigMDMap[connectConfigMap[connId].grpDest].lGrpId;

    fetchPreConnectionInfo(netId);
    fetchConnIdsLookupArray(netId);
    fetchSynapseState(netId);
    // iterate over all postsynaptic neurons
    for (int lNId = groupConfigs[netId][lGrpId].lStartN; lNId <= groupConfigs[netId][lGrpId].lEndN; lNId++) {
        unsigned int cumIdx = managerRuntimeData.cumulativePre[lNId];

        // iterate over all presynaptic neurons
        unsigned int pos_ij = cumIdx;
        for (int j = 0; j < managerRuntimeData.Npre[lNId]; pos_ij++, j++) {
            if (managerRuntimeData.connIdsPreIdx[pos_ij] == connId) {
                // apply bias to weight
                float weight = managerRuntimeData.wt[pos_ij] + bias;

                // inform user of acton taken if weight is out of bounds
//              bool needToPrintDebug = (weight+bias>connInfo->maxWt || weight+bias<connInfo->minWt);
                bool needToPrintDebug = (weight > connectConfigMap[connId].maxWt || weight < 0.0f);

                if (updateWeightRange) {
                    // if this flag is set, we need to update minWt,maxWt accordingly
                    // will be saving new maxSynWt and copying to GPU below
//                  connInfo->minWt = fmin(connInfo->minWt, weight);
#if defined(WIN32) && defined(__NO_CUDA__) // LN2021 fix gcc
                    connectConfigMap[connId].maxWt = std::max<float>(connectConfigMap[connId].maxWt, weight);
#else
                    connectConfigMap[connId].maxWt = std::max(connectConfigMap[connId].maxWt, weight);  
#endif
                    if (needToPrintDebug) {
                        KERNEL_DEBUG("biasWeights(%d,%f,%s): updated weight ranges to [%f,%f]", connId, bias,
                            (updateWeightRange?"true":"false"), 0.0f, connectConfigMap[connId].maxWt);
                    }
                } else {
                    // constrain weight to boundary values
                    // compared to above, we swap minWt/maxWt logic
#if defined(WIN32) && defined(__NO_CUDA__) // LN2021 fix gcc
                    weight = std::min<float>(weight, connectConfigMap[connId].maxWt);
#else
                    weight = std::min(weight, connectConfigMap[connId].maxWt);  // LN2021 gcc, Workaround for VC no longer neccessary
#endif
                    //                  weight = fmax(weight, connInfo->minWt);
#if defined(WIN32) && defined(__NO_CUDA__) // LN2021 fix gcc
                    weight = std::max<float>(weight, 0.0f);
#else
                    weight = std::max(weight, 0.0f);
#endif
                    if (needToPrintDebug) {
                        KERNEL_DEBUG("biasWeights(%d,%f,%s): constrained weight %f to [%f,%f]", connId, bias,
                            (updateWeightRange?"true":"false"), weight, 0.0f, connectConfigMap[connId].maxWt);
                    }
                }

                // update datastructures
                managerRuntimeData.wt[pos_ij] = weight;
                managerRuntimeData.maxSynWt[pos_ij] = connectConfigMap[connId].maxWt; // it's easier to just update, even if it hasn't changed
            }
        }

        // update GPU datastructures in batches, grouped by post-neuron
        if (netId < CPU_RUNTIME_BASE) {
#ifndef __NO_CUDA__
            CUDA_CHECK_ERRORS( cudaMemcpy(&(runtimeData[netId].wt[cumIdx]), &(managerRuntimeData.wt[cumIdx]), sizeof(float)*managerRuntimeData.Npre[lNId],
                cudaMemcpyHostToDevice) );

            if (runtimeData[netId].maxSynWt != NULL) {
                // only copy maxSynWt if datastructure actually exists on the GPU runtime
                // (that logic should be done elsewhere though)
                CUDA_CHECK_ERRORS( cudaMemcpy(&(runtimeData[netId].maxSynWt[cumIdx]), &(managerRuntimeData.maxSynWt[cumIdx]),
                    sizeof(float) * managerRuntimeData.Npre[lNId], cudaMemcpyHostToDevice) );
            }
#else
            assert(false);
#endif
        } else {
            memcpy(&runtimeData[netId].wt[cumIdx], &managerRuntimeData.wt[cumIdx], sizeof(float) * managerRuntimeData.Npre[lNId]);

            if (runtimeData[netId].maxSynWt != NULL) {
                // only copy maxSynWt if datastructure actually exists on the CPU runtime
                // (that logic should be done elsewhere though)
                memcpy(&runtimeData[netId].maxSynWt[cumIdx], &managerRuntimeData.maxSynWt[cumIdx], sizeof(float) * managerRuntimeData.Npre[lNId]);
            }
        }
    }
}

// deallocates dynamical structures and exits
void SNN::exitSimulation(int val) {
    deleteObjects();
    exit(val);
}

// reads network state from file
void SNN::loadSimulation(FILE* fid) {
    loadSimFID = fid;
}

// multiplies every weight with a scaling factor
void SNN::scaleWeights(short int connId, float scale, bool updateWeightRange) {
    assert(connId>=0 && connId<numConnections);
    assert(scale>=0.0f);

    int netId = groupConfigMDMap[connectConfigMap[connId].grpDest].netId;
    int lGrpId = groupConfigMDMap[connectConfigMap[connId].grpDest].lGrpId;

    fetchPreConnectionInfo(netId);
    fetchConnIdsLookupArray(netId);
    fetchSynapseState(netId);

    // iterate over all postsynaptic neurons
    for (int lNId = groupConfigs[netId][lGrpId].lStartN; lNId <= groupConfigs[netId][lGrpId].lEndN; lNId++) {
        unsigned int cumIdx = managerRuntimeData.cumulativePre[lNId];

        // iterate over all presynaptic neurons
        unsigned int pos_ij = cumIdx;
        for (int j = 0; j < managerRuntimeData.Npre[lNId]; pos_ij++, j++) {
            if (managerRuntimeData.connIdsPreIdx[pos_ij]==connId) {
                // apply bias to weight
                float weight = managerRuntimeData.wt[pos_ij] * scale;

                // inform user of acton taken if weight is out of bounds
//              bool needToPrintDebug = (weight>connInfo->maxWt || weight<connInfo->minWt);
                bool needToPrintDebug = (weight > connectConfigMap[connId].maxWt || weight < 0.0f);

                if (updateWeightRange) {
                    // if this flag is set, we need to update minWt,maxWt accordingly
                    // will be saving new maxSynWt and copying to GPU below
//                  connInfo->minWt = fmin(connInfo->minWt, weight);
#if defined(WIN32) && defined(__NO_CUDA__) // LN2021 fix gcc
                    connectConfigMap[connId].maxWt = std::max<float>(connectConfigMap[connId].maxWt, weight);
#else
                    connectConfigMap[connId].maxWt = std::max(connectConfigMap[connId].maxWt, weight);
#endif
                    if (needToPrintDebug) {
                        KERNEL_DEBUG("scaleWeights(%d,%f,%s): updated weight ranges to [%f,%f]", connId, scale,
                            (updateWeightRange?"true":"false"), 0.0f, connectConfigMap[connId].maxWt);
                    }
                } else {
                    // constrain weight to boundary values
                    // compared to above, we swap minWt/maxWt logic
#if defined(WIN32) && defined(__NO_CUDA__) // LN2021 fix gcc
                    weight = std::min<float>(weight, connectConfigMap[connId].maxWt);
#else
                    weight = std::min(weight, connectConfigMap[connId].maxWt);  // LN2021 gcc
#endif
//                  weight = fmax(weight, connInfo->minWt);
#if defined(WIN32) && defined(__NO_CUDA__) // LN2021 fix gcc
                    weight = std::max<float>(weight, 0.0f);   // \todo Issue 
#else
                    weight = std::max(weight, 0.0f);   // \todo Issue  lower bound
#endif
                    if (needToPrintDebug) {
                        KERNEL_DEBUG("scaleWeights(%d,%f,%s): constrained weight %f to [%f,%f]", connId, scale,
                            (updateWeightRange?"true":"false"), weight, 0.0f, connectConfigMap[connId].maxWt);
                    }
                }

                // update datastructures
                managerRuntimeData.wt[pos_ij] = weight;
                managerRuntimeData.maxSynWt[pos_ij] = connectConfigMap[connId].maxWt; // it's easier to just update, even if it hasn't changed
            }
        }

        // update GPU datastructures in batches, grouped by post-neuron
        if (netId < CPU_RUNTIME_BASE) {
#ifndef __NO_CUDA__
            CUDA_CHECK_ERRORS(cudaMemcpy(&runtimeData[netId].wt[cumIdx], &managerRuntimeData.wt[cumIdx], sizeof(float)*managerRuntimeData.Npre[lNId],
                cudaMemcpyHostToDevice));

            if (runtimeData[netId].maxSynWt != NULL) {
                // only copy maxSynWt if datastructure actually exists on the GPU runtime
                // (that logic should be done elsewhere though)
                CUDA_CHECK_ERRORS(cudaMemcpy(&runtimeData[netId].maxSynWt[cumIdx], &managerRuntimeData.maxSynWt[cumIdx],
                    sizeof(float) * managerRuntimeData.Npre[lNId], cudaMemcpyHostToDevice));
            }
#else
            assert(false);
#endif
        } else {
            memcpy(&runtimeData[netId].wt[cumIdx], &managerRuntimeData.wt[cumIdx], sizeof(float) * managerRuntimeData.Npre[lNId]);

            if (runtimeData[netId].maxSynWt != NULL) {
                // only copy maxSynWt if datastructure actually exists on the CPU runtime
                // (that logic should be done elsewhere though)
                memcpy(&runtimeData[netId].maxSynWt[cumIdx], &managerRuntimeData.maxSynWt[cumIdx], sizeof(float) * managerRuntimeData.Npre[lNId]);
            }
        }
    }
}

// FIXME: distinguish the function call at CONFIG_STATE and SETUP_STATE, where groupConfigs[0][] might not be available
// or groupConfigMap is not sync with groupConfigs[0][]
GroupMonitor* SNN::setGroupMonitor(int gGrpId, FILE* fid, int mode) {
    int netId = groupConfigMDMap[gGrpId].netId;
    int lGrpId = groupConfigMDMap[gGrpId].lGrpId;

    // check whether group already has a GroupMonitor
    if (groupConfigMDMap[gGrpId].groupMonitorId >= 0) {
        KERNEL_ERROR("setGroupMonitor has already been called on Group %d (%s).", gGrpId, groupConfigMap[gGrpId].grpName.c_str());
        exitSimulation(KERNEL_ERROR_GROUPMON_SET);
    }

    // create new GroupMonitorCore object in any case and initialize analysis components
    // grpMonObj destructor (see below) will deallocate it
    GroupMonitorCore* grpMonCoreObj = new GroupMonitorCore(this, numGroupMonitor, gGrpId, mode);
    groupMonCoreList[numGroupMonitor] = grpMonCoreObj;

    // assign group status file ID if we selected to write to a file, else it's NULL
    // if file pointer exists, it has already been fopened
    // this will also write the header section of the group status file
    // grpMonCoreObj destructor will fclose it
    grpMonCoreObj->setGroupFileId(fid);

    // create a new GroupMonitor object for the user-interface
    // SNN::deleteObjects will deallocate it
    GroupMonitor* grpMonObj = new GroupMonitor(grpMonCoreObj);
    groupMonList[numGroupMonitor] = grpMonObj;

    // also inform the group that it is being monitored...
    groupConfigMDMap[gGrpId].groupMonitorId = numGroupMonitor;

    numGroupMonitor++;
    KERNEL_INFO("GroupMonitor set for group %d (%s)", gGrpId, groupConfigMap[gGrpId].grpName.c_str());

    return grpMonObj;
}

// FIXME: distinguish the function call at CONFIG_STATE and SETUP_STATE, where group(connect)Config[] might not be available
// or group(connect)ConfigMap is not sync with group(connect)Config[]
ConnectionMonitor* SNN::setConnectionMonitor(int grpIdPre, int grpIdPost, FILE* fid) {
    // find connection based on pre-post pair
    short int connId = getConnectId(grpIdPre, grpIdPost);
    if (connId<0) {
        KERNEL_ERROR("No connection found from group %d(%s) to group %d(%s)", grpIdPre, getGroupName(grpIdPre).c_str(),
            grpIdPost, getGroupName(grpIdPost).c_str());
        exitSimulation(KERNEL_ERROR_CONN_MISSING4);
    }

    // check whether connection already has a connection monitor
    if (connectConfigMap[connId].connectionMonitorId >= 0) {
        KERNEL_ERROR("setConnectionMonitor has already been called on Connection %d (MonitorId=%d)", connId, connectConfigMap[connId].connectionMonitorId);
        exitSimulation(KERNEL_ERROR_CONNMON_SET);
    }

    // inform the connection that it is being monitored...
    // this needs to be called before new ConnectionMonitorCore
    connectConfigMap[connId].connectionMonitorId = numConnectionMonitor;

    // create new ConnectionMonitorCore object in any case and initialize
    // connMonObj destructor (see below) will deallocate it
    ConnectionMonitorCore* connMonCoreObj = new ConnectionMonitorCore(this, numConnectionMonitor, connId,
        grpIdPre, grpIdPost);
    connMonCoreList[numConnectionMonitor] = connMonCoreObj;

    // assign conn file ID if we selected to write to a file, else it's NULL
    // if file pointer exists, it has already been fopened
    // this will also write the header section of the conn file
    // connMonCoreObj destructor will fclose it
    connMonCoreObj->setConnectFileId(fid);

    // create a new ConnectionMonitor object for the user-interface
    // SNN::deleteObjects will deallocate it
    ConnectionMonitor* connMonObj = new ConnectionMonitor(connMonCoreObj);
    connMonList[numConnectionMonitor] = connMonObj;

    // now init core object (depends on several datastructures allocated above)
    connMonCoreObj->init();

    numConnectionMonitor++;
    KERNEL_INFO("ConnectionMonitor %d set for Connection %d: %d(%s) => %d(%s)", connectConfigMap[connId].connectionMonitorId, connId, grpIdPre, getGroupName(grpIdPre).c_str(),
        grpIdPost, getGroupName(grpIdPost).c_str());

    return connMonObj;
}

// FIXME: distinguish the function call at CONFIG_STATE and SETUP_STATE, where groupConfigs[0][] might not be available
// or groupConfigMap is not sync with groupConfigs[0][]
// sets up a spike generator
void SNN::setSpikeGenerator(int gGrpId, SpikeGeneratorCore* spikeGenFunc) {
    assert(snnState == CONFIG_SNN); // must be called before setupNetwork() to work on GPU
    assert(spikeGenFunc);
    assert(groupConfigMap[gGrpId].isSpikeGenerator);
    groupConfigMap[gGrpId].spikeGenFunc = spikeGenFunc;
}

// record spike information, return a SpikeInfo object
SpikeMonitor* SNN::setSpikeMonitor(int gGrpId, FILE* fid) {
    // check whether group already has a SpikeMonitor
    if (groupConfigMDMap[gGrpId].spikeMonitorId >= 0) {
        // in this case, return the current object and update fid
        SpikeMonitor* spkMonObj = getSpikeMonitor(gGrpId);

        // update spike file ID
        SpikeMonitorCore* spkMonCoreObj = getSpikeMonitorCore(gGrpId);
        spkMonCoreObj->setSpikeFileId(fid);

        KERNEL_INFO("SpikeMonitor updated for group %d (%s)", gGrpId, groupConfigMap[gGrpId].grpName.c_str());
        return spkMonObj;
    } else {
        // create new SpikeMonitorCore object in any case and initialize analysis components
        // spkMonObj destructor (see below) will deallocate it
        SpikeMonitorCore* spkMonCoreObj = new SpikeMonitorCore(this, numSpikeMonitor, gGrpId);
        spikeMonCoreList[numSpikeMonitor] = spkMonCoreObj;

        // assign spike file ID if we selected to write to a file, else it's NULL
        // if file pointer exists, it has already been fopened
        // this will also write the header section of the spike file
        // spkMonCoreObj destructor will fclose it
        spkMonCoreObj->setSpikeFileId(fid);

        // create a new SpikeMonitor object for the user-interface
        // SNN::deleteObjects will deallocate it
        SpikeMonitor* spkMonObj = new SpikeMonitor(spkMonCoreObj);
        spikeMonList[numSpikeMonitor] = spkMonObj;

        // also inform the grp that it is being monitored...
        groupConfigMDMap[gGrpId].spikeMonitorId = numSpikeMonitor;

        numSpikeMonitor++;
        KERNEL_INFO("SpikeMonitor set for group %d (%s)", gGrpId, groupConfigMap[gGrpId].grpName.c_str());

        return spkMonObj;
    }
}

// record neuron state information, return a NeuronInfo object
NeuronMonitor* SNN::setNeuronMonitor(int gGrpId, FILE* fid) {
    int lGrpId = groupConfigMDMap[gGrpId].lGrpId;
    int netId = groupConfigMDMap[gGrpId].netId;

    if (getGroupNumNeurons(gGrpId) > 128) {
        KERNEL_WARN("Due to limited memory space, only the first 128 neurons can be monitored by NeuronMonitor");
    }

    // check whether group already has a NeuronMonitor
    if (groupConfigMDMap[gGrpId].neuronMonitorId >= 0) {
        // in this case, return the current object and update fid
        NeuronMonitor* nrnMonObj = getNeuronMonitor(gGrpId);

        // update neuron file ID
        NeuronMonitorCore* nrnMonCoreObj = getNeuronMonitorCore(gGrpId);
        nrnMonCoreObj->setNeuronFileId(fid);

        KERNEL_INFO("NeuronMonitor updated for group %d (%s)", gGrpId, groupConfigMap[gGrpId].grpName.c_str());
        return nrnMonObj;
    } else {
        // create new NeuronMonitorCore object in any case and initialize analysis components
        // nrnMonObj destructor (see below) will deallocate it
        NeuronMonitorCore* nrnMonCoreObj = new NeuronMonitorCore(this, numNeuronMonitor, gGrpId);
        neuronMonCoreList[numNeuronMonitor] = nrnMonCoreObj;

        // assign neuron state file ID if we selected to write to a file, else it's NULL
        // if file pointer exists, it has already been fopened
        // this will also write the header section of the spike file
        // spkMonCoreObj destructor will fclose it
        nrnMonCoreObj->setNeuronFileId(fid);

        // create a new NeuronMonitor object for the user-interface
        // SNN::deleteObjects will deallocate it
        NeuronMonitor* nrnMonObj = new NeuronMonitor(nrnMonCoreObj);
        neuronMonList[numNeuronMonitor] = nrnMonObj;

        // also inform the grp that it is being monitored...
        groupConfigMDMap[gGrpId].neuronMonitorId = numNeuronMonitor;

        numNeuronMonitor++;
        KERNEL_INFO("NeuronMonitor set for group %d (%s)", gGrpId, groupConfigMap[gGrpId].grpName.c_str());

        return nrnMonObj;
    }
}

// FIXME: distinguish the function call at CONFIG_STATE and RUN_STATE, where groupConfigs[0][] might not be available
// or groupConfigMap is not sync with groupConfigs[0][]
// assigns spike rate to group
void SNN::setSpikeRate(int gGrpId, PoissonRate* ratePtr, int refPeriod) {
    int netId = groupConfigMDMap[gGrpId].netId;
    int lGrpId = groupConfigMDMap[gGrpId].lGrpId;

    assert(gGrpId >= 0 && lGrpId < networkConfigs[netId].numGroups);
    assert(ratePtr);
    assert(groupConfigMap[gGrpId].isSpikeGenerator);
    assert(ratePtr->getNumNeurons() == groupConfigMap[gGrpId].numN);
    assert(refPeriod >= 1);

    groupConfigMDMap[gGrpId].ratePtr = ratePtr;
    groupConfigMDMap[gGrpId].refractPeriod = refPeriod;
    spikeRateUpdated = true;
}

// sets the weight value of a specific synapse
void SNN::setWeight(short int connId, int neurIdPre, int neurIdPost, float weight, bool updateWeightRange) {
    assert(connId>=0 && connId<getNumConnections());
    assert(weight>=0.0f);

    assert(neurIdPre >= 0  && neurIdPre < getGroupNumNeurons(connectConfigMap[connId].grpSrc));
    assert(neurIdPost >= 0 && neurIdPost < getGroupNumNeurons(connectConfigMap[connId].grpDest));

    float maxWt = fabs(connectConfigMap[connId].maxWt);
    float minWt = 0.0f;

    // inform user of acton taken if weight is out of bounds
    bool needToPrintDebug = (weight>maxWt || weight<minWt);

    int netId = groupConfigMDMap[connectConfigMap[connId].grpDest].netId;
    int postlGrpId = groupConfigMDMap[connectConfigMap[connId].grpDest].lGrpId;
    int prelGrpId = groupConfigMDMap[connectConfigMap[connId].grpSrc].lGrpId;

    fetchPreConnectionInfo(netId);
    fetchConnIdsLookupArray(netId);
    fetchSynapseState(netId);

    if (updateWeightRange) {
        // if this flag is set, we need to update minWt,maxWt accordingly
        // will be saving new maxSynWt and copying to GPU below
//      connInfo->minWt = fmin(connInfo->minWt, weight);
        maxWt = fmax(maxWt, weight);
        if (needToPrintDebug) {
            KERNEL_DEBUG("setWeight(%d,%d,%d,%f,%s): updated weight ranges to [%f,%f]", connId, neurIdPre, neurIdPost,
                weight, (updateWeightRange?"true":"false"), minWt, maxWt);
        }
    } else {
        // constrain weight to boundary values
        // compared to above, we swap minWt/maxWt logic
        weight = fmin(weight, maxWt);
        weight = fmax(weight, minWt);
        if (needToPrintDebug) {
            KERNEL_DEBUG("setWeight(%d,%d,%d,%f,%s): constrained weight %f to [%f,%f]", connId, neurIdPre, neurIdPost,
                weight, (updateWeightRange?"true":"false"), weight, minWt, maxWt);
        }
    }

    // find real ID of pre- and post-neuron
    int neurIdPreReal = groupConfigs[netId][prelGrpId].lStartN + neurIdPre;
    int neurIdPostReal = groupConfigs[netId][postlGrpId].lStartN + neurIdPost;

    // iterate over all presynaptic synapses until right one is found
    bool synapseFound = false;
    int pos_ij = managerRuntimeData.cumulativePre[neurIdPostReal];
    for (int j = 0; j < managerRuntimeData.Npre[neurIdPostReal]; pos_ij++, j++) {
        SynInfo* preId = &(managerRuntimeData.preSynapticIds[pos_ij]);
        int pre_nid = GET_CONN_NEURON_ID((*preId));
        if (GET_CONN_NEURON_ID((*preId)) == neurIdPreReal) {
            assert(managerRuntimeData.connIdsPreIdx[pos_ij] == connId); // make sure we've got the right connection ID

            managerRuntimeData.wt[pos_ij] = isExcitatoryGroup(connectConfigMap[connId].grpSrc) ? weight : -1.0 * weight;
            managerRuntimeData.maxSynWt[pos_ij] = isExcitatoryGroup(connectConfigMap[connId].grpSrc) ? maxWt : -1.0 * maxWt;

            if (netId < CPU_RUNTIME_BASE) {
#ifndef __NO_CUDA__
                // need to update datastructures on GPU runtime
                CUDA_CHECK_ERRORS(cudaMemcpy(&runtimeData[netId].wt[pos_ij], &managerRuntimeData.wt[pos_ij], sizeof(float), cudaMemcpyHostToDevice));
                if (runtimeData[netId].maxSynWt != NULL) {
                    // only copy maxSynWt if datastructure actually exists on the GPU runtime
                    // (that logic should be done elsewhere though)
                    CUDA_CHECK_ERRORS(cudaMemcpy(&runtimeData[netId].maxSynWt[pos_ij], &managerRuntimeData.maxSynWt[pos_ij], sizeof(float), cudaMemcpyHostToDevice));
                }
#else
                assert(false);
#endif
            } else {
                // need to update datastructures on CPU runtime
                memcpy(&runtimeData[netId].wt[pos_ij], &managerRuntimeData.wt[pos_ij], sizeof(float));
                if (runtimeData[netId].maxSynWt != NULL) {
                    // only copy maxSynWt if datastructure actually exists on the CPU runtime
                    // (that logic should be done elsewhere though)
                    memcpy(&runtimeData[netId].maxSynWt[pos_ij], &managerRuntimeData.maxSynWt[pos_ij], sizeof(float));
                }
            }

            // synapse found and updated: we're done!
            synapseFound = true;
            break;
        }
    }

    if (!synapseFound) {
        KERNEL_WARN("setWeight(%d,%d,%d,%f,%s): Synapse does not exist, not updated.", connId, neurIdPre, neurIdPost,
            weight, (updateWeightRange?"true":"false"));
    }
}

void SNN::setExternalCurrent(int grpId, const std::vector<float>& current) {
    assert(grpId >= 0); assert(grpId < numGroups);
    assert(!isPoissonGroup(grpId));
    assert(current.size() == getGroupNumNeurons(grpId));

    int netId = groupConfigMDMap[grpId].netId;
    int lGrpId = groupConfigMDMap[grpId].lGrpId;

    // // update flag for faster handling at run-time
    // if (count_if(current.begin(), current.end(), isGreaterThanZero)) {
    //  groupConfigs[0][grpId].WithCurrentInjection = true;
    // } else {
    //  groupConfigs[0][grpId].WithCurrentInjection = false;
    // }

    // store external current in array
    for (int lNId = groupConfigs[netId][lGrpId].lStartN, j = 0; lNId <= groupConfigs[netId][lGrpId].lEndN; lNId++, j++) {
        managerRuntimeData.extCurrent[lNId] = current[j];
    }

    // copy to GPU if necessary
    // don't allocate; allocation done in generateRuntimeData
    if (netId < CPU_RUNTIME_BASE) {
        copyExternalCurrent(netId, lGrpId, &runtimeData[netId], cudaMemcpyHostToDevice, false);
    }
    else {
        copyExternalCurrent(netId, lGrpId, &runtimeData[netId], false);
    }
}

// writes network state to file
// handling of file pointer should be handled externally: as far as this function is concerned, it is simply
// trying to write to file
void SNN::saveSimulation(FILE* fid, bool saveSynapseInfo) {
    int tmpInt;
    float tmpFloat;


    tmpInt = 294338571; // some int used to identify saveSimulation files
    if (!fwrite(&tmpInt,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");

    tmpFloat = 0.3f;
    if (!fwrite(&tmpFloat,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");

    tmpFloat = ((float)simTimeSec) + ((float)simTimeMs)/1000.0f;
    if (!fwrite(&tmpFloat,sizeof(float),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");

    stopTiming();
    tmpFloat = executionTime/1000.0f;
    if (!fwrite(&tmpFloat,sizeof(float),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");


    if (!fwrite(&glbNetworkConfig.numN,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    int dummyInt = 0;
    //if (!fwrite(&numPreSynNet,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    // if (!fwrite(&dummyInt,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    //if (!fwrite(&numPostSynNet,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    // if (!fwrite(&dummyInt,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    if (!fwrite(&numGroups,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");

    char name[100];
    for (int gGrpId=0;gGrpId<numGroups;gGrpId++) {
        if (!fwrite(&groupConfigMDMap[gGrpId].gStartN,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
        if (!fwrite(&groupConfigMDMap[gGrpId].gEndN,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");

        if (!fwrite(&groupConfigMap[gGrpId].grid.numX,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
        if (!fwrite(&groupConfigMap[gGrpId].grid.numY,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
        if (!fwrite(&groupConfigMap[gGrpId].grid.numZ,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");

        strncpy(name,groupConfigMap[gGrpId].grpName.c_str(),100);
        if (!fwrite(name,1,100,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    }

    if (!saveSynapseInfo) return;

    // Save number of local networks
    int net_count = 0;
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            net_count++;
        }
    }
    if (!fwrite(&net_count, sizeof(int), 1, fid)) KERNEL_ERROR("saveSimulation fwrite error");

    // Save weights for each local network
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            // copy from runtimeData to managerRuntimeData
            fetchPreConnectionInfo(netId);
            fetchPostConnectionInfo(netId);
            fetchConnIdsLookupArray(netId);
            fetchSynapseState(netId);

            // save number of synapses that starting from local groups
            int numSynToSave = 0;
            for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[netId].begin(); grpIt != groupPartitionLists[netId].end(); grpIt++) {
                if (grpIt->netId == netId) {
                    numSynToSave += grpIt->numPostSynapses;
                }
            }
            if (!fwrite(&numSynToSave, sizeof(int), 1, fid)) KERNEL_ERROR("saveSimulation fwrite error");
            // read synapse info from managerRuntimData
            int numSynSaved = 0;
            for (int lNId = 0; lNId < networkConfigs[netId].numNAssigned; lNId++) {
                unsigned int offset = managerRuntimeData.cumulativePost[lNId];

                // save each synapse starting from from neuron lNId
                for (int t = 0; t < glbNetworkConfig.maxDelay; t++) {
                    DelayInfo dPar = managerRuntimeData.postDelayInfo[lNId*(glbNetworkConfig.maxDelay + 1)+t];

                    for (int idx_d=dPar.delay_index_start; idx_d < (dPar.delay_index_start + dPar.delay_length); idx_d++) {
                        SynInfo post_info = managerRuntimeData.postSynapticIds[offset + idx_d];
                        int lNIdPost = GET_CONN_NEURON_ID(post_info);
                        int lGrpIdPost = GET_CONN_GRP_ID(post_info);
                        int preSynId = GET_CONN_SYN_ID(post_info);
                        int pre_pos = managerRuntimeData.cumulativePre[lNIdPost] + preSynId;
                        SynInfo pre_info = managerRuntimeData.preSynapticIds[pre_pos];
                        int lNIdPre = GET_CONN_NEURON_ID(pre_info);
                        int lGrpIdPre = GET_CONN_GRP_ID(pre_info);
                        float weight = managerRuntimeData.wt[pre_pos];
                        float maxWeight = managerRuntimeData.maxSynWt[pre_pos];
                        int connId = managerRuntimeData.connIdsPreIdx[pre_pos];
                        int delay = t+1;

                        // convert local group id to global group id
                        // convert local neuron id to neuron order in group
                        int gGrpIdPre = groupConfigs[netId][lGrpIdPre].gGrpId;
                        int gGrpIdPost = groupConfigs[netId][lGrpIdPost].gGrpId;
                        int grpNIdPre = lNId - groupConfigs[netId][lGrpIdPre].lStartN;
                        int grpNIdPost = lNIdPost - groupConfigs[netId][lGrpIdPost].lStartN;

                        // we only save synapses starting from local groups since otherwise we will save external synapses twice 
                        // write order is based on function connectNeurons (no NetId & external_NetId)
                        // inline void SNN::connectNeurons(int netId, int _grpSrc, int _grpDest, int _nSrc, int _nDest, short int _connId, float initWt, float maxWt, uint8_t delay, int externalNetId) 
                        if (groupConfigMDMap[gGrpIdPre].netId == netId) {
                            numSynSaved++;
                            if (!fwrite(&gGrpIdPre, sizeof(int), 1, fid)) KERNEL_ERROR("saveSimulation fwrite error");
                            if (!fwrite(&gGrpIdPost, sizeof(int), 1, fid)) KERNEL_ERROR("saveSimulation fwrite error");
                            if (!fwrite(&grpNIdPre, sizeof(int), 1, fid)) KERNEL_ERROR("saveSimulation fwrite error");
                            if (!fwrite(&grpNIdPost, sizeof(int), 1, fid)) KERNEL_ERROR("saveSimulation fwrite error");
                            if (!fwrite(&connId, sizeof(int), 1, fid)) KERNEL_ERROR("saveSimulation fwrite error");
                            if (!fwrite(&weight, sizeof(float), 1, fid)) KERNEL_ERROR("saveSimulation fwrite error");
                            if (!fwrite(&maxWeight, sizeof(float), 1, fid)) KERNEL_ERROR("saveSimulation fwrite error");
                            if (!fwrite(&delay, sizeof(int), 1, fid)) KERNEL_ERROR("saveSimulation fwrite error");
                        }
                    }
                }
            }
            assert(numSynSaved == numSynToSave);
        }
    }


    //if (simMode_ == GPU_MODE)
    //  copyWeightState(&managerRuntimeData, &runtimeData[0], cudaMemcpyDeviceToHost, false);

    //if (saveSynapseInfo) {
    //  for (int i = 0; i < numN; i++) {
    //      unsigned int offset = managerRuntimeData.cumulativePost[i];

    //      unsigned int count = 0;
    //      for (int t=0;t<maxDelay_;t++) {
    //          DelayInfo dPar = managerRuntimeData.postDelayInfo[i*(maxDelay_+1)+t];

    //          for(int idx_d=dPar.delay_index_start; idx_d<(dPar.delay_index_start+dPar.delay_length); idx_d++)
    //              count++;
    //      }

    //      if (!fwrite(&count,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");

    //      for (int t=0;t<maxDelay_;t++) {
    //          DelayInfo dPar = managerRuntimeData.postDelayInfo[i*(maxDelay_+1)+t];

    //          for(int idx_d=dPar.delay_index_start; idx_d<(dPar.delay_index_start+dPar.delay_length); idx_d++) {
    //              // get synaptic info...
    //              SynInfo post_info = managerRuntimeData.postSynapticIds[offset + idx_d];

    //              // get neuron id
    //              //int p_i = (post_info&POST_SYN_NEURON_MASK);
    //              unsigned int p_i = GET_CONN_NEURON_ID(post_info);
    //              assert(p_i<numN);

    //              // get syn id
    //              unsigned int s_i = GET_CONN_SYN_ID(post_info);
    //              //>>POST_SYN_NEURON_BITS)&POST_SYN_CONN_MASK;
    //              assert(s_i<(managerRuntimeData.Npre[p_i]));

    //              // get the cumulative position for quick access...
    //              unsigned int pos_i = managerRuntimeData.cumulativePre[p_i] + s_i;

    //              uint8_t delay = t+1;
    //              uint8_t plastic = s_i < managerRuntimeData.Npre_plastic[p_i]; // plastic or fixed.

    //              if (!fwrite(&i,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    //              if (!fwrite(&p_i,sizeof(int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    //              if (!fwrite(&(managerRuntimeData.wt[pos_i]),sizeof(float),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    //              if (!fwrite(&(managerRuntimeData.maxSynWt[pos_i]),sizeof(float),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    //              if (!fwrite(&delay,sizeof(uint8_t),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    //              if (!fwrite(&plastic,sizeof(uint8_t),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    //              if (!fwrite(&(managerRuntimeData.connIdsPreIdx[pos_i]),sizeof(short int),1,fid)) KERNEL_ERROR("saveSimulation fwrite error");
    //          }
    //      }
    //  }
    //}
}

// writes population weights from gIDpre to gIDpost to file fname in binary
//void SNN::writePopWeights(std::string fname, int grpIdPre, int grpIdPost) {
//  assert(grpIdPre>=0); assert(grpIdPost>=0);
//
//  float* weights;
//  int matrixSize;
//  FILE* fid;
//  int numPre, numPost;
//  fid = fopen(fname.c_str(), "wb");
//  assert(fid != NULL);
//
//  if(snnState == CONFIG_SNN || snnState == COMPILED_SNN || snnState == PARTITIONED_SNN){
//      KERNEL_ERROR("Simulation has not been run yet, cannot output weights.");
//      exitSimulation(1);
//  }
//
//  SynInfo* preId;
//  int pre_nid, pos_ij;
//
//  //population sizes
//  numPre = groupConfigs[0][grpIdPre].SizeN;
//  numPost = groupConfigs[0][grpIdPost].SizeN;
//
//  //first iteration gets the number of synaptic weights to place in our
//  //weight matrix.
//  matrixSize=0;
//  //iterate over all neurons in the post group
//  for (int i=groupConfigs[0][grpIdPost].StartN; i<=groupConfigs[0][grpIdPost].EndN; i++) {
//      // for every post-neuron, find all pre
//      pos_ij = managerRuntimeData.cumulativePre[i]; // i-th neuron, j=0th synapse
//      //iterate over all presynaptic synapses
//      for(int j=0; j<managerRuntimeData.Npre[i]; pos_ij++,j++) {
//          preId = &managerRuntimeData.preSynapticIds[pos_ij];
//          pre_nid = GET_CONN_NEURON_ID((*preId)); // neuron id of pre
//          if (pre_nid<groupConfigs[0][grpIdPre].StartN || pre_nid>groupConfigs[0][grpIdPre].EndN)
//              continue; // connection does not belong to group grpIdPre
//          matrixSize++;
//      }
//  }
//
//  //now we have the correct size
//  weights = new float[matrixSize];
//  //second iteration assigns the weights
//  int curr = 0; // iterator for return array
//  //iterate over all neurons in the post group
//  for (int i=groupConfigs[0][grpIdPost].StartN; i<=groupConfigs[0][grpIdPost].EndN; i++) {
//      // for every post-neuron, find all pre
//      pos_ij = managerRuntimeData.cumulativePre[i]; // i-th neuron, j=0th synapse
//      //do the GPU copy here.  Copy the current weights from GPU to CPU.
//      if(simMode_==GPU_MODE){
//          copyWeightsGPU(i,grpIdPre);
//      }
//      //iterate over all presynaptic synapses
//      for(int j=0; j<managerRuntimeData.Npre[i]; pos_ij++,j++) {
//          preId = &(managerRuntimeData.preSynapticIds[pos_ij]);
//          pre_nid = GET_CONN_NEURON_ID((*preId)); // neuron id of pre
//          if (pre_nid<groupConfigs[0][grpIdPre].StartN || pre_nid>groupConfigs[0][grpIdPre].EndN)
//              continue; // connection does not belong to group grpIdPre
//          weights[curr] = managerRuntimeData.wt[pos_ij];
//          curr++;
//      }
//  }
//
//  fwrite(weights,sizeof(float),matrixSize,fid);
//  fclose(fid);
//  //Let my memory FREE!!!
//  delete [] weights;
//}



// set new file pointer for all files
// fp==NULL is code for don't change it
// can be called in all logger modes; however, the analogous interface function can only be called in CUSTOM
void SNN::setLogsFp(FILE* fpInf, FILE* fpErr, FILE* fpDeb, FILE* fpLog) {
    if (fpInf!=NULL) {
        if (fpInf_!=NULL && fpInf_!=stdout && fpInf_!=stderr)
            fclose(fpInf_);
        fpInf_ = fpInf;
    }

    if (fpErr!=NULL) {
        if (fpErr_ != NULL && fpErr_!=stdout && fpErr_!=stderr)
            fclose(fpErr_);
        fpErr_ = fpErr;
    }

    if (fpDeb!=NULL) {
        if (fpDeb_!=NULL && fpDeb_!=stdout && fpDeb_!=stderr)
            fclose(fpDeb_);
        fpDeb_ = fpDeb;
    }

    if (fpLog!=NULL) {
        if (fpLog_!=NULL && fpLog_!=stdout && fpLog_!=stderr)
            fclose(fpLog_);
        fpLog_ = fpLog;
    }
}



// loop over linked list entries to find a connection with the right pre-post pair, O(N)
short int SNN::getConnectId(int grpIdPre, int grpIdPost) {
    short int connId = -1;

    for (std::map<int, ConnectConfig>::iterator it = connectConfigMap.begin(); it != connectConfigMap.end(); it++) {
        if (it->second.grpSrc == grpIdPre && it->second.grpDest == grpIdPost) {
            connId = it->second.connId;
            break;
        }
    }

    return connId;
}

ConnectConfig SNN::getConnectConfig(short int connId) {
    CHECK_CONNECTION_ID(connId, numConnections);

    if (connectConfigMap.find(connId) == connectConfigMap.end()) {
        KERNEL_ERROR("Total Connections = %d", numConnections);
        KERNEL_ERROR("ConnectId (%d) cannot be recognized", connId);
    }

    return connectConfigMap[connId];
}

std::vector<float> SNN::getConductanceAMPA(int gGrpId) {
    assert(isSimulationWithCOBA());

    // copy data to the manager runtime
    fetchConductanceAMPA(gGrpId);

    std::vector<float> gAMPAvec;
    for (int gNId = groupConfigMDMap[gGrpId].gStartN; gNId <= groupConfigMDMap[gGrpId].gEndN; gNId++) {
        gAMPAvec.push_back(managerRuntimeData.gAMPA[gNId]);
    }
    return gAMPAvec;
}

std::vector<float> SNN::getConductanceNMDA(int gGrpId) {
#ifdef LN_I_CALC_TYPES
    assert(groupConfigMap[gGrpId].icalcType == COBA);
#else
    assert(isSimulationWithCOBA());
#endif

    // copy data to the manager runtime
    fetchConductanceNMDA(gGrpId);

    std::vector<float> gNMDAvec;
#ifdef LN_I_CALC_TYPES
        if(groupConfigMap[gGrpId].with_NMDA_rise) {
#else
        if (isSimulationWithNMDARise()) {
#endif
        // need to construct conductance from rise and decay parts
        for (int gNId = groupConfigMDMap[gGrpId].gStartN; gNId <= groupConfigMDMap[gGrpId].gEndN; gNId++) {
            gNMDAvec.push_back(managerRuntimeData.gNMDA_d[gNId] - managerRuntimeData.gNMDA_r[gNId]);
        }
    } else {
        for (int gNId = groupConfigMDMap[gGrpId].gStartN; gNId <= groupConfigMDMap[gGrpId].gEndN; gNId++) {
            gNMDAvec.push_back(managerRuntimeData.gNMDA[gNId]);
        }
    }
    return gNMDAvec;
}

std::vector<float> SNN::getConductanceGABAa(int gGrpId) {
    assert(isSimulationWithCOBA());

    // copy data to the manager runtime
    fetchConductanceGABAa(gGrpId);

    std::vector<float> gGABAaVec;
    for (int gNId = groupConfigMDMap[gGrpId].gStartN; gNId <= groupConfigMDMap[gGrpId].gEndN; gNId++) {
        gGABAaVec.push_back(managerRuntimeData.gGABAa[gNId]);
    }
    return gGABAaVec;
}

std::vector<float> SNN::getConductanceGABAb(int gGrpId) {
#ifdef LN_I_CALC_TYPES
    assert(groupConfigMap[gGrpId].icalcType == COBA);
#else
    assert(isSimulationWithCOBA());
#endif

    // copy data to the manager runtime
    fetchConductanceGABAb(gGrpId);

    std::vector<float> gGABAbVec;
#ifdef LN_I_CALC_TYPES
    if (groupConfigMap[gGrpId].with_GABAb_rise) {
#else
    if (isSimulationWithGABAbRise()) {
#endif
        // need to construct conductance from rise and decay parts
        for (int gNId = groupConfigMDMap[gGrpId].gStartN; gNId <= groupConfigMDMap[gGrpId].gEndN; gNId++) {
            gGABAbVec.push_back(managerRuntimeData.gGABAb_d[gNId] - managerRuntimeData.gGABAb_r[gNId]);
        }
    } else {
        for (int gNId = groupConfigMDMap[gGrpId].gStartN; gNId <= groupConfigMDMap[gGrpId].gEndN; gNId++) {
            gGABAbVec.push_back(managerRuntimeData.gGABAb[gNId]);
        }
    }
    return gGABAbVec;
}

// returns RangeDelay struct of a connection
RangeDelay SNN::getDelayRange(short int connId) {
    assert(connId>=0 && connId<numConnections);

    return RangeDelay(connectConfigMap[connId].minDelay, connectConfigMap[connId].maxDelay);
}

// \TODO: bad API design (return allocated memory to user), consider to move this function to connection monitor
uint8_t* SNN::getDelays(int gGrpIdPre, int gGrpIdPost, int& numPreN, int& numPostN) {
    int netIdPost = groupConfigMDMap[gGrpIdPost].netId;
    int lGrpIdPost = groupConfigMDMap[gGrpIdPost].lGrpId;
    int lGrpIdPre = -1;
    uint8_t* delays;

    for (int lGrpId = 0; lGrpId < networkConfigs[netIdPost].numGroupsAssigned; lGrpId++)
        if (groupConfigs[netIdPost][lGrpId].gGrpId == gGrpIdPre) {
            lGrpIdPre = lGrpId;
            break;
        }
    assert(lGrpIdPre != -1);

    numPreN = groupConfigMap[gGrpIdPre].numN;
    numPostN = groupConfigMap[gGrpIdPost].numN;

    delays = new uint8_t[numPreN * numPostN];
    memset(delays, 0, numPreN * numPostN);

    fetchPostConnectionInfo(netIdPost);

    for (int lNIdPre = groupConfigs[netIdPost][lGrpIdPre].lStartN; lNIdPre <= groupConfigs[netIdPost][lGrpIdPre].lEndN; lNIdPre++) {  // FIXED LN 2022 the end is an index as well
        unsigned int offset = managerRuntimeData.cumulativePost[lNIdPre];

        for (int t = 0; t < glbNetworkConfig.maxDelay; t++) {
            DelayInfo dPar = managerRuntimeData.postDelayInfo[lNIdPre * (glbNetworkConfig.maxDelay + 1) + t];

            for(int idx_d = dPar.delay_index_start; idx_d<(dPar.delay_index_start+dPar.delay_length); idx_d++) {
                // get synaptic info...
                SynInfo postSynInfo = managerRuntimeData.postSynapticIds[offset + idx_d];

                // get local post neuron id
                int lNIdPost = GET_CONN_NEURON_ID(postSynInfo);
                assert(lNIdPost < glbNetworkConfig.numN);

                if (lNIdPost >= groupConfigs[netIdPost][lGrpIdPost].lStartN && lNIdPost <= groupConfigs[netIdPost][lGrpIdPost].lEndN) {
                    delays[(lNIdPre - groupConfigs[netIdPost][lGrpIdPre].lStartN) + numPreN * (lNIdPost - groupConfigs[netIdPost][lGrpIdPost].lStartN)] = t + 1;
                }
            }
        }
    }
    return delays;
}

Grid3D SNN::getGroupGrid3D(int gGrpId) {
    assert(gGrpId >= 0 && gGrpId < numGroups);

    return groupConfigMap[gGrpId].grid;
}

// find ID of group with name grpName
int SNN::getGroupId(std::string grpName) {
    int grpId = -1;
    for (int gGrpId = 0; gGrpId < numGroups; gGrpId++) {
        if (groupConfigMap[gGrpId].grpName.compare(grpName) == 0) {
            grpId = gGrpId;
            break;
        }
    }

    return grpId;
}

std::string SNN::getGroupName(int gGrpId) {
    assert(gGrpId >= -1 && gGrpId < numGroups);

    if (gGrpId == ALL)
        return "ALL";

    return groupConfigMap[gGrpId].grpName;
}

ConnSTDPInfo SNN::getConnSTDPInfo(short int connId) {
    ConnSTDPInfo cInfo;

    cInfo.WithSTDP = connectConfigMap[connId].stdpConfig.WithSTDP;
    cInfo.WithESTDP = connectConfigMap[connId].stdpConfig.WithESTDP;
    cInfo.WithISTDP = connectConfigMap[connId].stdpConfig.WithISTDP;
    cInfo.WithESTDPtype = connectConfigMap[connId].stdpConfig.WithESTDPtype;
    cInfo.WithISTDPtype = connectConfigMap[connId].stdpConfig.WithISTDPtype;
    cInfo.WithESTDPcurve = connectConfigMap[connId].stdpConfig.WithESTDPcurve;
    cInfo.WithISTDPcurve = connectConfigMap[connId].stdpConfig.WithISTDPcurve;
    cInfo.ALPHA_MINUS_EXC = connectConfigMap[connId].stdpConfig.ALPHA_MINUS_EXC;
    cInfo.ALPHA_PLUS_EXC = connectConfigMap[connId].stdpConfig.ALPHA_PLUS_EXC;
    cInfo.TAU_MINUS_INV_EXC = connectConfigMap[connId].stdpConfig.TAU_MINUS_INV_EXC;
    cInfo.TAU_PLUS_INV_EXC = connectConfigMap[connId].stdpConfig.TAU_PLUS_INV_EXC;
    cInfo.ALPHA_MINUS_INB = connectConfigMap[connId].stdpConfig.ALPHA_MINUS_INB;
    cInfo.ALPHA_PLUS_INB = connectConfigMap[connId].stdpConfig.ALPHA_PLUS_INB;
    cInfo.TAU_MINUS_INV_INB = connectConfigMap[connId].stdpConfig.TAU_MINUS_INV_INB;
    cInfo.TAU_PLUS_INV_INB = connectConfigMap[connId].stdpConfig.TAU_PLUS_INV_INB;
    cInfo.GAMMA = connectConfigMap[connId].stdpConfig.GAMMA;
    cInfo.BETA_LTP = connectConfigMap[connId].stdpConfig.BETA_LTP;
    cInfo.BETA_LTD = connectConfigMap[connId].stdpConfig.BETA_LTD;
    cInfo.LAMBDA = connectConfigMap[connId].stdpConfig.LAMBDA;
    cInfo.DELTA = connectConfigMap[connId].stdpConfig.DELTA;

    return cInfo;
}

GroupNeuromodulatorInfo SNN::getGroupNeuromodulatorInfo(int gGrpId) {
    GroupNeuromodulatorInfo gInfo;

    gInfo.baseDP = groupConfigMap[gGrpId].neuromodulatorConfig.baseDP;
    gInfo.base5HT = groupConfigMap[gGrpId].neuromodulatorConfig.base5HT;
    gInfo.baseACh = groupConfigMap[gGrpId].neuromodulatorConfig.baseACh;
    gInfo.baseNE = groupConfigMap[gGrpId].neuromodulatorConfig.baseNE;

    gInfo.decayDP = groupConfigMap[gGrpId].neuromodulatorConfig.decayDP;
    gInfo.decay5HT = groupConfigMap[gGrpId].neuromodulatorConfig.decay5HT;
    gInfo.decayACh = groupConfigMap[gGrpId].neuromodulatorConfig.decayACh;
    gInfo.decayNE = groupConfigMap[gGrpId].neuromodulatorConfig.decayNE;

    gInfo.releaseDP = groupConfigMap[gGrpId].neuromodulatorConfig.releaseDP;
    gInfo.release5HT = groupConfigMap[gGrpId].neuromodulatorConfig.release5HT;
    gInfo.releaseACh = groupConfigMap[gGrpId].neuromodulatorConfig.releaseACh;
    gInfo.releaseNE = groupConfigMap[gGrpId].neuromodulatorConfig.releaseNE;

    gInfo.activeDP = groupConfigMap[gGrpId].neuromodulatorConfig.activeDP;
    gInfo.active5HT = groupConfigMap[gGrpId].neuromodulatorConfig.active5HT;
    gInfo.activeACh = groupConfigMap[gGrpId].neuromodulatorConfig.activeACh;
    gInfo.activeNE = groupConfigMap[gGrpId].neuromodulatorConfig.activeNE;

    return gInfo;
}

Point3D SNN::getNeuronLocation3D(int gNId) {
    int gGrpId = -1;
    assert(gNId >= 0 && gNId < glbNetworkConfig.numN);

    // search for global group id
    for (std::map<int, GroupConfigMD>::iterator grpIt = groupConfigMDMap.begin(); grpIt != groupConfigMDMap.end(); grpIt++) {
        if (gNId >= grpIt->second.gStartN && gNId <= grpIt->second.gEndN)
            gGrpId = grpIt->second.gGrpId;
    }

    // adjust neurId for neuron ID of first neuron in the group
    int neurId = gNId - groupConfigMDMap[gGrpId].gStartN;

    return getNeuronLocation3D(gGrpId, neurId);
}

Point3D SNN::getNeuronLocation3D(int gGrpId, int relNeurId) {
    Grid3D grid = groupConfigMap[gGrpId].grid;
    assert(gGrpId >= 0 && gGrpId < numGroups);
    assert(relNeurId >= 0 && relNeurId < getGroupNumNeurons(gGrpId));

    int intX = relNeurId % grid.numX;
    int intY = (relNeurId / grid.numX) % grid.numY;
    int intZ = relNeurId / (grid.numX * grid.numY);

    // get coordinates center around origin
    double coordX = grid.distX * intX + grid.offsetX;
    double coordY = grid.distY * intY + grid.offsetY;
    double coordZ = grid.distZ * intZ + grid.offsetZ;
    return Point3D(coordX, coordY, coordZ);
}


// LN DEBUG  gaussian problem  
// TODO check latest CARLsim 4.1 and 5.0

int SNN::getNeuronId(int gGrpId, Point3D location) {

    Grid3D grid = groupConfigMap[gGrpId].grid;
    assert(gGrpId >= 0 && gGrpId < numGroups);
    
    // translate coordinates center around origin
    int intX = round((location.x - grid.offsetX) / grid.distX);  // location.x = grid.distX * intX + grid.offsetX;
    int intY = round((location.y - grid.offsetY) / grid.distY);  // location.y = grid.distY * intY + grid.offsetY;
    int intZ = round((location.z - grid.offsetZ) / grid.distZ);  // location.z = grid.distZ * intZ + grid.offsetZ;

//  int intX = roundf((location.x - grid.offsetX - 1) / grid.distX - (-(grid.numX - 1) / 2));  // location.x = grid.distX * intX + grid.offsetX;
//  int intY = roundf((location.y - grid.offsetY - 1) / grid.distY - (-(grid.numY - 1) / 2)); ; // location.y = grid.distY * intY + grid.offsetY;
//  int intZ = roundf((location.z - grid.offsetZ - 1) / grid.distZ - (-(grid.numZ - 1) / 2)); ;  // location.z = grid.distZ * intZ + grid.offsetZ;

//  int intX = roundf(location.x + (grid.numX - 1) / 2);  // location.x = grid.distX * intX + grid.offsetX;
//  int intY = roundf(location.y + (grid.numY - 1) / 2);  // location.y = grid.distY * intY + grid.offsetY;
//  int intZ = roundf(location.z + (grid.numZ - 1) / 2);  // location.z = grid.distZ * intZ + grid.offsetZ;

//  printf("intX=%d, intY=%d, intZ=%d\n", intX, intY, intZ);

    // solve function that fullfils: 
    //  intX = relNeurId % grid.numX;
    //  intY = (relNeurId / grid.numX) % grid.numY;
    //  intZ = relNeurId / (grid.numX * grid.numY);
    //int relNeurId = intX + intY * grid.numX + intY + intZ * (grid.numX * grid.numY) + intZ;
    int relNeurId = intX + intY * grid.numX + intZ * (grid.numX * grid.numY);
    assert(relNeurId >= 0 && relNeurId < getGroupNumNeurons(gGrpId));

/*
    Nx = 2
    [-(Nx-1)/2, (Nx-1)/2]

    x_min = -(Nx-1)/2 = -(2-1)/2 = -0.5

    = offset
*/

    return relNeurId;
}


// returns the number of synaptic connections associated with this connection.
int SNN::getNumSynapticConnections(short int connId) {
    //we didn't find the connection.
    if (connectConfigMap.find(connId) == connectConfigMap.end()) {
        KERNEL_ERROR("Connection ID was not found.  Quitting.");
        exitSimulation(KERNEL_ERROR_CONN_MISSING5);
    }

    return connectConfigMap[connId].numberOfConnections;
}

// returns pointer to existing SpikeMonitor object, NULL else
SpikeMonitor* SNN::getSpikeMonitor(int gGrpId) {
    assert(gGrpId >= 0 && gGrpId < getNumGroups());

    if (groupConfigMDMap[gGrpId].spikeMonitorId >= 0) {
        return spikeMonList[(groupConfigMDMap[gGrpId].spikeMonitorId)];
    } else {
        return NULL;
    }
}

SpikeMonitorCore* SNN::getSpikeMonitorCore(int gGrpId) {
    assert(gGrpId >= 0 && gGrpId < getNumGroups());

    if (groupConfigMDMap[gGrpId].spikeMonitorId >= 0) {
        return spikeMonCoreList[(groupConfigMDMap[gGrpId].spikeMonitorId)];
    } else {
        return NULL;
    }
}

// returns pointer to existing NeuronMonitor object, NULL else
NeuronMonitor* SNN::getNeuronMonitor(int gGrpId) {
    assert(gGrpId >= 0 && gGrpId < getNumGroups());

    if (groupConfigMDMap[gGrpId].neuronMonitorId >= 0) {
        return neuronMonList[(groupConfigMDMap[gGrpId].neuronMonitorId)];
    }
    else {
        return NULL;
    }
}

NeuronMonitorCore* SNN::getNeuronMonitorCore(int gGrpId) {
    assert(gGrpId >= 0 && gGrpId < getNumGroups());

    if (groupConfigMDMap[gGrpId].neuronMonitorId >= 0) {
        return neuronMonCoreList[(groupConfigMDMap[gGrpId].neuronMonitorId)];
    }
    else {
        return NULL;
    }
}

RangeWeight SNN::getWeightRange(short int connId) {
    assert(connId>=0 && connId<numConnections);

    return RangeWeight(0.0f, connectConfigMap[connId].initWt, connectConfigMap[connId].maxWt);
}



// all unsafe operations of SNN constructor
void SNN::SNNinit() {
    // initialize snnState
    snnState = CONFIG_SNN;

    // set logger mode (defines where to print all status, error, and debug messages)
    switch (loggerMode_) {
    case USER:
        fpInf_ = stdout;
        fpErr_ = stderr;
        #if defined(WIN32) || defined(WIN64) || defined(__APPLE__)
            fpDeb_ = fopen("nul","w");
        #else
            fpDeb_ = fopen("/dev/null","w");
        #endif
        break;
    case DEVELOPER:
        fpInf_ = stdout;
        fpErr_ = stderr;
        fpDeb_ = stdout;
        break;
    case SHOWTIME:
        #if defined(WIN32) || defined(WIN64) || defined(__APPLE__)
            fpInf_ = fopen("nul","w");
        #else
            fpInf_ = fopen("/dev/null","w");
        #endif
        fpErr_ = stderr;
        #if defined(WIN32) || defined(WIN64) || defined(__APPLE__)
            fpDeb_ = fopen("nul","w");
        #else
            fpDeb_ = fopen("/dev/null","w");
        #endif
        break;
    case SILENT:
    case CUSTOM:
        #if defined(WIN32) || defined(WIN64) || defined(__APPLE__)
            fpInf_ = fopen("nul","w");
            fpErr_ = fopen("nul","w");
            fpDeb_ = fopen("nul","w");
        #else
            fpInf_ = fopen("/dev/null","w");
            fpErr_ = fopen("/dev/null","w");
            fpDeb_ = fopen("/dev/null","w");
        #endif
    break;
    default:
        fpErr_ = stderr; // need to open file stream first
        KERNEL_ERROR("Unknown logger mode");
        exit(UNKNOWN_LOGGER_ERROR);

    }

    // try to open log file in results folder: create if not exists
#if defined(WIN32) || defined(WIN64)
    CreateDirectory("results", NULL);
    fpLog_ = fopen("results/carlsim.log", "w");
#else
    struct stat sb;
    int createDir = 1;
    if (stat("results", &sb) == -1 || !S_ISDIR(sb.st_mode)) {
        // results dir does not exist, try to create:
        createDir = mkdir("results", 0777);
    }

    if (createDir == -1) {
        // tried to create dir, but failed
        fprintf(stderr, "Could not create directory \"results/\", which is required to "
            "store simulation results. Aborting simulation...\n");
        exit(NO_LOGGER_DIR_ERROR);
    } else {
        // open log file
        fpLog_ = fopen("results/carlsim.log", "w");

        if (createDir == 0) {
            // newly created dir: now that fpLog_/fpInf_ exist, inform user
            KERNEL_INFO("Created results directory \"results/\".");
        }
    }
#endif
    if (fpLog_ == NULL) {
        fprintf(stderr, "Could not create the directory \"results/\" or the log file \"results/carlsim.log\""
            ", which is required to store simulation results. Aborting simulation...\n");
        exit(NO_LOGGER_DIR_ERROR);
    }

    KERNEL_INFO("*********************************************************************************");
    KERNEL_INFO("********************      Welcome to CARLsim %d.%d      ***************************",
                MAJOR_VERSION,MINOR_VERSION);
    KERNEL_INFO("*********************************************************************************\n");

    KERNEL_INFO("***************************** Configuring Network ********************************");
    KERNEL_INFO("Starting CARLsim simulation \"%s\" in %s mode",networkName_.c_str(),
        loggerMode_string[loggerMode_]);
    KERNEL_INFO("Random number seed: %d",randSeed_);

    time_t rawtime;
    struct tm * timeinfo;
    time(&rawtime);
    timeinfo = localtime(&rawtime);
    KERNEL_DEBUG("Current local time and date: %s", asctime(timeinfo));

    // init random seed
    srand48(randSeed_);

    simTimeRunStart = 0; simTimeRunStop = 0;
    simTimeLastRunSummary = 0;
    simTimeMs = 0; simTimeSec = 0; simTime = 0;

    numGroups = 0;
    numConnections = 0;
    numCompartmentConnections = 0;
    numSpikeGenGrps = 0;
    simulatorDeleted = false;

    cumExecutionTime = 0.0f;
    executionTime = 0.0f;
    prevExecutionTime = 0.0f; // FIX 2022: Wrong display in Debug Mode

    spikeRateUpdated = false;
    numSpikeMonitor = 0;
    numNeuronMonitor = 0;
    numGroupMonitor = 0;
    numConnectionMonitor = 0;

    sim_with_compartments = false;
    sim_with_fixedwts = true; // default is true, will be set to false if there are any plastic synapses
#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVEL
    sim_with_conductances = false; // default is false
    sim_with_stdp = false;
    sim_with_modulated_stdp = false;
    sim_with_homeostasis = false;
    sim_with_stp = false;
    sim_in_testing = false;

    loadSimFID = NULL;

#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVEL
    // conductance info struct for simulation
    sim_with_NMDA_rise = false;
    sim_with_GABAb_rise = false;
#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVEL
#ifndef LN_I_CALC_TYPES
    dAMPA  = 1.0-1.0/5.0;       // some default decay and rise times
    rNMDA  = 1.0-1.0/10.0;
    dNMDA  = 1.0-1.0/150.0;
    sNMDA  = 1.0;
    dGABAa = 1.0-1.0/6.0;
    rGABAb = 1.0-1.0/100.0;
    dGABAb = 1.0-1.0/150.0;
    sGABAb = 1.0;
#endif
    // default integration method: Forward-Euler with 0.5ms integration step
    setIntegrationMethod(FORWARD_EULER, 2);

    mulSynFast = NULL;
    mulSynSlow = NULL;

    // reset all monitors, don't deallocate (false)
    resetMonitors(false);

    resetGroupConfigs(false);

    resetConnectionConfigs(false);

    // initialize spike buffer
    spikeBuf = new SpikeBuffer(0, MAX_TIME_SLICE);

    memset(networkConfigs, 0, sizeof(NetworkConfigRT) * MAX_NET_PER_SNN);

    // reset all runtime data
    // GPU/CPU runtime data
    memset(runtimeData, 0, sizeof(RuntimeData) * MAX_NET_PER_SNN);
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) // FIXME: redundant??   //LN2021 Yes, 0 --> false 
        runtimeData[netId].allocated = false;

    // Manager runtime data
    memset(&managerRuntimeData, 0, sizeof(RuntimeData));
    managerRuntimeData.allocated = false; // FIXME: redundant??

    // default weight update parameter
    wtANDwtChangeUpdateInterval_ = 1000; // update weights every 1000 ms (default)
    wtANDwtChangeUpdateIntervalCnt_ = 0; // helper var to implement fast modulo
    stdpScaleFactor_ = 1.0f;
    wtChangeDecay_ = 0.0f;

    // FIXME: use it when necessary
#ifndef __NO_CUDA__
    CUDA_CREATE_TIMER(timer);
    CUDA_RESET_TIMER(timer);
#endif
}

void SNN::advSimStep() {
    doSTPUpdateAndDecayCond();

    //KERNEL_INFO("STPUpdate!");

    spikeGeneratorUpdate();

    //KERNEL_INFO("spikeGeneratorUpdate!");

    findFiring();

    //KERNEL_INFO("Find firing!");

    updateTimingTable();

    routeSpikes();

    doCurrentUpdate();

    //KERNEL_INFO("doCurrentUpdate!");

    globalStateUpdate();

    //KERNEL_INFO("globalStateUpdate!");

    clearExtFiringTable();
}

void SNN::doSTPUpdateAndDecayCond() {
    #ifndef __NO_PTHREADS__ // POSIX
        pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
        cpu_set_t cpus;
        ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
        int threadCount = 0;
    #endif

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            assert(runtimeData[netId].allocated);
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                doSTPUpdateAndDecayCond_GPU(netId);
            else{//CPU runtime
                #ifdef __NO_PTHREADS__
                    doSTPUpdateAndDecayCond_CPU(netId);
                #else // Linux or MAC
                    pthread_attr_t attr;
                    pthread_attr_init(&attr);
                    CPU_ZERO(&cpus);
                    CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                    argsThreadRoutine[threadCount].snn_pointer = this;
                    argsThreadRoutine[threadCount].netId = netId;
                    argsThreadRoutine[threadCount].lGrpId = 0;
                    argsThreadRoutine[threadCount].startIdx = 0;
                    argsThreadRoutine[threadCount].endIdx = 0;
                    argsThreadRoutine[threadCount].GtoLOffset = 0;

                    pthread_create(&threads[threadCount], &attr, &SNN::helperDoSTPUpdateAndDecayCond_CPU, (void*)&argsThreadRoutine[threadCount]);
                    pthread_attr_destroy(&attr);
                    threadCount++;
                #endif
            }
        }
    }

    #ifndef __NO_PTHREADS__ // POSIX
        // join all the threads
        for (int i=0; i<threadCount; i++){
            pthread_join(threads[i], NULL);
        }
    #endif
}

void SNN::spikeGeneratorUpdate() {
    // If poisson rate has been updated, assign new poisson rate
    if (spikeRateUpdated) {
        #ifndef __NO_PTHREADS__ // POSIX
            pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
            cpu_set_t cpus;
            ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
            int threadCount = 0;
        #endif

        for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
            if (!groupPartitionLists[netId].empty()) {
                if (netId < CPU_RUNTIME_BASE) // GPU runtime
                    assignPoissonFiringRate_GPU(netId);
                else{ // CPU runtime
                    #ifdef __NO_PTHREADS__
                        assignPoissonFiringRate_CPU(netId);
                    #else // Linux or MAC
                        pthread_attr_t attr;
                        pthread_attr_init(&attr);
                        CPU_ZERO(&cpus);
                        CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                        pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                        argsThreadRoutine[threadCount].snn_pointer = this;
                        argsThreadRoutine[threadCount].netId = netId;
                        argsThreadRoutine[threadCount].lGrpId = 0;
                        argsThreadRoutine[threadCount].startIdx = 0;
                        argsThreadRoutine[threadCount].endIdx = 0;
                        argsThreadRoutine[threadCount].GtoLOffset = 0;

                        pthread_create(&threads[threadCount], &attr, &SNN::helperAssignPoissonFiringRate_CPU, (void*)&argsThreadRoutine[threadCount]);
                        pthread_attr_destroy(&attr);
                        threadCount++;
                    #endif
                }
            }
        }

        #ifndef __NO_PTHREADS__ // POSIX
            // join all the threads
            for (int i=0; i<threadCount; i++){
                pthread_join(threads[i], NULL);
            }
        #endif

        spikeRateUpdated = false;
    }

    // If time slice has expired, check if new spikes needs to be generated by user-defined spike generators
    generateUserDefinedSpikes();

    #ifndef __NO_PTHREADS__ // POSIX
        pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
        cpu_set_t cpus;
        ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
        int threadCount = 0;
    #endif

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                spikeGeneratorUpdate_GPU(netId);
            else{ // CPU runtime
                #ifdef __NO_PTHREADS__
                    spikeGeneratorUpdate_CPU(netId);
                #else // Linux or MAC
                    pthread_attr_t attr;
                    pthread_attr_init(&attr);
                    CPU_ZERO(&cpus);
                    CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                    argsThreadRoutine[threadCount].snn_pointer = this;
                    argsThreadRoutine[threadCount].netId = netId;
                    argsThreadRoutine[threadCount].lGrpId = 0;
                    argsThreadRoutine[threadCount].startIdx = 0;
                    argsThreadRoutine[threadCount].endIdx = 0;
                    argsThreadRoutine[threadCount].GtoLOffset = 0;

                    pthread_create(&threads[threadCount], &attr, &SNN::helperSpikeGeneratorUpdate_CPU, (void*)&argsThreadRoutine[threadCount]);
                    pthread_attr_destroy(&attr);
                    threadCount++;
                #endif
            }
        }
    }

    #ifndef __NO_PTHREADS__ // POSIX
        // join all the threads
        for (int i=0; i<threadCount; i++){
            pthread_join(threads[i], NULL);
        }
    #endif

    // tell the spike buffer to advance to the next time step
    spikeBuf->step();
}

void SNN::findFiring() {
    #ifndef __NO_PTHREADS__ // POSIX
        pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
        cpu_set_t cpus;
        ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
        int threadCount = 0;
    #endif

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                findFiring_GPU(netId);
            else {// CPU runtime
                #ifdef __NO_PTHREADS__
                    findFiring_CPU(netId);
                #else // Linux or MAC
                    pthread_attr_t attr;
                    pthread_attr_init(&attr);
                    CPU_ZERO(&cpus);
                    CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                    argsThreadRoutine[threadCount].snn_pointer = this;
                    argsThreadRoutine[threadCount].netId = netId;
                    argsThreadRoutine[threadCount].lGrpId = 0;
                    argsThreadRoutine[threadCount].startIdx = 0;
                    argsThreadRoutine[threadCount].endIdx = 0;
                    argsThreadRoutine[threadCount].GtoLOffset = 0;

                    pthread_create(&threads[threadCount], &attr, &SNN::helperFindFiring_CPU, (void*)&argsThreadRoutine[threadCount]);
                    pthread_attr_destroy(&attr);
                    threadCount++;
                #endif
            }
        }
    }

    #ifndef __NO_PTHREADS__ // POSIX
        // join all the threads
        for (int i=0; i<threadCount; i++){
            pthread_join(threads[i], NULL);
        }
    #endif
}

void SNN::doCurrentUpdate() {
    #ifndef __NO_PTHREADS__ // POSIX
        pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
        cpu_set_t cpus;
        ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
        int threadCount = 0;
    #endif

    // This loop updates and generates spikes on connections with a delay of >1ms
    //     (by calling doCurrentUpdateD2_GPU() and helperDoCurrentUpdateD2_CPU())
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                doCurrentUpdateD2_GPU(netId);
            else{ // CPU runtime
                #ifdef __NO_PTHREADS__
                    doCurrentUpdateD2_CPU(netId);
                #else // Linux or MAC
                    pthread_attr_t attr;
                    pthread_attr_init(&attr);
                    CPU_ZERO(&cpus);
                    CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                    argsThreadRoutine[threadCount].snn_pointer = this;
                    argsThreadRoutine[threadCount].netId = netId;
                    argsThreadRoutine[threadCount].lGrpId = 0;
                    argsThreadRoutine[threadCount].startIdx = 0;
                    argsThreadRoutine[threadCount].endIdx = 0;
                    argsThreadRoutine[threadCount].GtoLOffset = 0;

                    pthread_create(&threads[threadCount], &attr, &SNN::helperDoCurrentUpdateD2_CPU, (void*)&argsThreadRoutine[threadCount]);
                    pthread_attr_destroy(&attr);
                    threadCount++;
                #endif
            }
        }
    }

    #ifndef __NO_PTHREADS__ // POSIX
        // join all the threads
        for (int i=0; i<threadCount; i++){
            pthread_join(threads[i], NULL);
        }
        threadCount = 0;
    #endif

    // This loop is very similar to the previous loop above, but it
    //     updates and generates spikes on connections with a delay of <1ms
    //     (by calling doCurrentUpdateD1_GPU() and helperDoCurrentUpdateD1_CPU())
    // XXX It would be nice to reduce the code duplication across these two loops
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                doCurrentUpdateD1_GPU(netId);
            else{ // CPU runtime
                #ifdef __NO_PTHREADS__
                    doCurrentUpdateD1_CPU(netId);
                #else // Linux or MAC
                    pthread_attr_t attr;
                    pthread_attr_init(&attr);
                    CPU_ZERO(&cpus);
                    CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                    argsThreadRoutine[threadCount].snn_pointer = this;
                    argsThreadRoutine[threadCount].netId = netId;
                    argsThreadRoutine[threadCount].lGrpId = 0;
                    argsThreadRoutine[threadCount].startIdx = 0;
                    argsThreadRoutine[threadCount].endIdx = 0;
                    argsThreadRoutine[threadCount].GtoLOffset = 0;

                    pthread_create(&threads[threadCount], &attr, &SNN::helperDoCurrentUpdateD1_CPU, (void*)&argsThreadRoutine[threadCount]);
                    pthread_attr_destroy(&attr);
                    threadCount++;
                #endif
            }
        }
    }

    #ifndef __NO_PTHREADS__ // POSIX
        // join all the threads
        for (int i=0; i<threadCount; i++){
            pthread_join(threads[i], NULL);
        }
    #endif
}

void SNN::updateTimingTable() {
    #ifndef __NO_PTHREADS__ // POSIX
        pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
        cpu_set_t cpus;
        ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
        int threadCount = 0;
    #endif

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                updateTimingTable_GPU(netId);
            else{ // CPU runtime
                #ifdef __NO_PTHREADS__
                    updateTimingTable_CPU(netId);
                #else // Linux or MAC
                    pthread_attr_t attr;
                    pthread_attr_init(&attr);
                    CPU_ZERO(&cpus);
                    CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                    argsThreadRoutine[threadCount].snn_pointer = this;
                    argsThreadRoutine[threadCount].netId = netId;
                    argsThreadRoutine[threadCount].lGrpId = 0;
                    argsThreadRoutine[threadCount].startIdx = 0;
                    argsThreadRoutine[threadCount].endIdx = 0;
                    argsThreadRoutine[threadCount].GtoLOffset = 0;

                    pthread_create(&threads[threadCount], &attr, &SNN::helperUpdateTimingTable_CPU, (void*)&argsThreadRoutine[threadCount]);
                    pthread_attr_destroy(&attr);
                    threadCount++;
                #endif
            }
        }
    }
    #ifndef __NO_PTHREADS__ // POSIX
        // join all the threads
        for (int i=0; i<threadCount; i++){
            pthread_join(threads[i], NULL);
        }
    #endif
}

void SNN::globalStateUpdate() {
    #ifndef __NO_PTHREADS__ // POSIX
        pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
        cpu_set_t cpus;
        ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
        int threadCount = 0;
    #endif

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                globalStateUpdate_C_GPU(netId);
            else{ // CPU runtime
                #ifdef __NO_PTHREADS__
                    globalStateUpdate_CPU(netId);
                #else // Linux or MAC
                    pthread_attr_t attr;
                    pthread_attr_init(&attr);
                    CPU_ZERO(&cpus);
                    CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                    argsThreadRoutine[threadCount].snn_pointer = this;
                    argsThreadRoutine[threadCount].netId = netId;
                    argsThreadRoutine[threadCount].lGrpId = 0;
                    argsThreadRoutine[threadCount].startIdx = 0;
                    argsThreadRoutine[threadCount].endIdx = 0;
                    argsThreadRoutine[threadCount].GtoLOffset = 0;

                    pthread_create(&threads[threadCount], &attr, &SNN::helperGlobalStateUpdate_CPU, (void*)&argsThreadRoutine[threadCount]);
                    pthread_attr_destroy(&attr);
                    threadCount++;
                #endif
            }
        }
    }

    #ifndef __NO_PTHREADS__ // POSIX
        // join all the threads
        for (int i=0; i<threadCount; i++){
            pthread_join(threads[i], NULL);
        }
    #endif

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                globalStateUpdate_N_GPU(netId);
        }
    }

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                globalStateUpdate_G_GPU(netId);
        }
    }
}

void SNN::clearExtFiringTable() {
    #ifndef __NO_PTHREADS__ // POSIX
        pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
        cpu_set_t cpus;
        ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
        int threadCount = 0;
    #endif

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                clearExtFiringTable_GPU(netId);
            else{ // CPU runtime
                #ifdef __NO_PTHREADS__
                    clearExtFiringTable_CPU(netId);
                #else // Linux or MAC
                    pthread_attr_t attr;
                    pthread_attr_init(&attr);
                    CPU_ZERO(&cpus);
                    CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                    argsThreadRoutine[threadCount].snn_pointer = this;
                    argsThreadRoutine[threadCount].netId = netId;
                    argsThreadRoutine[threadCount].lGrpId = 0;
                    argsThreadRoutine[threadCount].startIdx = 0;
                    argsThreadRoutine[threadCount].endIdx = 0;
                    argsThreadRoutine[threadCount].GtoLOffset = 0;

                    pthread_create(&threads[threadCount], &attr, &SNN::helperClearExtFiringTable_CPU, (void*)&argsThreadRoutine[threadCount]);
                    pthread_attr_destroy(&attr);
                    threadCount++;
                #endif
            }
        }
    }

    #ifndef __NO_PTHREADS__ // POSIX
        // join all the threads
        for (int i=0; i<threadCount; i++){
            pthread_join(threads[i], NULL);
        }
    #endif
}

void SNN::updateWeights() {
    #ifndef __NO_PTHREADS__ // POSIX
        pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
        cpu_set_t cpus;
        ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
        int threadCount = 0;
    #endif

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                updateWeights_GPU(netId);
            else{ // CPU runtime
                #ifdef __NO_PTHREADS__
                    updateWeights_CPU(netId);
                #else // Linux or MAC
                    pthread_attr_t attr;
                    pthread_attr_init(&attr);
                    CPU_ZERO(&cpus);
                    CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                    argsThreadRoutine[threadCount].snn_pointer = this;
                    argsThreadRoutine[threadCount].netId = netId;
                    argsThreadRoutine[threadCount].lGrpId = 0;
                    argsThreadRoutine[threadCount].startIdx = 0;
                    argsThreadRoutine[threadCount].endIdx = 0;
                    argsThreadRoutine[threadCount].GtoLOffset = 0;

                    pthread_create(&threads[threadCount], &attr, &SNN::helperUpdateWeights_CPU, (void*)&argsThreadRoutine[threadCount]);
                    pthread_attr_destroy(&attr);
                    threadCount++;
                #endif
            }
        }
    }
    #ifndef __NO_PTHREADS__ // POSIX
        // join all the threads
        for (int i=0; i<threadCount; i++){
            pthread_join(threads[i], NULL);
        }
    #endif

}

void SNN::updateNetworkConfig(int netId) {
    assert(netId < MAX_NET_PER_SNN);

    if (netId < CPU_RUNTIME_BASE) // GPU runtime
        copyNetworkConfig(netId, cudaMemcpyHostToDevice);
    else
        copyNetworkConfig(netId); // CPU runtime
}

void SNN::shiftSpikeTables() {
    #ifndef __NO_PTHREADS__ // POSIX
        pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
        cpu_set_t cpus;
        ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
        int threadCount = 0;
    #endif

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                shiftSpikeTables_F_GPU(netId);
            else { // CPU runtime
                #ifdef __NO_PTHREADS__
                    shiftSpikeTables_CPU(netId);
                #else // Linux or MAC
                    pthread_attr_t attr;
                    pthread_attr_init(&attr);
                    CPU_ZERO(&cpus);
                    CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                    argsThreadRoutine[threadCount].snn_pointer = this;
                    argsThreadRoutine[threadCount].netId = netId;
                    argsThreadRoutine[threadCount].lGrpId = 0;
                    argsThreadRoutine[threadCount].startIdx = 0;
                    argsThreadRoutine[threadCount].endIdx = 0;
                    argsThreadRoutine[threadCount].GtoLOffset = 0;

                    pthread_create(&threads[threadCount], &attr, &SNN::helperShiftSpikeTables_CPU, (void*)&argsThreadRoutine[threadCount]);
                    pthread_attr_destroy(&attr);
                    threadCount++;
                #endif
            }
        }
    }

    #ifndef __NO_PTHREADS__ // POSIX
        // join all the threads
        for (int i=0; i<threadCount; i++){
            pthread_join(threads[i], NULL);
        }
    #endif

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                shiftSpikeTables_T_GPU(netId);
        }
    }
}

void SNN::allocateSNN(int netId) {
    assert(netId > ANY && netId < MAX_NET_PER_SNN);

    if (netId < CPU_RUNTIME_BASE)
        allocateSNN_GPU(netId);
    else
        allocateSNN_CPU(netId);
}

void SNN::allocateManagerRuntimeData() {
    // reset variable related to spike count
    managerRuntimeData.spikeCountSec = 0;
    managerRuntimeData.spikeCountD1Sec = 0;
    managerRuntimeData.spikeCountD2Sec = 0;
    managerRuntimeData.spikeCountLastSecLeftD2 = 0;
    managerRuntimeData.spikeCount = 0;
    managerRuntimeData.spikeCountD1 = 0;
    managerRuntimeData.spikeCountD2 = 0;
    managerRuntimeData.nPoissonSpikes = 0;
    managerRuntimeData.spikeCountExtRxD1 = 0;
    managerRuntimeData.spikeCountExtRxD2 = 0;

    managerRuntimeData.voltage    = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.nextVoltage = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.recovery   = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.Izh_a      = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.Izh_b      = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.Izh_c      = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.Izh_d      = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.Izh_C      = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.Izh_k      = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.Izh_vr     = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.Izh_vt     = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.Izh_vpeak  = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.lif_tau_m      = new int[managerRTDSize.maxNumNReg];
    managerRuntimeData.lif_tau_ref      = new int[managerRTDSize.maxNumNReg];
    managerRuntimeData.lif_tau_ref_c      = new int[managerRTDSize.maxNumNReg];
    managerRuntimeData.lif_vTh      = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.lif_vReset      = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.lif_gain      = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.lif_bias      = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.current    = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.extCurrent = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.totalCurrent = new float[managerRTDSize.maxNumNReg];
    managerRuntimeData.curSpike   = new bool[managerRTDSize.maxNumNReg];
    memset(managerRuntimeData.voltage, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.nextVoltage, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.recovery, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.Izh_a, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.Izh_b, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.Izh_c, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.Izh_d, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.Izh_C, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.Izh_k, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.Izh_vr, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.Izh_vt, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.Izh_vpeak, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.lif_tau_m, 0, sizeof(int) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.lif_tau_ref, 0, sizeof(int) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.lif_tau_ref_c, 0, sizeof(int) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.lif_vTh, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.lif_vReset, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.lif_gain, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.lif_bias, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.current, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.extCurrent, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.totalCurrent, 0, sizeof(float) * managerRTDSize.maxNumNReg);
    memset(managerRuntimeData.curSpike, 0, sizeof(bool) * managerRTDSize.maxNumNReg);

    managerRuntimeData.nVBuffer = new float[MAX_NEURON_MON_GRP_SZIE * 1000 * managerRTDSize.maxNumGroups]; // 1 second v buffer
    managerRuntimeData.nUBuffer = new float[MAX_NEURON_MON_GRP_SZIE * 1000 * managerRTDSize.maxNumGroups];
    managerRuntimeData.nIBuffer = new float[MAX_NEURON_MON_GRP_SZIE * 1000 * managerRTDSize.maxNumGroups];
    memset(managerRuntimeData.nVBuffer, 0, sizeof(float) * MAX_NEURON_MON_GRP_SZIE * 1000 * managerRTDSize.maxNumGroups);
    memset(managerRuntimeData.nUBuffer, 0, sizeof(float) * MAX_NEURON_MON_GRP_SZIE * 1000 * managerRTDSize.maxNumGroups);
    memset(managerRuntimeData.nIBuffer, 0, sizeof(float) * MAX_NEURON_MON_GRP_SZIE * 1000 * managerRTDSize.maxNumGroups);

    managerRuntimeData.gAMPA  = new float[managerRTDSize.glbNumNReg]; // sufficient to hold all regular neurons in the global network
    managerRuntimeData.gNMDA_r = new float[managerRTDSize.glbNumNReg]; // sufficient to hold all regular neurons in the global network
    managerRuntimeData.gNMDA_d = new float[managerRTDSize.glbNumNReg]; // sufficient to hold all regular neurons in the global network
    managerRuntimeData.gNMDA = new float[managerRTDSize.glbNumNReg]; // sufficient to hold all regular neurons in the global network
    memset(managerRuntimeData.gAMPA, 0, sizeof(float) * managerRTDSize.glbNumNReg);
    memset(managerRuntimeData.gNMDA_r, 0, sizeof(float) * managerRTDSize.glbNumNReg);
    memset(managerRuntimeData.gNMDA_d, 0, sizeof(float) * managerRTDSize.glbNumNReg);
    memset(managerRuntimeData.gNMDA, 0, sizeof(float) * managerRTDSize.glbNumNReg);

    managerRuntimeData.gGABAa = new float[managerRTDSize.glbNumNReg]; // sufficient to hold all regular neurons in the global network
    managerRuntimeData.gGABAb_r = new float[managerRTDSize.glbNumNReg]; // sufficient to hold all regular neurons in the global network
    managerRuntimeData.gGABAb_d = new float[managerRTDSize.glbNumNReg]; // sufficient to hold all regular neurons in the global network
    managerRuntimeData.gGABAb = new float[managerRTDSize.glbNumNReg]; // sufficient to hold all regular neurons in the global network
    memset(managerRuntimeData.gGABAa, 0, sizeof(float) * managerRTDSize.glbNumNReg);
    memset(managerRuntimeData.gGABAb_r, 0, sizeof(float) * managerRTDSize.glbNumNReg);
    memset(managerRuntimeData.gGABAb_d, 0, sizeof(float) * managerRTDSize.glbNumNReg);
    memset(managerRuntimeData.gGABAb, 0, sizeof(float) * managerRTDSize.glbNumNReg);

    // allocate neuromodulators and their assistive buffers
    managerRuntimeData.grpDA  = new float[managerRTDSize.maxNumGroups];
    managerRuntimeData.grp5HT = new float[managerRTDSize.maxNumGroups];
    managerRuntimeData.grpACh = new float[managerRTDSize.maxNumGroups];
    managerRuntimeData.grpNE  = new float[managerRTDSize.maxNumGroups];
    memset(managerRuntimeData.grpDA, 0, sizeof(float) * managerRTDSize.maxNumGroups);
    memset(managerRuntimeData.grp5HT, 0, sizeof(float) * managerRTDSize.maxNumGroups);
    memset(managerRuntimeData.grpACh, 0, sizeof(float) * managerRTDSize.maxNumGroups);
    memset(managerRuntimeData.grpNE, 0, sizeof(float) * managerRTDSize.maxNumGroups);


    managerRuntimeData.grpDABuffer  = new float[managerRTDSize.maxNumGroups * 1000]; // 1 second DA buffer
    managerRuntimeData.grp5HTBuffer = new float[managerRTDSize.maxNumGroups * 1000];
    managerRuntimeData.grpAChBuffer = new float[managerRTDSize.maxNumGroups * 1000];
    managerRuntimeData.grpNEBuffer  = new float[managerRTDSize.maxNumGroups * 1000];
    memset(managerRuntimeData.grpDABuffer, 0, managerRTDSize.maxNumGroups * sizeof(float) * 1000);
    memset(managerRuntimeData.grp5HTBuffer, 0, managerRTDSize.maxNumGroups * sizeof(float) * 1000);
    memset(managerRuntimeData.grpAChBuffer, 0, managerRTDSize.maxNumGroups * sizeof(float) * 1000);
    memset(managerRuntimeData.grpNEBuffer, 0, managerRTDSize.maxNumGroups * sizeof(float) * 1000);

    managerRuntimeData.lastSpikeTime = new int[managerRTDSize.maxNumNAssigned];
    memset(managerRuntimeData.lastSpikeTime, 0, sizeof(int) * managerRTDSize.maxNumNAssigned);

    managerRuntimeData.nSpikeCnt = new int[managerRTDSize.glbNumN];
    memset(managerRuntimeData.nSpikeCnt, 0, sizeof(int) * managerRTDSize.glbNumN); // sufficient to hold all neurons in the global network

    managerRuntimeData.avgFiring  = new float[managerRTDSize.maxNumN];
    managerRuntimeData.baseFiring = new float[managerRTDSize.maxNumN];
    memset(managerRuntimeData.avgFiring, 0, sizeof(float) * managerRTDSize.maxNumN);
    memset(managerRuntimeData.baseFiring, 0, sizeof(float) * managerRTDSize.maxNumN);

    // STP can be applied to spike generators, too -> numN
    // \TODO: The size of these data structures could be reduced to the max synaptic delay of all
    // connections with STP. That number might not be the same as maxDelay_.
    managerRuntimeData.stpu = new float[managerRTDSize.maxNumN * (glbNetworkConfig.maxDelay + 1)];
    managerRuntimeData.stpx = new float[managerRTDSize.maxNumN * (glbNetworkConfig.maxDelay + 1)];
    memset(managerRuntimeData.stpu, 0, sizeof(float) * managerRTDSize.maxNumN * (glbNetworkConfig.maxDelay + 1));
    memset(managerRuntimeData.stpx, 0, sizeof(float) * managerRTDSize.maxNumN * (glbNetworkConfig.maxDelay + 1));

    managerRuntimeData.Npre           = new unsigned short[managerRTDSize.maxNumNAssigned];
    managerRuntimeData.Npre_plastic   = new unsigned short[managerRTDSize.maxNumNAssigned];
    managerRuntimeData.Npost          = new unsigned short[managerRTDSize.maxNumNAssigned];
    managerRuntimeData.cumulativePost = new unsigned int[managerRTDSize.maxNumNAssigned];
    managerRuntimeData.cumulativePre  = new unsigned int[managerRTDSize.maxNumNAssigned];
    memset(managerRuntimeData.Npre, 0, sizeof(short) * managerRTDSize.maxNumNAssigned);
    memset(managerRuntimeData.Npre_plastic, 0, sizeof(short) * managerRTDSize.maxNumNAssigned);
    memset(managerRuntimeData.Npost, 0, sizeof(short) * managerRTDSize.maxNumNAssigned);
    memset(managerRuntimeData.cumulativePost, 0, sizeof(int) * managerRTDSize.maxNumNAssigned);
    memset(managerRuntimeData.cumulativePre, 0, sizeof(int) * managerRTDSize.maxNumNAssigned);

    managerRuntimeData.postSynapticIds = new SynInfo[managerRTDSize.maxNumPostSynNet];
    managerRuntimeData.postDelayInfo   = new DelayInfo[managerRTDSize.maxNumNAssigned * (glbNetworkConfig.maxDelay + 1)];   
    memset(managerRuntimeData.postSynapticIds, 0, sizeof(SynInfo) * managerRTDSize.maxNumPostSynNet);
    memset(managerRuntimeData.postDelayInfo, 0, sizeof(DelayInfo) * managerRTDSize.maxNumNAssigned * (glbNetworkConfig.maxDelay + 1));

    managerRuntimeData.preSynapticIds   = new SynInfo[managerRTDSize.maxNumPreSynNet];
    memset(managerRuntimeData.preSynapticIds, 0, sizeof(SynInfo) * managerRTDSize.maxNumPreSynNet);

    managerRuntimeData.wt           = new float[managerRTDSize.maxNumPreSynNet];
    managerRuntimeData.wtChange     = new float[managerRTDSize.maxNumPreSynNet];
    managerRuntimeData.maxSynWt     = new float[managerRTDSize.maxNumPreSynNet];
    managerRuntimeData.synSpikeTime = new int[managerRTDSize.maxNumPreSynNet];
    memset(managerRuntimeData.wt, 0, sizeof(float) * managerRTDSize.maxNumPreSynNet);
    memset(managerRuntimeData.wtChange, 0, sizeof(float) * managerRTDSize.maxNumPreSynNet);
    memset(managerRuntimeData.maxSynWt, 0, sizeof(float) * managerRTDSize.maxNumPreSynNet);
    memset(managerRuntimeData.synSpikeTime, 0, sizeof(int) * managerRTDSize.maxNumPreSynNet);

    mulSynFast = new float[managerRTDSize.maxNumConnections];
    mulSynSlow = new float[managerRTDSize.maxNumConnections];
    memset(mulSynFast, 0, sizeof(float) * managerRTDSize.maxNumConnections);
    memset(mulSynSlow, 0, sizeof(float) * managerRTDSize.maxNumConnections);

    managerRuntimeData.connIdsPreIdx    = new short int[managerRTDSize.maxNumPreSynNet];
    memset(managerRuntimeData.connIdsPreIdx, 0, sizeof(short int) * managerRTDSize.maxNumPreSynNet);

    managerRuntimeData.grpIds = new short int[managerRTDSize.maxNumNAssigned];
    memset(managerRuntimeData.grpIds, 0, sizeof(short int) * managerRTDSize.maxNumNAssigned);

    managerRuntimeData.spikeGenBits = new unsigned int[managerRTDSize.maxNumNSpikeGen / 32 + 1];

    managerRuntimeData.randNum  = new float[managerRTDSize.maxNumNPois];  
    managerRuntimeData.poissonFireRate  = new float[managerRTDSize.maxNumNPois]; 


    // Confirm allocation of SNN runtime data in main memory
    managerRuntimeData.allocated = true;
    managerRuntimeData.memType = CPU_MEM;
}

int SNN::assignGroup(int gGrpId, int availableNeuronId) {
    int newAvailableNeuronId;
    assert(groupConfigMDMap[gGrpId].gStartN == -1); // The group has not yet been assigned
    groupConfigMDMap[gGrpId].gStartN = availableNeuronId;
    groupConfigMDMap[gGrpId].gEndN = availableNeuronId + groupConfigMap[gGrpId].numN - 1;

    KERNEL_DEBUG("Allocation for %d(%s), St=%d, End=%d",
                gGrpId, groupConfigMap[gGrpId].grpName.c_str(), groupConfigMDMap[gGrpId].gStartN, groupConfigMDMap[gGrpId].gEndN);

    newAvailableNeuronId = availableNeuronId + groupConfigMap[gGrpId].numN;
    //assert(newAvailableNeuronId <= numN);

    return newAvailableNeuronId;
}

int SNN::assignGroup(std::list<GroupConfigMD>::iterator grpIt, int localGroupId, int availableNeuronId) {
    int newAvailableNeuronId;
    assert(grpIt->lGrpId == -1); // The group has not yet been assigned
    grpIt->lGrpId = localGroupId;
    grpIt->lStartN = availableNeuronId;
    grpIt->lEndN = availableNeuronId + groupConfigMap[grpIt->gGrpId].numN - 1;

    grpIt->LtoGOffset = grpIt->gStartN - grpIt->lStartN;
    grpIt->GtoLOffset = grpIt->lStartN - grpIt->gStartN;

    KERNEL_DEBUG("Allocation for group (%s) [id:%d, local id:%d], St=%d, End=%d", groupConfigMap[grpIt->gGrpId].grpName.c_str(),
        grpIt->gGrpId, grpIt->lGrpId, grpIt->lStartN, grpIt->lEndN);

    newAvailableNeuronId = availableNeuronId + groupConfigMap[grpIt->gGrpId].numN;

    return newAvailableNeuronId;
}

void SNN::generateGroupRuntime(int netId, int lGrpId) {
    resetNeuromodulator(netId, lGrpId);

    for(int lNId = groupConfigs[netId][lGrpId].lStartN; lNId <= groupConfigs[netId][lGrpId].lEndN; lNId++)
        resetNeuron(netId, lGrpId, lNId);
}

void SNN::generateRuntimeGroupConfigs() {
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[netId].begin(); grpIt != groupPartitionLists[netId].end(); grpIt++) {
            // publish the group configs in an array for quick access and accessible on GPUs (cuda doesn't support std::list)
            int gGrpId = grpIt->gGrpId;
            int lGrpId = grpIt->lGrpId;

            // Data published by groupConfigMDMap[] are generated in compileSNN() and are invariant in partitionSNN()
            // Data published by grpIt are generated in partitionSNN() and maybe have duplicated copys
            groupConfigs[netId][lGrpId].netId = grpIt->netId;
            groupConfigs[netId][lGrpId].gGrpId = grpIt->gGrpId;
            groupConfigs[netId][lGrpId].gStartN = grpIt->gStartN;
            groupConfigs[netId][lGrpId].gEndN = grpIt->gEndN;
            groupConfigs[netId][lGrpId].lGrpId = grpIt->lGrpId;
            groupConfigs[netId][lGrpId].lStartN = grpIt->lStartN;
            groupConfigs[netId][lGrpId].lEndN = grpIt->lEndN;
            groupConfigs[netId][lGrpId].LtoGOffset = grpIt->LtoGOffset;
            groupConfigs[netId][lGrpId].GtoLOffset = grpIt->GtoLOffset;
            groupConfigs[netId][lGrpId].Type = groupConfigMap[gGrpId].type;
            groupConfigs[netId][lGrpId].numN = groupConfigMap[gGrpId].numN;
            groupConfigs[netId][lGrpId].numPostSynapses = grpIt->numPostSynapses;
            groupConfigs[netId][lGrpId].numPreSynapses = grpIt->numPreSynapses;
            groupConfigs[netId][lGrpId].isSpikeGenerator = groupConfigMap[gGrpId].isSpikeGenerator;
            groupConfigs[netId][lGrpId].isSpikeGenFunc = groupConfigMap[gGrpId].spikeGenFunc != NULL ? true : false;
            groupConfigs[netId][lGrpId].WithSTP = groupConfigMap[gGrpId].stpConfig.WithSTP;
            groupConfigs[netId][lGrpId].WithSTDP = groupConfigMap[gGrpId].WithSTDP;
            groupConfigs[netId][lGrpId].WithDA_MOD = groupConfigMap[gGrpId].WithDA_MOD;

            // groupConfigs[netId][lGrpId].WithESTDP =  groupConfigMap[gGrpId].stdpConfig.WithESTDP;
            // groupConfigs[netId][lGrpId].WithISTDP = groupConfigMap[gGrpId].stdpConfig.WithISTDP;
            // groupConfigs[netId][lGrpId].WithESTDPtype = groupConfigMap[gGrpId].stdpConfig.WithESTDPtype;
            // groupConfigs[netId][lGrpId].WithISTDPtype =  groupConfigMap[gGrpId].stdpConfig.WithISTDPtype;
            // groupConfigs[netId][lGrpId].WithESTDPcurve =  groupConfigMap[gGrpId].stdpConfig.WithESTDPcurve;
            // groupConfigs[netId][lGrpId].WithISTDPcurve =  groupConfigMap[gGrpId].stdpConfig.WithISTDPcurve;
            groupConfigs[netId][lGrpId].WithHomeostasis = groupConfigMap[gGrpId].homeoConfig.WithHomeostasis;
#ifdef LN_I_CALC_TYPES
            groupConfigs[netId][lGrpId].with_NMDA_rise = groupConfigMap[gGrpId].with_NMDA_rise;
            groupConfigs[netId][lGrpId].with_GABAb_rise = groupConfigMap[gGrpId].with_GABAb_rise;
#endif
            groupConfigs[netId][lGrpId].FixedInputWts = grpIt->fixedInputWts;
            groupConfigs[netId][lGrpId].hasExternalConnect = grpIt->hasExternalConnect;
            groupConfigs[netId][lGrpId].Noffset = grpIt->Noffset; // Note: Noffset is not valid at this time
            groupConfigs[netId][lGrpId].MaxDelay = grpIt->maxOutgoingDelay;
            groupConfigs[netId][lGrpId].STP_A = groupConfigMap[gGrpId].stpConfig.STP_A;
            groupConfigs[netId][lGrpId].STP_U = groupConfigMap[gGrpId].stpConfig.STP_U;
            groupConfigs[netId][lGrpId].STP_tau_u_inv = groupConfigMap[gGrpId].stpConfig.STP_tau_u_inv;
            groupConfigs[netId][lGrpId].STP_tau_x_inv = groupConfigMap[gGrpId].stpConfig.STP_tau_x_inv;
            // groupConfigs[netId][lGrpId].TAU_PLUS_INV_EXC = groupConfigMap[gGrpId].stdpConfig.TAU_PLUS_INV_EXC;
            // groupConfigs[netId][lGrpId].TAU_MINUS_INV_EXC = groupConfigMap[gGrpId].stdpConfig.TAU_MINUS_INV_EXC;
            // groupConfigs[netId][lGrpId].ALPHA_PLUS_EXC = groupConfigMap[gGrpId].stdpConfig.ALPHA_PLUS_EXC;
            // groupConfigs[netId][lGrpId].ALPHA_MINUS_EXC = groupConfigMap[gGrpId].stdpConfig.ALPHA_MINUS_EXC;
            // groupConfigs[netId][lGrpId].GAMMA = groupConfigMap[gGrpId].stdpConfig.GAMMA;
            // groupConfigs[netId][lGrpId].KAPPA = groupConfigMap[gGrpId].stdpConfig.KAPPA;
            // groupConfigs[netId][lGrpId].OMEGA = groupConfigMap[gGrpId].stdpConfig.OMEGA;
            // groupConfigs[netId][lGrpId].TAU_PLUS_INV_INB = groupConfigMap[gGrpId].stdpConfig.TAU_PLUS_INV_INB;
            // groupConfigs[netId][lGrpId].TAU_MINUS_INV_INB = groupConfigMap[gGrpId].stdpConfig.TAU_MINUS_INV_INB;
            // groupConfigs[netId][lGrpId].ALPHA_PLUS_INB = groupConfigMap[gGrpId].stdpConfig.ALPHA_PLUS_INB;
            // groupConfigs[netId][lGrpId].ALPHA_MINUS_INB = groupConfigMap[gGrpId].stdpConfig.ALPHA_MINUS_INB;
            // groupConfigs[netId][lGrpId].BETA_LTP = groupConfigMap[gGrpId].stdpConfig.BETA_LTP;
            // groupConfigs[netId][lGrpId].BETA_LTD = groupConfigMap[gGrpId].stdpConfig.BETA_LTD;
            // groupConfigs[netId][lGrpId].LAMBDA = groupConfigMap[gGrpId].stdpConfig.LAMBDA;
            // groupConfigs[netId][lGrpId].DELTA = groupConfigMap[gGrpId].stdpConfig.DELTA;

            groupConfigs[netId][lGrpId].numCompNeighbors = 0;
            groupConfigs[netId][lGrpId].withCompartments = groupConfigMap[gGrpId].withCompartments;
            groupConfigs[netId][lGrpId].compCouplingUp = groupConfigMap[gGrpId].compCouplingUp;
            groupConfigs[netId][lGrpId].compCouplingDown = groupConfigMap[gGrpId].compCouplingDown;
            memset(&groupConfigs[netId][lGrpId].compNeighbors, 0, sizeof(groupConfigs[netId][lGrpId].compNeighbors[0]) * MAX_NUM_COMP_CONN);
            memset(&groupConfigs[netId][lGrpId].compCoupling, 0, sizeof(groupConfigs[netId][lGrpId].compCoupling[0]) * MAX_NUM_COMP_CONN);

            groupConfigs[netId][lGrpId].avgTimeScale = groupConfigMap[gGrpId].homeoConfig.avgTimeScale;
            groupConfigs[netId][lGrpId].avgTimeScale_decay = groupConfigMap[gGrpId].homeoConfig.avgTimeScaleDecay;
            groupConfigs[netId][lGrpId].avgTimeScaleInv = groupConfigMap[gGrpId].homeoConfig.avgTimeScaleInv;
            groupConfigs[netId][lGrpId].homeostasisScale = groupConfigMap[gGrpId].homeoConfig.homeostasisScale;

            // parameters of neuromodulator
            groupConfigs[netId][lGrpId].baseDP = groupConfigMap[gGrpId].neuromodulatorConfig.baseDP;
            groupConfigs[netId][lGrpId].base5HT = groupConfigMap[gGrpId].neuromodulatorConfig.base5HT;
            groupConfigs[netId][lGrpId].baseACh = groupConfigMap[gGrpId].neuromodulatorConfig.baseACh;
            groupConfigs[netId][lGrpId].baseNE = groupConfigMap[gGrpId].neuromodulatorConfig.baseNE;
            groupConfigs[netId][lGrpId].decayDP = groupConfigMap[gGrpId].neuromodulatorConfig.decayDP;
            groupConfigs[netId][lGrpId].decay5HT = groupConfigMap[gGrpId].neuromodulatorConfig.decay5HT;
            groupConfigs[netId][lGrpId].decayACh = groupConfigMap[gGrpId].neuromodulatorConfig.decayACh;
            groupConfigs[netId][lGrpId].decayNE = groupConfigMap[gGrpId].neuromodulatorConfig.decayNE;
            groupConfigs[netId][lGrpId].releaseDP = groupConfigMap[gGrpId].neuromodulatorConfig.releaseDP;
            groupConfigs[netId][lGrpId].release5HT = groupConfigMap[gGrpId].neuromodulatorConfig.release5HT;
            groupConfigs[netId][lGrpId].releaseACh = groupConfigMap[gGrpId].neuromodulatorConfig.releaseACh;
            groupConfigs[netId][lGrpId].releaseNE = groupConfigMap[gGrpId].neuromodulatorConfig.releaseNE;
            groupConfigs[netId][lGrpId].activeDP = groupConfigMap[gGrpId].neuromodulatorConfig.activeDP;
            groupConfigs[netId][lGrpId].active5HT = groupConfigMap[gGrpId].neuromodulatorConfig.active5HT;
            groupConfigs[netId][lGrpId].activeACh = groupConfigMap[gGrpId].neuromodulatorConfig.activeACh;
            groupConfigs[netId][lGrpId].activeNE = groupConfigMap[gGrpId].neuromodulatorConfig.activeNE;

#ifdef LN_I_CALC_TYPES
            // parameters of IcalcTypes
            if (groupConfigMap[gGrpId].icalcType == UNKNOWN_ICALC)
            {
                KERNEL_ERROR("IcalcType is unknwon in group [%d] ", gGrpId);
                exitSimulation(KERNEL_ERROR_UNKNOWN_ICALC);
            }
            else {
                groupConfigs[netId][lGrpId].icalcType = groupConfigMap[gGrpId].icalcType;
            }
            // conductances
            groupConfigs[netId][lGrpId].dAMPA = groupConfigMap[gGrpId].conductanceConfig.dAMPA;
            groupConfigs[netId][lGrpId].rNMDA = groupConfigMap[gGrpId].conductanceConfig.rNMDA;
            groupConfigs[netId][lGrpId].dNMDA = groupConfigMap[gGrpId].conductanceConfig.dNMDA;
            groupConfigs[netId][lGrpId].sNMDA = groupConfigMap[gGrpId].conductanceConfig.sNMDA;
            groupConfigs[netId][lGrpId].dGABAa = groupConfigMap[gGrpId].conductanceConfig.dGABAa;
            groupConfigs[netId][lGrpId].rGABAb = groupConfigMap[gGrpId].conductanceConfig.rGABAb;
            groupConfigs[netId][lGrpId].dGABAb = groupConfigMap[gGrpId].conductanceConfig.dGABAb;
            groupConfigs[netId][lGrpId].sGABAb = groupConfigMap[gGrpId].conductanceConfig.sGABAb;
            // NM4
            for (int i = 0; i < NM_NE + 3; i++)  // \todo LN doc intern  <= due NM_UNKNOWN+2 , last elements are normalization and base
                groupConfigs[netId][lGrpId].nm4w[i] = groupConfigMap[gGrpId].nm4wConfig.w[i];
            // NM4STP
            groupConfigs[netId][lGrpId].WithNM4STP = groupConfigMap[gGrpId].nm4StpConfig.WithNM4STP;
            for (int i = 0; i < NM_NE + 3; i++) {
                groupConfigs[netId][lGrpId].wstpu[i] = groupConfigMap[gGrpId].nm4StpConfig.w_STP_U[i];
                groupConfigs[netId][lGrpId].wstptauu[i] = groupConfigMap[gGrpId].nm4StpConfig.w_STP_tau_u[i];
                groupConfigs[netId][lGrpId].wstptaux[i] = groupConfigMap[gGrpId].nm4StpConfig.w_STP_tau_x[i];
            }

            // NM4STP 128
            //assert(groupConfigs[netId][lGrpId].nm4stp == nullptr);  // must be called only once, memset(0) see SNN::SNNinit()
            //groupConfigs[netId][lGrpId].nm4stp = new NM4STPConfig(groupConfigMap[gGrpId].nm4StpConfig); 
            //printf("DEBUG: groupConfigs[%d][%d].nm4stp = new NM4STPConfig(groupConfigMap[%d].nm4StpConfig); %s %d \n", netId, lGrpId, gGrpId, __FILE__, __LINE__);
            // \todo memory management, -> delete groupConfigs[netId][lGrpId].nm4stp;           
#endif

#ifdef LN_AXON_PLAST
            groupConfigs[netId][lGrpId].WithAxonPlast = groupConfigMap[gGrpId].WithAxonPlast;
            groupConfigs[netId][lGrpId].AxonPlast_TAU = groupConfigMap[gGrpId].AxonPlast_TAU;
#endif

            // sync groupConfigs[][] and groupConfigMDMap[]
            if (netId == grpIt->netId) {
                groupConfigMDMap[gGrpId].netId = grpIt->netId;
                groupConfigMDMap[gGrpId].gGrpId = grpIt->gGrpId;
                groupConfigMDMap[gGrpId].gStartN = grpIt->gStartN;
                groupConfigMDMap[gGrpId].gEndN = grpIt->gEndN;
                groupConfigMDMap[gGrpId].lGrpId = grpIt->lGrpId;
                groupConfigMDMap[gGrpId].lStartN = grpIt->lStartN;
                groupConfigMDMap[gGrpId].lEndN = grpIt->lEndN;
                groupConfigMDMap[gGrpId].numPostSynapses = grpIt->numPostSynapses;
                groupConfigMDMap[gGrpId].numPreSynapses = grpIt->numPreSynapses;
                groupConfigMDMap[gGrpId].LtoGOffset = grpIt->LtoGOffset;
                groupConfigMDMap[gGrpId].GtoLOffset = grpIt->GtoLOffset;
                groupConfigMDMap[gGrpId].fixedInputWts = grpIt->fixedInputWts;
                groupConfigMDMap[gGrpId].hasExternalConnect = grpIt->hasExternalConnect;
                groupConfigMDMap[gGrpId].Noffset = grpIt->Noffset; // Note: Noffset is not valid at this time
                groupConfigMDMap[gGrpId].maxOutgoingDelay = grpIt->maxOutgoingDelay;
            }
            groupConfigs[netId][lGrpId].withParamModel_9 = groupConfigMap[gGrpId].withParamModel_9;
            groupConfigs[netId][lGrpId].isLIF = groupConfigMap[gGrpId].isLIF;

        }

        // FIXME: How does networkConfigs[netId].numGroups be availabe at this time?! Bug?!
        //int numNSpikeGen = 0;
        //for(int lGrpId = 0; lGrpId < networkConfigs[netId].numGroups; lGrpId++) {
        //  if (netId == groupConfigs[netId][lGrpId].netId && groupConfigs[netId][lGrpId].isSpikeGenerator && groupConfigs[netId][lGrpId].isSpikeGenFunc) {
        //  // we only need numNSpikeGen for spike generator callbacks that need to transfer their spikes to the GPU
        //      groupConfigs[netId][lGrpId].Noffset = numNSpikeGen; // FIXME, Noffset is updated after publish group configs
        //      numNSpikeGen += groupConfigs[netId][lGrpId].numN;
        //  }
        //}
        //assert(numNSpikeGen <= networkConfigs[netId].numNPois);
    }
}

void SNN::generateRuntimeConnectConfigs() {
    // sync localConnectLists and connectConfigMap
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        for (std::list<ConnectConfig>::iterator connIt = localConnectLists[netId].begin(); connIt != localConnectLists[netId].end(); connIt++) {
            int lConnId = connIt->connId;
            connectConfigMap[lConnId] = *connIt;

            connectConfigs[netId][lConnId].grpSrc =  connIt->grpSrc;
            connectConfigs[netId][lConnId].grpDest =  connIt->grpDest;

            connectConfigs[netId][lConnId].WithSTDP =  connectConfigMap[lConnId].stdpConfig.WithSTDP;
            connectConfigs[netId][lConnId].WithESTDP =  connectConfigMap[lConnId].stdpConfig.WithESTDP;
            connectConfigs[netId][lConnId].WithISTDP = connectConfigMap[lConnId].stdpConfig.WithISTDP;
            connectConfigs[netId][lConnId].WithESTDPtype = connectConfigMap[lConnId].stdpConfig.WithESTDPtype;
            connectConfigs[netId][lConnId].WithISTDPtype =  connectConfigMap[lConnId].stdpConfig.WithISTDPtype;
            connectConfigs[netId][lConnId].WithESTDPcurve =  connectConfigMap[lConnId].stdpConfig.WithESTDPcurve;
            connectConfigs[netId][lConnId].WithISTDPcurve =  connectConfigMap[lConnId].stdpConfig.WithISTDPcurve;

            connectConfigs[netId][lConnId].TAU_PLUS_INV_EXC = connectConfigMap[lConnId].stdpConfig.TAU_PLUS_INV_EXC;
            connectConfigs[netId][lConnId].TAU_MINUS_INV_EXC = connectConfigMap[lConnId].stdpConfig.TAU_MINUS_INV_EXC;
            connectConfigs[netId][lConnId].ALPHA_PLUS_EXC = connectConfigMap[lConnId].stdpConfig.ALPHA_PLUS_EXC;
            connectConfigs[netId][lConnId].ALPHA_MINUS_EXC = connectConfigMap[lConnId].stdpConfig.ALPHA_MINUS_EXC;
            connectConfigs[netId][lConnId].GAMMA = connectConfigMap[lConnId].stdpConfig.GAMMA;
            connectConfigs[netId][lConnId].KAPPA = connectConfigMap[lConnId].stdpConfig.KAPPA;
            connectConfigs[netId][lConnId].OMEGA = connectConfigMap[lConnId].stdpConfig.OMEGA;
            connectConfigs[netId][lConnId].TAU_PLUS_INV_INB = connectConfigMap[lConnId].stdpConfig.TAU_PLUS_INV_INB;
            connectConfigs[netId][lConnId].TAU_MINUS_INV_INB = connectConfigMap[lConnId].stdpConfig.TAU_MINUS_INV_INB;
            connectConfigs[netId][lConnId].ALPHA_PLUS_INB = connectConfigMap[lConnId].stdpConfig.ALPHA_PLUS_INB;
            connectConfigs[netId][lConnId].ALPHA_MINUS_INB = connectConfigMap[lConnId].stdpConfig.ALPHA_MINUS_INB;
            connectConfigs[netId][lConnId].BETA_LTP = connectConfigMap[lConnId].stdpConfig.BETA_LTP;
            connectConfigs[netId][lConnId].BETA_LTD = connectConfigMap[lConnId].stdpConfig.BETA_LTD;
            connectConfigs[netId][lConnId].LAMBDA = connectConfigMap[lConnId].stdpConfig.LAMBDA;
            connectConfigs[netId][lConnId].DELTA = connectConfigMap[lConnId].stdpConfig.DELTA;
#ifdef LN_I_CALC_TYPES
            connectConfigs[netId][lConnId].NM_PKA = connectConfigMap[lConnId].stdpConfig.NM_PKA;
            connectConfigs[netId][lConnId].NM_PLC = connectConfigMap[lConnId].stdpConfig.NM_PLC;
            connectConfigs[netId][lConnId].W_PKA = connectConfigMap[lConnId].stdpConfig.W_PKA;
            connectConfigs[netId][lConnId].W_PLC = connectConfigMap[lConnId].stdpConfig.W_PLC;
            connectConfigs[netId][lConnId].icalcType = connectConfigMap[lConnId].icalcType;
#endif
        }

        for (std::list<ConnectConfig>::iterator connIt = externalConnectLists[netId].begin(); connIt != externalConnectLists[netId].end(); connIt++) {
            int lConnId = connIt->connId;
            connectConfigMap[lConnId] = *connIt;

            connectConfigs[netId][lConnId].grpSrc =  connIt->grpSrc;
            connectConfigs[netId][lConnId].grpDest =  connIt->grpDest;

            connectConfigs[netId][lConnId].WithSTDP =  connectConfigMap[lConnId].stdpConfig.WithSTDP;
            connectConfigs[netId][lConnId].WithESTDP =  connectConfigMap[lConnId].stdpConfig.WithESTDP;
            connectConfigs[netId][lConnId].WithISTDP = connectConfigMap[lConnId].stdpConfig.WithISTDP;
            connectConfigs[netId][lConnId].WithESTDPtype = connectConfigMap[lConnId].stdpConfig.WithESTDPtype;
            connectConfigs[netId][lConnId].WithISTDPtype =  connectConfigMap[lConnId].stdpConfig.WithISTDPtype;
            connectConfigs[netId][lConnId].WithESTDPcurve =  connectConfigMap[lConnId].stdpConfig.WithESTDPcurve;
            connectConfigs[netId][lConnId].WithISTDPcurve =  connectConfigMap[lConnId].stdpConfig.WithISTDPcurve;

            connectConfigs[netId][lConnId].TAU_PLUS_INV_EXC = connectConfigMap[lConnId].stdpConfig.TAU_PLUS_INV_EXC;
            connectConfigs[netId][lConnId].TAU_MINUS_INV_EXC = connectConfigMap[lConnId].stdpConfig.TAU_MINUS_INV_EXC;
            connectConfigs[netId][lConnId].ALPHA_PLUS_EXC = connectConfigMap[lConnId].stdpConfig.ALPHA_PLUS_EXC;
            connectConfigs[netId][lConnId].ALPHA_MINUS_EXC = connectConfigMap[lConnId].stdpConfig.ALPHA_MINUS_EXC;
            connectConfigs[netId][lConnId].GAMMA = connectConfigMap[lConnId].stdpConfig.GAMMA;
            connectConfigs[netId][lConnId].KAPPA = connectConfigMap[lConnId].stdpConfig.KAPPA;
            connectConfigs[netId][lConnId].OMEGA = connectConfigMap[lConnId].stdpConfig.OMEGA;
            connectConfigs[netId][lConnId].TAU_PLUS_INV_INB = connectConfigMap[lConnId].stdpConfig.TAU_PLUS_INV_INB;
            connectConfigs[netId][lConnId].TAU_MINUS_INV_INB = connectConfigMap[lConnId].stdpConfig.TAU_MINUS_INV_INB;
            connectConfigs[netId][lConnId].ALPHA_PLUS_INB = connectConfigMap[lConnId].stdpConfig.ALPHA_PLUS_INB;
            connectConfigs[netId][lConnId].ALPHA_MINUS_INB = connectConfigMap[lConnId].stdpConfig.ALPHA_MINUS_INB;
            connectConfigs[netId][lConnId].BETA_LTP = connectConfigMap[lConnId].stdpConfig.BETA_LTP;
            connectConfigs[netId][lConnId].BETA_LTD = connectConfigMap[lConnId].stdpConfig.BETA_LTD;
            connectConfigs[netId][lConnId].LAMBDA = connectConfigMap[lConnId].stdpConfig.LAMBDA;
            connectConfigs[netId][lConnId].DELTA = connectConfigMap[lConnId].stdpConfig.DELTA;
#ifdef LN_I_CALC_TYPES
            connectConfigs[netId][lConnId].NM_PKA = connectConfigMap[lConnId].stdpConfig.NM_PKA;
            connectConfigs[netId][lConnId].NM_PLC = connectConfigMap[lConnId].stdpConfig.NM_PLC;
            connectConfigs[netId][lConnId].W_PKA = connectConfigMap[lConnId].stdpConfig.W_PKA;
            connectConfigs[netId][lConnId].W_PLC = connectConfigMap[lConnId].stdpConfig.W_PLC;
            connectConfigs[netId][lConnId].icalcType = connectConfigMap[lConnId].icalcType; // Fix LN 2021
#endif
        }
    }
}

void SNN::generateRuntimeNetworkConfigs() {
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            // copy the global network config to local network configs
            // global configuration for maximum axonal delay
            networkConfigs[netId].maxDelay  = glbNetworkConfig.maxDelay;

            // configurations for execution features
            networkConfigs[netId].sim_with_fixedwts = sim_with_fixedwts;
#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVEL
            networkConfigs[netId].sim_with_conductances = sim_with_conductances;
            networkConfigs[netId].sim_with_homeostasis = sim_with_homeostasis;
            networkConfigs[netId].sim_with_stdp = sim_with_stdp;
            networkConfigs[netId].sim_with_stp = sim_with_stp;
            networkConfigs[netId].sim_in_testing = sim_in_testing;

            // search for active neuron monitor
            networkConfigs[netId].sim_with_nm = false;
            for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[netId].begin(); grpIt != groupPartitionLists[netId].end(); grpIt++) {
                if (grpIt->netId == netId && grpIt->neuronMonitorId >= 0)
                    networkConfigs[netId].sim_with_nm = true;
            }

            // stdp, da-stdp configurations
            networkConfigs[netId].stdpScaleFactor = stdpScaleFactor_;
            networkConfigs[netId].wtChangeDecay = wtChangeDecay_;

            // conductance configurations
#define LN_I_CALC_TYPES__REQUIRED_FOR_NETWORK_LEVEL
            networkConfigs[netId].sim_with_NMDA_rise = sim_with_NMDA_rise;
            networkConfigs[netId].sim_with_GABAb_rise = sim_with_GABAb_rise;
#ifndef LN_I_CALC_TYPES
            networkConfigs[netId].dAMPA = dAMPA;
            networkConfigs[netId].rNMDA = rNMDA;
            networkConfigs[netId].dNMDA = dNMDA;
            networkConfigs[netId].sNMDA = sNMDA;
            networkConfigs[netId].dGABAa = dGABAa;
            networkConfigs[netId].rGABAb = rGABAb;
            networkConfigs[netId].dGABAb = dGABAb;
            networkConfigs[netId].sGABAb = sGABAb;
#endif
            networkConfigs[netId].simIntegrationMethod = glbNetworkConfig.simIntegrationMethod;
            networkConfigs[netId].simNumStepsPerMs = glbNetworkConfig.simNumStepsPerMs;
            networkConfigs[netId].timeStep = glbNetworkConfig.timeStep;

            // configurations for boundries of neural types
            findNumN(netId, networkConfigs[netId].numN, networkConfigs[netId].numNExternal, networkConfigs[netId].numNAssigned,
                     networkConfigs[netId].numNReg, networkConfigs[netId].numNExcReg, networkConfigs[netId].numNInhReg,
                     networkConfigs[netId].numNPois, networkConfigs[netId].numNExcPois, networkConfigs[netId].numNInhPois);

            // configurations for assigned groups and connections
            networkConfigs[netId].numGroups = 0;
            for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[netId].begin(); grpIt != groupPartitionLists[netId].end(); grpIt++) {
                if (grpIt->netId == netId)
                    networkConfigs[netId].numGroups++;
            }
            networkConfigs[netId].numGroupsAssigned = groupPartitionLists[netId].size();
            //networkConfigs[netId].numConnections = localConnectLists[netId].size();
            //networkConfigs[netId].numAssignedConnections = localConnectLists[netId].size() + externalConnectLists[netId].size();
            //networkConfigs[netId].numConnections = localConnectLists[netId].size() + externalConnectLists[netId].size();
            networkConfigs[netId].numConnections = connectConfigMap.size();// temporarily solution: copy all connection info to each GPU

            // find the maximum number of pre- and post-connections among neurons
            // SNN::maxNumPreSynN and SNN::maxNumPostSynN are updated
            findMaxNumSynapsesNeurons(netId, networkConfigs[netId].maxNumPostSynN, networkConfigs[netId].maxNumPreSynN);

            // find the maximum number of spikes in D1 (i.e., maxDelay == 1) and D2 (i.e., maxDelay >= 2) sets
            findMaxSpikesD1D2(netId, networkConfigs[netId].maxSpikesD1, networkConfigs[netId].maxSpikesD2);

            // find the total number of synapses in the network
            findNumSynapsesNetwork(netId, networkConfigs[netId].numPostSynNet, networkConfigs[netId].numPreSynNet);

            // find out number of user-defined spike gen and update Noffset of each group config
            // Note: groupConfigs[][].Noffset is valid at this time
            findNumNSpikeGenAndOffset(netId);
        }
    }

    // find manager runtime data size, which is sufficient to hold the data of any gpu runtime
    memset(&managerRTDSize, 0, sizeof(ManagerRuntimeDataSize));
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            // find the maximum number of numN, numNReg ,and numNAssigned among local networks
            if (networkConfigs[netId].numNReg > managerRTDSize.maxNumNReg) managerRTDSize.maxNumNReg = networkConfigs[netId].numNReg;
            if (networkConfigs[netId].numN > managerRTDSize.maxNumN) managerRTDSize.maxNumN = networkConfigs[netId].numN;
            if (networkConfigs[netId].numNAssigned > managerRTDSize.maxNumNAssigned) managerRTDSize.maxNumNAssigned = networkConfigs[netId].numNAssigned;

            // find the maximum number of numNSpikeGen among local networks
            if (networkConfigs[netId].numNSpikeGen > managerRTDSize.maxNumNSpikeGen) managerRTDSize.maxNumNSpikeGen = networkConfigs[netId].numNSpikeGen;

            // \note maxNumNPois is used for both numRand and poissonFireRates
            if (networkConfigs[netId].numNPois > managerRTDSize.maxNumNPois) managerRTDSize.maxNumNPois = networkConfigs[netId].numNPois;  

            // find the maximum number of numGroups and numConnections among local networks
            if (networkConfigs[netId].numGroups > managerRTDSize.maxNumGroups) managerRTDSize.maxNumGroups = networkConfigs[netId].numGroups;
            if (networkConfigs[netId].numConnections > managerRTDSize.maxNumConnections) managerRTDSize.maxNumConnections = networkConfigs[netId].numConnections;

            // find the maximum number of neurons in a group among local networks
            for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[netId].begin(); grpIt != groupPartitionLists[netId].end(); grpIt++) {
                if (groupConfigMap[grpIt->gGrpId].numN > managerRTDSize.maxNumNPerGroup) managerRTDSize.maxNumNPerGroup = groupConfigMap[grpIt->gGrpId].numN;
            }

            // find the maximum number of maxSipkesD1(D2) among networks
            if (networkConfigs[netId].maxSpikesD1 > managerRTDSize.maxMaxSpikeD1) managerRTDSize.maxMaxSpikeD1 = networkConfigs[netId].maxSpikesD1;
            if (networkConfigs[netId].maxSpikesD2 > managerRTDSize.maxMaxSpikeD2) managerRTDSize.maxMaxSpikeD2 = networkConfigs[netId].maxSpikesD2;

            // find the maximum number of total # of pre- and post-connections among local networks
            if (networkConfigs[netId].numPreSynNet > managerRTDSize.maxNumPreSynNet) managerRTDSize.maxNumPreSynNet = networkConfigs[netId].numPreSynNet;
            if (networkConfigs[netId].numPostSynNet > managerRTDSize.maxNumPostSynNet) managerRTDSize.maxNumPostSynNet = networkConfigs[netId].numPostSynNet;

            // find the number of numN, and numNReg in the global network
            managerRTDSize.glbNumN += networkConfigs[netId].numN;
            managerRTDSize.glbNumNReg += networkConfigs[netId].numNReg;
        }
    }
}

bool compareSrcNeuron(const ConnectionInfo& first, const ConnectionInfo& second) {
    return (first.nSrc + first.srcGLoffset < second.nSrc + second.srcGLoffset);
}

bool compareDelay(const ConnectionInfo& first, const ConnectionInfo& second) {
    return (first.delay < second.delay);
}

//#define DEBUG__generateConnectionRuntime__pre_pos
//#define DEBUG__generateConnectionRuntime__preSynapticIds

// Note: ConnectInfo stored in connectionList use global ids
void SNN::generateConnectionRuntime(int netId) {
    std::map<int, int> GLoffset; // global nId to local nId offset
    std::map<int, int> GLgrpId; // global grpId to local grpId offset

    // load offset between global neuron id and local neuron id
    for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[netId].begin(); grpIt != groupPartitionLists[netId].end(); grpIt++) {
        GLoffset[grpIt->gGrpId] = grpIt->GtoLOffset;
        GLgrpId[grpIt->gGrpId] = grpIt->lGrpId;
    }
    // FIXME: connId is global connId, use connectConfigs[netId][local connId] instead,
    // FIXME; but note connectConfigs[netId][] are NOT complete, lack of exeternal incoming connections
    // generate mulSynFast, mulSynSlow in connection-centric array
    for (std::map<int, ConnectConfig>::iterator connIt = connectConfigMap.begin(); connIt != connectConfigMap.end(); connIt++) {
        // store scaling factors for synaptic currents in connection-centric array
        mulSynFast[connIt->second.connId] = connIt->second.mulSynFast;
        mulSynSlow[connIt->second.connId] = connIt->second.mulSynSlow;
    }

    // parse ConnectionInfo stored in connectionLists[0]
    // note: ConnectInfo stored in connectionList use global ids
    // generate Npost, Npre, Npre_plastic
    int parsedConnections = 0;
    memset(managerRuntimeData.Npost, 0, sizeof(short) * networkConfigs[netId].numNAssigned);
    memset(managerRuntimeData.Npre, 0, sizeof(short) * networkConfigs[netId].numNAssigned);
    memset(managerRuntimeData.Npre_plastic, 0, sizeof(short) * networkConfigs[netId].numNAssigned);
#ifdef LN_FIX_CONNLIST_
    for (std::vector<ConnectionInfo>::iterator connIt = connectionLists[netId].begin(); connIt != connectionLists[netId].end(); connIt++) {
#else
    for (std::list<ConnectionInfo>::iterator connIt = connectionLists[netId].begin(); connIt != connectionLists[netId].end(); connIt++) {
#endif
        connIt->srcGLoffset = GLoffset[connIt->grpSrc];
        if (managerRuntimeData.Npost[connIt->nSrc + GLoffset[connIt->grpSrc]] == SYNAPSE_ID_MASK) {
            KERNEL_ERROR("Error: the number of synapses exceeds maximum limit (%d) for neuron %d (group %d)", SYNAPSE_ID_MASK, connIt->nSrc, connIt->grpSrc);
            exitSimulation(ID_OVERFLOW_ERROR);
        }
        if (managerRuntimeData.Npre[connIt->nDest + GLoffset[connIt->grpDest]] == SYNAPSE_ID_MASK) {
            KERNEL_ERROR("Error: the number of synapses exceeds maximum limit (%d) for neuron %d (group %d)", SYNAPSE_ID_MASK, connIt->nDest, connIt->grpDest);
            exitSimulation(ID_OVERFLOW_ERROR);
        }
        managerRuntimeData.Npost[connIt->nSrc + GLoffset[connIt->grpSrc]]++;
        managerRuntimeData.Npre[connIt->nDest + GLoffset[connIt->grpDest]]++;

        if (GET_FIXED_PLASTIC(connectConfigMap[connIt->connId].connProp) == SYN_PLASTIC) {
            sim_with_fixedwts = false; // if network has any plastic synapses at all, this will be set to true
            managerRuntimeData.Npre_plastic[connIt->nDest + GLoffset[connIt->grpDest]]++;

            // homeostasis
            if (groupConfigMap[connIt->grpDest].homeoConfig.WithHomeostasis && groupConfigMDMap[connIt->grpDest].homeoId == -1)
                groupConfigMDMap[connIt->grpDest].homeoId = connIt->nDest + GLoffset[connIt->grpDest]; // this neuron info will be printed

            // old access to homeostasis
            //if (groupConfigs[netId][GLgrpId[it->grpDest]].WithHomeostasis && groupConfigs[netId][GLgrpId[it->grpDest]].homeoId == -1)
            //  groupConfigs[netId][GLgrpId[it->grpDest]].homeoId = it->nDest + GLoffset[it->grpDest]; // this neuron info will be printed
        }

        // generate the delay vaule
        //it->delay = connectConfigMap[it->connId].minDelay + rand() % (connectConfigMap[it->connId].maxDelay - connectConfigMap[it->connId].minDelay + 1);
        //assert((it->delay >= connectConfigMap[it->connId].minDelay) && (it->delay <= connectConfigMap[it->connId].maxDelay));
        // generate the max weight and initial weight
        //float initWt = generateWeight(connectConfigMap[it->connId].connProp, connectConfigMap[it->connId].initWt, connectConfigMap[it->connId].maxWt, it->nSrc, it->grpSrc);
        //float initWt = connectConfigMap[it->connId].initWt;
        //float maxWt = connectConfigMap[it->connId].maxWt;
        // adjust sign of weight based on pre-group (negative if pre is inhibitory)
        // this access is fine, isExcitatoryGroup() use global grpId
        //it->maxWt = isExcitatoryGroup(it->grpSrc) ? fabs(maxWt) : -1.0 * fabs(maxWt);
        //it->initWt = isExcitatoryGroup(it->grpSrc) ? fabs(initWt) : -1.0 * fabs(initWt);

        parsedConnections++;
    }
    assert(parsedConnections == networkConfigs[netId].numPostSynNet && parsedConnections == networkConfigs[netId].numPreSynNet);

    // generate cumulativePost and cumulativePre
    managerRuntimeData.cumulativePost[0] = 0;
    managerRuntimeData.cumulativePre[0] = 0;
    for (int lNId = 1; lNId < networkConfigs[netId].numNAssigned; lNId++) {
        managerRuntimeData.cumulativePost[lNId] = managerRuntimeData.cumulativePost[lNId - 1] + managerRuntimeData.Npost[lNId - 1];
        managerRuntimeData.cumulativePre[lNId] = managerRuntimeData.cumulativePre[lNId - 1] + managerRuntimeData.Npre[lNId - 1];
    }

    // generate preSynapticIds, parse plastic connections first
    memset(managerRuntimeData.Npre, 0, sizeof(short) * networkConfigs[netId].numNAssigned); // reset managerRuntimeData.Npre to zero, so that it can be used as synId
    parsedConnections = 0;
#ifdef LN_FIX_CONNLIST_
    for (std::vector<ConnectionInfo>::iterator connIt = connectionLists[netId].begin(); connIt != connectionLists[netId].end(); connIt++) {
#else
    for (std::list<ConnectionInfo>::iterator connIt = connectionLists[netId].begin(); connIt != connectionLists[netId].end(); connIt++) {
#endif
        if (GET_FIXED_PLASTIC(connectConfigMap[connIt->connId].connProp) == SYN_PLASTIC) {
            int pre_pos = managerRuntimeData.cumulativePre[connIt->nDest + GLoffset[connIt->grpDest]] + managerRuntimeData.Npre[connIt->nDest + GLoffset[connIt->grpDest]];
            assert(pre_pos < networkConfigs[netId].numPreSynNet);

            managerRuntimeData.preSynapticIds[pre_pos] = SET_CONN_ID((connIt->nSrc + GLoffset[connIt->grpSrc]), 0, (GLgrpId[connIt->grpSrc])); // managerRuntimeData.Npost[it->nSrc] is not availabe at this parse
            connIt->preSynId = managerRuntimeData.Npre[connIt->nDest + GLoffset[connIt->grpDest]]; // save managerRuntimeData.Npre[it->nDest] as synId

            managerRuntimeData.Npre[connIt->nDest+ GLoffset[connIt->grpDest]]++;
            parsedConnections++;

            // update the maximum number of and pre-connections of a neuron in a group
            //if (managerRuntimeData.Npre[it->nDest] > groupInfo[it->grpDest].maxPreConn)
            //  groupInfo[it->grpDest].maxPreConn = managerRuntimeData.Npre[it->nDest];
        }
    }
    // parse fixed connections
#ifdef LN_FIX_CONNLIST_
    for (std::vector<ConnectionInfo>::iterator connIt = connectionLists[netId].begin(); connIt != connectionLists[netId].end(); connIt++) {
#else
    for (std::list<ConnectionInfo>::iterator connIt = connectionLists[netId].begin(); connIt != connectionLists[netId].end(); connIt++) {
#endif
        if (GET_FIXED_PLASTIC(connectConfigMap[connIt->connId].connProp) == SYN_FIXED) {
            int pre_pos = managerRuntimeData.cumulativePre[connIt->nDest + GLoffset[connIt->grpDest]] + managerRuntimeData.Npre[connIt->nDest + GLoffset[connIt->grpDest]];
            assert(pre_pos < networkConfigs[netId].numPreSynNet);

            managerRuntimeData.preSynapticIds[pre_pos] = SET_CONN_ID((connIt->nSrc + GLoffset[connIt->grpSrc]), 0, (GLgrpId[connIt->grpSrc])); // managerRuntimeData.Npost[it->nSrc] is not availabe at this parse
            connIt->preSynId = managerRuntimeData.Npre[connIt->nDest + GLoffset[connIt->grpDest]]; // save managerRuntimeData.Npre[it->nDest] as synId

            managerRuntimeData.Npre[connIt->nDest + GLoffset[connIt->grpDest]]++;
            parsedConnections++;

            // update the maximum number of and pre-connections of a neuron in a group
            //if (managerRuntimeData.Npre[it->nDest] > groupInfo[it->grpDest].maxPreConn)
            //  groupInfo[it->grpDest].maxPreConn = managerRuntimeData.Npre[it->nDest];
        }
    }
    assert(parsedConnections == networkConfigs[netId].numPreSynNet);
    //printf("parsed pre connections %d\n", parsedConnections);

    // generate postSynapticIds
#ifdef LN_FIX_CONNLIST_
    //\todo FIX_CONLIST  implement splice sort(compareSrcNeuron) for vector
#else
    connectionLists[netId].sort(compareSrcNeuron); // sort by local nSrc id
#endif
    memset(managerRuntimeData.postDelayInfo, 0, sizeof(DelayInfo) * (networkConfigs[netId].numNAssigned * (glbNetworkConfig.maxDelay + 1)));
    for (int lNId = 0; lNId < networkConfigs[netId].numNAssigned; lNId++) { // pre-neuron order, local nId
        if (managerRuntimeData.Npost[lNId] > 0) {
            std::list<ConnectionInfo> postConnectionList;
            ConnectionInfo targetConn;
            targetConn.nSrc = lNId ; // the other fields does not matter, use local nid to search

#ifdef LN_FIX_CONNLIST_
            std::list<ConnectionInfo>::iterator firstPostConn;
            // \todo  FIX_CONLIST   rewrite find()
#else   
            std::list<ConnectionInfo>::iterator firstPostConn = std::find(connectionLists[netId].begin(), connectionLists[netId].end(), targetConn);
#endif
            std::list<ConnectionInfo>::iterator lastPostConn = firstPostConn;
            std::advance(lastPostConn, managerRuntimeData.Npost[lNId]);
            managerRuntimeData.Npost[lNId] = 0; // reset managerRuntimeData.Npost[lNId] to zero, so that it can be used as synId

#ifdef LN_FIX_CONNLIST_         
            // \todo  FIX_CONLIST   implement splice(...) for vector
            // Assertion failed : connectionLists[netId].empty(), file src\snn_manager.cpp, line 3531
#else
            postConnectionList.splice(postConnectionList.begin(), connectionLists[netId], firstPostConn, lastPostConn);
            postConnectionList.sort(compareDelay);
#endif

            // to recognize the INV, data must be homgenous and have a high Signal/Noise ratio (no cludering formating)
#ifdef DEBUG__generateConnectionRuntime__pre_pos
            printf("pre_pos  = cumulativePre[connIt->nDest] + connIt->preSynId\n");
#endif
#ifdef DEBUG__generateConnectionRuntime__preSynapticIds
            printf("preSynapticIds[pre_pos] = SET_CONN_ID((nSrc + GLoffset[grpSrc]), Npost[nSrc + GLoffset[grpSrc]], (GLgrpId[grpSrc]))\n");
#endif
            //memset(&managerRuntimeData.postDelayInfo[lNId * (glbNetworkConfig.maxDelay + 1)], 0, sizeof(DelayInfo) * (glbNetworkConfig.maxDelay + 1));
            int post_pos, pre_pos, lastDelay = 0;
            parsedConnections = 0;
            //memset(&managerRuntimeData.postDelayInfo[lNId * (glbNetworkConfig.maxDelay + 1)], 0, sizeof(DelayInfo) * (glbNetworkConfig.maxDelay + 1));
            for (std::list<ConnectionInfo>::iterator connIt = postConnectionList.begin(); connIt != postConnectionList.end(); connIt++) {
                assert(connIt->nSrc + GLoffset[connIt->grpSrc] == lNId);
                post_pos = managerRuntimeData.cumulativePost[connIt->nSrc + GLoffset[connIt->grpSrc]] + managerRuntimeData.Npost[connIt->nSrc + GLoffset[connIt->grpSrc]];
                pre_pos  = managerRuntimeData.cumulativePre[connIt->nDest + GLoffset[connIt->grpDest]] + connIt->preSynId;
#ifdef DEBUG__generateConnectionRuntime__pre_pos
                printf("pre_pos  =           %3d[          %3d] +              %3d\n", managerRuntimeData.cumulativePre[connIt->nDest + GLoffset[connIt->grpDest]], connIt->nDest, connIt->preSynId);
#endif
                assert(post_pos < networkConfigs[netId].numPostSynNet);
                //assert(pre_pos  < numPreSynNet);

                // generate a post synaptic id for the current connection
                managerRuntimeData.postSynapticIds[post_pos] = SET_CONN_ID((connIt->nDest + GLoffset[connIt->grpDest]), connIt->preSynId, (GLgrpId[connIt->grpDest]));// used stored managerRuntimeData.Npre[it->nDest] in it->preSynId
                // generate a delay look up table by the way
                assert(connIt->delay > 0);
                if (connIt->delay > lastDelay) {
                    managerRuntimeData.postDelayInfo[lNId * (glbNetworkConfig.maxDelay + 1) + connIt->delay - 1].delay_index_start = managerRuntimeData.Npost[connIt->nSrc + GLoffset[connIt->grpSrc]];
                    managerRuntimeData.postDelayInfo[lNId * (glbNetworkConfig.maxDelay + 1) + connIt->delay - 1].delay_length++;
                } else if (connIt->delay == lastDelay) {
                    managerRuntimeData.postDelayInfo[lNId * (glbNetworkConfig.maxDelay + 1) + connIt->delay - 1].delay_length++;
                } else {
                    KERNEL_ERROR("Post-synaptic delays not sorted correctly... pre_id=%d, delay[%d]=%d, delay[%d]=%d",
                        lNId, managerRuntimeData.Npost[connIt->nSrc + GLoffset[connIt->grpSrc]], connIt->delay, managerRuntimeData.Npost[connIt->nSrc + GLoffset[connIt->grpSrc]] - 1, lastDelay);
                }
                lastDelay = connIt->delay;

                // update the corresponding pre synaptic id
                SynInfo preId = managerRuntimeData.preSynapticIds[pre_pos];
                assert(GET_CONN_NEURON_ID(preId) == connIt->nSrc + GLoffset[connIt->grpSrc]);
                //assert(GET_CONN_GRP_ID(preId) == it->grpSrc);
                managerRuntimeData.preSynapticIds[pre_pos] = SET_CONN_ID((connIt->nSrc + GLoffset[connIt->grpSrc]), managerRuntimeData.Npost[connIt->nSrc + GLoffset[connIt->grpSrc]], (GLgrpId[connIt->grpSrc]));
#ifdef DEBUG__generateConnectionRuntime__preSynapticIds
                printf("preSynapticIds[    %3d] = SET_CONN_ID(( %3d +      %3d[   %3d]),   %3d[ %3d +      %3d[   %3d]], (    %3d[   %3d]));\n",
                    pre_pos, 
                    connIt->nSrc, GLoffset[connIt->grpSrc], connIt->grpSrc, 
                    managerRuntimeData.Npost[connIt->nSrc + GLoffset[connIt->grpSrc]], connIt->nSrc, GLoffset[connIt->grpSrc], connIt->grpSrc,
                    GLgrpId[connIt->grpSrc], connIt->grpSrc );
#endif

                managerRuntimeData.wt[pre_pos] = connIt->initWt;
                managerRuntimeData.maxSynWt[pre_pos] = connIt->maxWt;
                managerRuntimeData.connIdsPreIdx[pre_pos] = connIt->connId;

                managerRuntimeData.Npost[connIt->nSrc + GLoffset[connIt->grpSrc]]++;
                parsedConnections++;

                // update the maximum number of and post-connections of a neuron in a group
                //if (managerRuntimeData.Npost[it->nSrc] > groupInfo[it->grpSrc].maxPostConn)
                //  groupInfo[it->grpSrc].maxPostConn = managerRuntimeData.Npost[it->nSrc];
            }
            assert(parsedConnections == managerRuntimeData.Npost[lNId]);
            //printf("parsed post connections %d\n", parsedConnections);
            // note: elements in postConnectionList are deallocated automatically with postConnectionList
            /* for postDelayInfo debugging
            printf("%d ", lNId);
            int maxDelay_ = glbNetworkConfig.maxDelay;
            for (int t = 0; t < maxDelay_ + 1; t ++) {
                printf("[%d,%d]",
                    managerRuntimeData.postDelayInfo[lNId * (maxDelay_ + 1) + t].delay_index_start,
                    managerRuntimeData.postDelayInfo[lNId * (maxDelay_ + 1) + t].delay_length);
            }
            printf("\n");
            */
        }
    }
    assert(connectionLists[netId].empty());

    //int p = managerRuntimeData.Npost[src];

    //assert(managerRuntimeData.Npost[src] >= 0);
    //assert(managerRuntimeData.Npre[dest] >= 0);
    //assert((src * maxNumPostSynGrp + p) / numN < maxNumPostSynGrp); // divide by numN to prevent INT overflow

    //unsigned int post_pos = managerRuntimeData.cumulativePost[src] + managerRuntimeData.Npost[src];
    //unsigned int pre_pos  = managerRuntimeData.cumulativePre[dest] + managerRuntimeData.Npre[dest];

    //assert(post_pos < numPostSynNet);
    //assert(pre_pos  < numPreSynNet);

    //managerRuntimeData.postSynapticIds[post_pos]   = SET_CONN_ID(dest, managerRuntimeData.Npre[dest], destGrp);
    //tmp_SynapticDelay[post_pos] = dVal;

    //managerRuntimeData.preSynapticIds[pre_pos] = SET_CONN_ID(src, managerRuntimeData.Npost[src], srcGrp);
    //managerRuntimeData.wt[pre_pos]      = synWt;
    //managerRuntimeData.maxSynWt[pre_pos] = maxWt;
    //managerRuntimeData.connIdsPreIdx[pre_pos] = connId;

    //bool synWtType = GET_FIXED_PLASTIC(connProp);

    //if (synWtType == SYN_PLASTIC) {
    //  sim_with_fixedwts = false; // if network has any plastic synapses at all, this will be set to true
    //  managerRuntimeData.Npre_plastic[dest]++;
    //  // homeostasis
    //  if (groupConfigs[0][destGrp].WithHomeostasis && groupConfigs[0][destGrp].homeoId ==-1)
    //      groupConfigs[0][destGrp].homeoId = dest; // this neuron info will be printed
    //}

    //managerRuntimeData.Npre[dest] += 1;
    //managerRuntimeData.Npost[src] += 1;

    //groupInfo[srcGrp].numPostConn++;
    //groupInfo[destGrp].numPreConn++;

    //if (managerRuntimeData.Npost[src] > groupInfo[srcGrp].maxPostConn)
    //  groupInfo[srcGrp].maxPostConn = managerRuntimeData.Npost[src];
    //if (managerRuntimeData.Npre[dest] > groupInfo[destGrp].maxPreConn)
    //  groupInfo[destGrp].maxPreConn = managerRuntimeData.Npre[src];
}

void SNN::generateCompConnectionRuntime(int netId)
{
    std::map<int, int> GLgrpId; // global grpId to local grpId offset

    for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[netId].begin(); grpIt != groupPartitionLists[netId].end(); grpIt++) {
        GLgrpId[grpIt->gGrpId] = grpIt->lGrpId;
        //printf("Global group id %i; Local group id %i\n", grpIt->gGrpId, grpIt->lGrpId);
    }

    //printf("The current netid is: %i\n", netId);

    for (std::list<compConnectConfig>::iterator connIt = localCompConnectLists[netId].begin(); connIt != localCompConnectLists[netId].end(); connIt++) {
        //printf("The size of localCompConnectLists is: %i\n", localCompConnectLists[netId].size());
        int grpLower = connIt->grpSrc;
        int grpUpper = connIt->grpDest;

        int i = groupConfigs[netId][GLgrpId[grpLower]].numCompNeighbors;
        if (i >= MAX_NUM_COMP_CONN) {
            KERNEL_ERROR("Group %s(%d) exceeds max number of allowed compartmental connections (%d).",
                groupConfigMap[grpLower].grpName.c_str(), grpLower, (int)MAX_NUM_COMP_CONN);
            exitSimulation(KERNEL_ERROR_COMP_CONNS_EXCEEDED);
        }
        groupConfigs[netId][GLgrpId[grpLower]].compNeighbors[i] = grpUpper;
        groupConfigs[netId][GLgrpId[grpLower]].compCoupling[i] = groupConfigs[netId][GLgrpId[grpUpper]].compCouplingDown; // get down-coupling from upper neighbor
        groupConfigs[netId][GLgrpId[grpLower]].numCompNeighbors++;

        int j = groupConfigs[netId][GLgrpId[grpUpper]].numCompNeighbors;
        if (j >= MAX_NUM_COMP_CONN) {
            KERNEL_ERROR("Group %s(%d) exceeds max number of allowed compartmental connections (%d).",
                groupConfigMap[grpUpper].grpName.c_str(), grpUpper, (int)MAX_NUM_COMP_CONN);
            exitSimulation(KERNEL_ERROR_COMP_CONNS_EXCEEDED2);
        }
        groupConfigs[netId][GLgrpId[grpUpper]].compNeighbors[j] = grpLower;
        groupConfigs[netId][GLgrpId[grpUpper]].compCoupling[j] = groupConfigs[netId][GLgrpId[grpLower]].compCouplingUp; // get up-coupling from lower neighbor
        groupConfigs[netId][GLgrpId[grpUpper]].numCompNeighbors++;

        //printf("Group %i (local group %i) has %i compartmental neighbors!\n", grpUpper, GLgrpId[grpUpper], groupConfigs[netId][GLgrpId[grpUpper]].numCompNeighbors);
    }
}


void SNN::generatePoissonGroupRuntime(int netId, int lGrpId) {
    resetNeuromodulator(netId, lGrpId); // Fix LN2021

    for(int lNId = groupConfigs[netId][lGrpId].lStartN; lNId <= groupConfigs[netId][lGrpId].lEndN; lNId++)
        resetPoissonNeuron(netId, lGrpId, lNId);
}


void SNN::collectGlobalNetworkConfigC() {
    // scan all connect configs to find the maximum delay in the global network, update glbNetworkConfig.maxDelay
    for (std::map<int, ConnectConfig>::iterator connIt = connectConfigMap.begin(); connIt != connectConfigMap.end(); connIt++) {
        if (connIt->second.maxDelay > glbNetworkConfig.maxDelay)
            glbNetworkConfig.maxDelay = connIt->second.maxDelay;
    }
    assert(connectConfigMap.size() > 0 || glbNetworkConfig.maxDelay != -1);

    // scan all group configs to find the number of (reg, pois, exc, inh) neuron in the global network
    for(int gGrpId = 0; gGrpId < numGroups; gGrpId++) {
        if (IS_EXCITATORY_TYPE(groupConfigMap[gGrpId].type) && (groupConfigMap[gGrpId].type & POISSON_NEURON)) {
            glbNetworkConfig.numNExcPois += groupConfigMap[gGrpId].numN;
        } else if (IS_INHIBITORY_TYPE(groupConfigMap[gGrpId].type) &&  (groupConfigMap[gGrpId].type & POISSON_NEURON)) {
            glbNetworkConfig.numNInhPois += groupConfigMap[gGrpId].numN;
        } else if (IS_EXCITATORY_TYPE(groupConfigMap[gGrpId].type) && !(groupConfigMap[gGrpId].type & POISSON_NEURON)) {
            glbNetworkConfig.numNExcReg += groupConfigMap[gGrpId].numN;
        } else if (IS_INHIBITORY_TYPE(groupConfigMap[gGrpId].type) && !(groupConfigMap[gGrpId].type & POISSON_NEURON)) {
            glbNetworkConfig.numNInhReg += groupConfigMap[gGrpId].numN;
        }

        if (groupConfigMDMap[gGrpId].maxOutgoingDelay == 1)
            glbNetworkConfig.numN1msDelay += groupConfigMap[gGrpId].numN;
        else if (groupConfigMDMap[gGrpId].maxOutgoingDelay >= 2)
            glbNetworkConfig.numN2msDelay += groupConfigMap[gGrpId].numN;
    }

    glbNetworkConfig.numNReg = glbNetworkConfig.numNExcReg + glbNetworkConfig.numNInhReg;
    glbNetworkConfig.numNPois = glbNetworkConfig.numNExcPois + glbNetworkConfig.numNInhPois;
    glbNetworkConfig.numN = glbNetworkConfig.numNReg + glbNetworkConfig.numNPois;
}


void SNN::collectGlobalNetworkConfigP() {
    // print group and connection overview
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!localConnectLists[netId].empty() || !externalConnectLists[netId].empty()) {
            for (std::list<ConnectConfig>::iterator connIt = localConnectLists[netId].begin(); connIt != localConnectLists[netId].end(); connIt++)
                glbNetworkConfig.numSynNet += connIt->numberOfConnections;

            for (std::list<ConnectConfig>::iterator connIt = externalConnectLists[netId].begin(); connIt != externalConnectLists[netId].end(); connIt++)
                glbNetworkConfig.numSynNet += connIt->numberOfConnections;
        }
    }
}

// after all the initalization. Its time to create the synaptic weights, weight change and also
// time of firing these are the mostly costly arrays so dense packing is essential to minimize wastage of space
void SNN::compileSNN() {
    KERNEL_DEBUG("Beginning compilation of the network....");

    // compile (update) group and connection configs according to their mutual information
    // update GroupConfig::MaxDelay GroupConfig::FixedInputWts
    // assign GroupConfig::StartN and GroupConfig::EndN
    // Note: MaxDelay, FixedInputWts, StartN, and EndN are invariant in single-GPU or multi-GPUs mode
    compileGroupConfig();

    compileConnectConfig(); // for future use

    // collect the global network config according to compiled gorup and connection configs
    // collect SNN::maxDelay_
    collectGlobalNetworkConfigC();

    // perform various consistency checks:
    // - numNeurons vs. sum of all neurons
    // - STDP set on a post-group with incoming plastic connections
    // - etc.
    verifyNetwork();

    // display the global network configuration
    KERNEL_INFO("\n");
    KERNEL_INFO("************************** Global Network Configuration *******************************");
    KERNEL_INFO("The number of neurons in the network (numN) = %d", glbNetworkConfig.numN);
    KERNEL_INFO("The number of regular neurons in the network (numNReg:numNExcReg:numNInhReg) = %d:%d:%d", glbNetworkConfig.numNReg, glbNetworkConfig.numNExcReg, glbNetworkConfig.numNInhReg);
    KERNEL_INFO("The number of poisson neurons in the network (numNPois:numNExcPois:numInhPois) = %d:%d:%d", glbNetworkConfig.numNPois, glbNetworkConfig.numNExcPois, glbNetworkConfig.numNInhPois);
    KERNEL_INFO("The maximum axonal delay in the network (maxDelay) = %d", glbNetworkConfig.maxDelay);

    //ensure that we dont compile the network again
    snnState = COMPILED_SNN;
}

void SNN::compileConnectConfig() {

    // Fix (reviewed) for failing UnitTest Interface.setSTDPDeath.
    bool synWtType;
    for (std::map<int, ConnectConfig>::iterator connIt = connectConfigMap.begin(); connIt != connectConfigMap.end(); connIt++) {
        ConnectConfig &config = connIt->second;
        if (connIt->second.stdpConfig.WithSTDP) {
            synWtType = GET_FIXED_PLASTIC(connIt->second.connProp);  // derived from compileGroupConfig()
            if (synWtType != SYN_PLASTIC) {
                KERNEL_ERROR("STDP requires plastic connection");
                exitSimulation(KERNEL_ERROR_STDP_SYN_PLASIC);
            }
        }
    }
}

void SNN::compileGroupConfig() {
    int grpSrc;
    bool synWtType;

    // find the maximum delay for each group according to incoming connection
    for (std::map<int, ConnectConfig>::iterator connIt = connectConfigMap.begin(); connIt != connectConfigMap.end(); connIt++) {
        // check if the current connection's delay meaning grpSrc's delay
        // is greater than the MaxDelay for grpSrc. We find the maximum
        // delay for the grpSrc by this scheme.
        grpSrc = connIt->second.grpSrc;
        if (connIt->second.maxDelay > groupConfigMDMap[grpSrc].maxOutgoingDelay)
            groupConfigMDMap[grpSrc].maxOutgoingDelay = connIt->second.maxDelay;

        // given group has plastic connection, and we need to apply STDP rule...
        synWtType = GET_FIXED_PLASTIC(connIt->second.connProp);
        if (synWtType == SYN_PLASTIC) {
            groupConfigMDMap[connIt->second.grpDest].fixedInputWts = false;
        }
    }

    // assigned global neruon ids to each group in the order...
    //    !!!!!!! IMPORTANT : NEURON ORGANIZATION/ARRANGEMENT MAP !!!!!!!!!!
    //     <--- Excitatory --> | <-------- Inhibitory REGION ----------> | <-- Excitatory -->
    //     Excitatory-Regular  | Inhibitory-Regular | Inhibitory-Poisson | Excitatory-Poisson
    int assignedGroup = 0;
    int availableNeuronId = 0;
    for(int order = 0; order < 4; order++) {
        for(int gGrpId = 0; gGrpId < numGroups; gGrpId++) {
            if (IS_EXCITATORY_TYPE(groupConfigMap[gGrpId].type) && (groupConfigMap[gGrpId].type & POISSON_NEURON) && order == 3) {
                availableNeuronId = assignGroup(gGrpId, availableNeuronId);
                assignedGroup++;
            } else if (IS_INHIBITORY_TYPE(groupConfigMap[gGrpId].type) &&  (groupConfigMap[gGrpId].type & POISSON_NEURON) && order == 2) {
                availableNeuronId = assignGroup(gGrpId, availableNeuronId);
                assignedGroup++;
            } else if (IS_EXCITATORY_TYPE(groupConfigMap[gGrpId].type) && !(groupConfigMap[gGrpId].type & POISSON_NEURON) && order == 0) {
                availableNeuronId = assignGroup(gGrpId, availableNeuronId);
                assignedGroup++;
            } else if (IS_INHIBITORY_TYPE(groupConfigMap[gGrpId].type) && !(groupConfigMap[gGrpId].type & POISSON_NEURON) && order == 1) {
                availableNeuronId = assignGroup(gGrpId, availableNeuronId);
                assignedGroup++;
            }
        }
    }
    //assert(availableNeuronId == numN);
    assert(assignedGroup == numGroups);

#ifdef LN_I_CALC_TYPES
    // group based IcalcType
    auto networkDefault = sim_with_conductances ? COBA : CUBA;
    for (int gGrpId = 0; gGrpId < numGroups; gGrpId++) {
        if (groupConfigMap[gGrpId].icalcType == UNKNOWN_ICALC) {
            groupConfigMap[gGrpId].icalcType = networkDefault;
            groupConfigMap[gGrpId].with_NMDA_rise = sim_with_NMDA_rise;
            groupConfigMap[gGrpId].with_GABAb_rise = sim_with_GABAb_rise;
#define LN_I_CALC_TYPES__REQUIRED_FOR_BACKWARD_COMP
            auto& config = groupConfigMap[gGrpId].conductanceConfig;
            config.dAMPA = dAMPA;  // loss of precision is acceptable
            config.dGABAa = dGABAa;
            config.dGABAb = dGABAb;
            config.dNMDA = dNMDA;
            config.rGABAb = rGABAb;
            config.rNMDA = rNMDA;
            config.sGABAb = sGABAb;
            config.sNMDA = sNMDA;
        }
    }
#endif

}

void SNN::connectNetwork() {
    // this parse generates local connections
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        for (std::list<ConnectConfig>::iterator connIt = localConnectLists[netId].begin(); connIt != localConnectLists[netId].end(); connIt++) {
            switch(connIt->type) {
                case CONN_RANDOM:
                    connectRandom(netId, connIt, false);
                    break;
                case CONN_FULL:
                    connectFull(netId, connIt, false);
                    break;
                case CONN_FULL_NO_DIRECT:
                    connectFull(netId, connIt, false);
                    break;
                case CONN_ONE_TO_ONE:
                    connectOneToOne(netId, connIt, false);
                    break;
                case CONN_GAUSSIAN:
                    connectGaussian(netId, connIt, false);
                    break;
                case CONN_USER_DEFINED:
                    connectUserDefined(netId, connIt, false);
                    break;
                default:
                    KERNEL_ERROR("Invalid connection type( should be 'random', 'full', 'full-no-direct', or 'one-to-one')");
                    exitSimulation(KERNEL_ERROR_INVALID_CONN2);
            }
        }
    }

    // this parse generates external connections
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        for (std::list<ConnectConfig>::iterator connIt = externalConnectLists[netId].begin(); connIt != externalConnectLists[netId].end(); connIt++) {
            switch(connIt->type) {
                case CONN_RANDOM:
                    connectRandom(netId, connIt, true);
                    break;
                case CONN_FULL:
                    connectFull(netId, connIt, true);
                    break;
                case CONN_FULL_NO_DIRECT:
                    connectFull(netId, connIt, true);
                    break;
                case CONN_ONE_TO_ONE:
                    connectOneToOne(netId, connIt, true);
                    break;
                case CONN_GAUSSIAN:
                    connectGaussian(netId, connIt, true);
                    break;
                case CONN_USER_DEFINED:
                    connectUserDefined(netId, connIt, true);
                    break;
                default:
                    KERNEL_ERROR("Invalid connection type( should be 'random', 'full', 'full-no-direct', or 'one-to-one')");
                    exitSimulation(KERNEL_ERROR_INVALID_CONN3);
            }
        }
    }
}


//#include <thread>
//void SNN::connectNetworkMT() {
//  // this parse generates local connections
//
//  std::vector<std::thread> pool;
//
//  for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
//
//      pool.push_back(move(std::thread([&, netId]() {
//
//          for (std::list<ConnectConfig>::iterator connIt = localConnectLists[netId].begin(); connIt != localConnectLists[netId].end(); connIt++) {
//              switch (connIt->type) {
//              case CONN_RANDOM:
//                  //connectRandomMT(netId, connIt, false); // does not work
//                  connectRandom(netId, connIt, false);
//                  break;
//              case CONN_FULL:
//                  connectFull(netId, connIt, false);
//                  break;
//              case CONN_FULL_NO_DIRECT:
//                  connectFull(netId, connIt, false);
//                  break;
//              case CONN_ONE_TO_ONE:
//                  connectOneToOne(netId, connIt, false);
//                  break;
//              case CONN_GAUSSIAN:
//                  connectGaussian(netId, connIt, false);
//                  break;
//              case CONN_USER_DEFINED:
//                  connectUserDefined(netId, connIt, false);
//                  break;
//              default:
//                  KERNEL_ERROR("Invalid connection type( should be 'random', 'full', 'full-no-direct', or 'one-to-one')");
//                  exitSimulation(-1);
//              }
//          }
//
//      })));
//  }
//
//  for (int i = 0; i < pool.size(); i++)
//      pool[i].join();
//
//
//  pool.clear();
//
//  // this parse generates external connections
//  for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
//
//      pool.push_back(move(std::thread([&, netId]() {
//
//          for (std::list<ConnectConfig>::iterator connIt = externalConnectLists[netId].begin(); connIt != externalConnectLists[netId].end(); connIt++) {
//              switch (connIt->type) {
//              case CONN_RANDOM:
//                  //connectRandomMT(netId, connIt, true);
//                  connectRandom(netId, connIt, true);
//                  break;
//              case CONN_FULL:
//                  connectFull(netId, connIt, true);
//                  break;
//              case CONN_FULL_NO_DIRECT:
//                  connectFull(netId, connIt, true);
//                  break;
//              case CONN_ONE_TO_ONE:
//                  connectOneToOne(netId, connIt, true);
//                  break;
//              case CONN_GAUSSIAN:
//                  connectGaussian(netId, connIt, true);
//                  break;
//              case CONN_USER_DEFINED:
//                  connectUserDefined(netId, connIt, true);
//                  break;
//              default:
//                  KERNEL_ERROR("Invalid connection type( should be 'random', 'full', 'full-no-direct', or 'one-to-one')");
//                  exitSimulation(-1);
//              }
//          }
//
//      })));
//  }
//
//  for (int i = 0; i < pool.size(); i++)
//      pool[i].join();
//}
//

#ifdef LN_SETUP_NETWORK_MT
//featFastSetup LN20201108
// 100% util but does not work correct
void SNN::connectNetworkMT() {
    // this parse generates local connections

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) { 
        for (std::list<ConnectConfig>::iterator connIt = localConnectLists[netId].begin(); connIt != localConnectLists[netId].end(); connIt++) {
            switch (connIt->type) {
            case CONN_RANDOM:
                connectRandomMT(netId, connIt, false); // does not work correctly
                break;
            case CONN_FULL:
                connectFull(netId, connIt, false);
                break;
            case CONN_FULL_NO_DIRECT:
                connectFull(netId, connIt, false);
                break;
            case CONN_ONE_TO_ONE:
                connectOneToOne(netId, connIt, false);
                break;
            case CONN_GAUSSIAN:
                connectGaussian(netId, connIt, false);
                break;
            case CONN_USER_DEFINED:
                connectUserDefined(netId, connIt, false);
                break;
            default:
                KERNEL_ERROR("Invalid connection type( should be 'random', 'full', 'full-no-direct', or 'one-to-one')");
                exitSimulation(-1);
            }
        }
    }

    // this parse generates external connections
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        for (std::list<ConnectConfig>::iterator connIt = externalConnectLists[netId].begin(); connIt != externalConnectLists[netId].end(); connIt++) {
            switch (connIt->type) {
            case CONN_RANDOM:
                connectRandomMT(netId, connIt, true); // does not work correctly
                break;
            case CONN_FULL:
                connectFull(netId, connIt, true);
                break;
            case CONN_FULL_NO_DIRECT:
                connectFull(netId, connIt, true);
                break;
            case CONN_ONE_TO_ONE:
                connectOneToOne(netId, connIt, true);
                break;
            case CONN_GAUSSIAN:
                connectGaussian(netId, connIt, true);
                break;
            case CONN_USER_DEFINED:
                connectUserDefined(netId, connIt, true);
                break;
            default:
                KERNEL_ERROR("Invalid connection type( should be 'random', 'full', 'full-no-direct', or 'one-to-one')");
                exitSimulation(-1);
            }
        }
    }

}
#endif 

inline void SNN::connectNeurons(int netId, int _grpSrc, int _grpDest, int _nSrc, int _nDest, short int _connId, int externalNetId) {
    //assert(destN <= CONN_SYN_NEURON_MASK); // total number of neurons is less than 1 million within a GPU
    ConnectionInfo connInfo;
    connInfo.grpSrc = _grpSrc;
    connInfo.grpDest = _grpDest;
    connInfo.nSrc = _nSrc;
    connInfo.nDest = _nDest;
    connInfo.srcGLoffset = 0;
    connInfo.connId = _connId;
    connInfo.preSynId = -1;
    connInfo.initWt = 0.0f;
    connInfo.maxWt = 0.0f;
    connInfo.delay = 0;

    // generate the delay vaule
    connInfo.delay = connectConfigMap[_connId].minDelay + rand() % (connectConfigMap[_connId].maxDelay - connectConfigMap[_connId].minDelay + 1);
    assert((connInfo.delay >= connectConfigMap[_connId].minDelay) && (connInfo.delay <= connectConfigMap[_connId].maxDelay));
    // generate the max weight and initial weight
    //float initWt = generateWeight(connectConfigMap[it->connId].connProp, connectConfigMap[it->connId].initWt, connectConfigMap[it->connId].maxWt, it->nSrc, it->grpSrc);
    float initWt = connectConfigMap[_connId].initWt;
    float maxWt = connectConfigMap[_connId].maxWt;
    // adjust sign of weight based on pre-group (negative if pre is inhibitory)
    // this access is fine, isExcitatoryGroup() use global grpId
    connInfo.maxWt = isExcitatoryGroup(_grpSrc) ? fabs(maxWt) : -1.0 * fabs(maxWt);
    connInfo.initWt = isExcitatoryGroup(_grpSrc) ? fabs(initWt) : -1.0 * fabs(initWt);

    connectionLists[netId].push_back(connInfo);

    // If the connection is external, copy the connection info to the external network
    if (externalNetId >= 0)
        connectionLists[externalNetId].push_back(connInfo);
}

#ifdef LN_SETUP_NETWORK_MT
inline void SNN::connectNeuronsMT(std::mutex &mtx, int netId, int _grpSrc, int _grpDest, int _nSrc, int _nDest, short int _connId, int externalNetId) {
    //assert(destN <= CONN_SYN_NEURON_MASK); // total number of neurons is less than 1 million within a GPU
    ConnectionInfo connInfo;
    connInfo.grpSrc = _grpSrc;
    connInfo.grpDest = _grpDest;
    connInfo.nSrc = _nSrc;
    connInfo.nDest = _nDest;
    connInfo.srcGLoffset = 0;
    connInfo.connId = _connId;
    connInfo.preSynId = -1;
    connInfo.initWt = 0.0f;
    connInfo.maxWt = 0.0f;
    connInfo.delay = 0;

    // generate the delay vaule
    connInfo.delay = connectConfigMap[_connId].minDelay + rand() % (connectConfigMap[_connId].maxDelay - connectConfigMap[_connId].minDelay + 1);
    assert((connInfo.delay >= connectConfigMap[_connId].minDelay) && (connInfo.delay <= connectConfigMap[_connId].maxDelay));
    // generate the max weight and initial weight
    //float initWt = generateWeight(connectConfigMap[it->connId].connProp, connectConfigMap[it->connId].initWt, connectConfigMap[it->connId].maxWt, it->nSrc, it->grpSrc);
    float initWt = connectConfigMap[_connId].initWt;
    float maxWt = connectConfigMap[_connId].maxWt;
    // adjust sign of weight based on pre-group (negative if pre is inhibitory)
    // this access is fine, isExcitatoryGroup() use global grpId
    connInfo.maxWt = isExcitatoryGroup(_grpSrc) ? fabs(maxWt) : -1.0 * fabs(maxWt);
    connInfo.initWt = isExcitatoryGroup(_grpSrc) ? fabs(initWt) : -1.0 * fabs(initWt);

    // 
    /*
    mutex works but slows down with 100% util
    partitionSNNMT: 206.8s
    generateRuntimeSNN: 191.5s

    without: 
    24s
    Assertion failed: parsedConnections == networkConfigs[netId].numPostSynNet && parsedConnections == networkConfigs[netId].numPreSynNet, file src\snn_manager.cpp, line 3385

    */
    //std::lock_guard<std::mutex> guard(mtx);  

    connectionLists[netId].push_back(connInfo);
    
    // If the connection is external, copy the connection info to the external network
    if (externalNetId >= 0)
        connectionLists[externalNetId].push_back(connInfo);
}
#endif


inline void SNN::connectNeurons(int netId, int _grpSrc, int _grpDest, int _nSrc, int _nDest, short int _connId, float initWt, float maxWt, uint8_t delay, int externalNetId) {
    //assert(destN <= CONN_SYN_NEURON_MASK); // total number of neurons is less than 1 million within a GPU
    ConnectionInfo connInfo;
    connInfo.grpSrc = _grpSrc;
    connInfo.grpDest = _grpDest;
    connInfo.nSrc = _nSrc;
    connInfo.nDest = _nDest;
    connInfo.srcGLoffset = 0;
    connInfo.connId = _connId;
    connInfo.preSynId = -1;
    // adjust the sign of the weight based on inh/exc connection
    connInfo.initWt = isExcitatoryGroup(_grpSrc) ? fabs(initWt) : -1.0*fabs(initWt);
    connInfo.maxWt = isExcitatoryGroup(_grpSrc) ? fabs(maxWt) : -1.0*fabs(maxWt);
    connInfo.delay = delay;

    connectionLists[netId].push_back(connInfo);

    // If the connection is external, copy the connection info to the external network
    if (externalNetId >= 0)
        connectionLists[externalNetId].push_back(connInfo);
}

// make 'C' full connections from grpSrc to grpDest
void SNN::connectFull(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal) {
    int grpSrc = connIt->grpSrc;
    int grpDest = connIt->grpDest;
    bool noDirect = (connIt->type == CONN_FULL_NO_DIRECT);
    int externalNetId = -1;

    if (isExternal) {
        externalNetId = groupConfigMDMap[grpDest].netId;
        assert(netId != externalNetId);
    }

    int gPreStart = groupConfigMDMap[grpSrc].gStartN;
    for(int gPreN = groupConfigMDMap[grpSrc].gStartN; gPreN <= groupConfigMDMap[grpSrc].gEndN; gPreN++)  {
        Point3D locPre = getNeuronLocation3D(grpSrc, gPreN - gPreStart); // 3D coordinates of i
        int gPostStart = groupConfigMDMap[grpDest].gStartN;
        for(int gPostN = groupConfigMDMap[grpDest].gStartN; gPostN <= groupConfigMDMap[grpDest].gEndN; gPostN++) { // j: the temp neuron id
            // if flag is set, don't connect direct connections
            if(noDirect && gPreN == gPostN)
                continue;

            // check whether pre-neuron location is in RF of post-neuron
            Point3D locPost = getNeuronLocation3D(grpDest, gPostN - gPostStart); // 3D coordinates of j
            if (!isPoint3DinRF(connIt->connRadius, locPre, locPost))
                continue;

            connectNeurons(netId, grpSrc, grpDest, gPreN, gPostN, connIt->connId, externalNetId);
            connIt->numberOfConnections++;
        }
    }

    std::list<GroupConfigMD>::iterator grpIt;
    GroupConfigMD targetGrp;

    // update numPostSynapses and numPreSynapses of groups in the local network
    targetGrp.gGrpId = grpSrc; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPostSynapses += connIt->numberOfConnections;

    targetGrp.gGrpId = grpDest; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPreSynapses += connIt->numberOfConnections;

    // also update numPostSynapses and numPreSynapses of groups in the external network if the connection is external
    if (isExternal) {
        targetGrp.gGrpId = grpSrc; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPostSynapses += connIt->numberOfConnections;

        targetGrp.gGrpId = grpDest; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPreSynapses += connIt->numberOfConnections;
    }
}

void SNN::connectGaussian(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal) {
    // in case pre and post have different Grid3D sizes: scale pre to the grid size of post
    int grpSrc = connIt->grpSrc;
    int grpDest = connIt->grpDest;
    Grid3D grid_i = getGroupGrid3D(grpSrc);
    Grid3D grid_j = getGroupGrid3D(grpDest);
    Point3D scalePre = Point3D(grid_j.numX, grid_j.numY, grid_j.numZ) / Point3D(grid_i.numX, grid_i.numY, grid_i.numZ);
    int externalNetId = -1;

    if (isExternal) {
        externalNetId = groupConfigMDMap[grpDest].netId;
        assert(netId != externalNetId);
    }

    for(int i = groupConfigMDMap[grpSrc].gStartN; i <= groupConfigMDMap[grpSrc].gEndN; i++)  {
        Point3D loc_i = getNeuronLocation3D(i)*scalePre; // i: adjusted 3D coordinates

        for(int j = groupConfigMDMap[grpDest].gStartN; j <= groupConfigMDMap[grpDest].gEndN; j++) { // j: the temp neuron id
            // check whether pre-neuron location is in RF of post-neuron
            Point3D loc_j = getNeuronLocation3D(j); // 3D coordinates of j

            // make sure point is in RF
            double rfDist = getRFDist3D(connIt->connRadius,loc_i,loc_j);
            if (rfDist < 0.0 || rfDist > 1.0)
                continue;

            // if rfDist is valid, it returns a number between 0 and 1
            // we want these numbers to fit to Gaussian weigths, so that rfDist=0 corresponds to max Gaussian weight
            // and rfDist=1 corresponds to 0.1 times max Gaussian weight
            // so we're looking at gauss = exp(-a*rfDist), where a such that exp(-a)=0.1
            // solving for a, we find that a = 2.3026
            double gauss = exp(-2.3026*rfDist);
            if (gauss < 0.1)
                continue;

            if (drand48() < connIt->connProbability) {
                float initWt = gauss * connIt->initWt; // scale weight according to gauss distance
                float maxWt = connIt->maxWt;
                uint8_t delay = connIt->minDelay + rand() % (connIt->maxDelay - connIt->minDelay + 1);
                assert((delay >= connIt->minDelay) && (delay <= connIt->maxDelay));

                connectNeurons(netId, grpSrc, grpDest, i, j, connIt->connId, initWt, maxWt, delay, externalNetId);
                connIt->numberOfConnections++;
            }
        }
    }

    std::list<GroupConfigMD>::iterator grpIt;
    GroupConfigMD targetGrp;

    // update numPostSynapses and numPreSynapses of groups in the local network
    targetGrp.gGrpId = grpSrc; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPostSynapses += connIt->numberOfConnections;

    targetGrp.gGrpId = grpDest; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPreSynapses += connIt->numberOfConnections;

    // also update numPostSynapses and numPreSynapses of groups in the external network if the connection is external
    if (isExternal) {
        targetGrp.gGrpId = grpSrc; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPostSynapses += connIt->numberOfConnections;

        targetGrp.gGrpId = grpDest; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPreSynapses += connIt->numberOfConnections;
    }
}

void SNN::connectOneToOne(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal) {
    int grpSrc = connIt->grpSrc;
    int grpDest = connIt->grpDest;
    int externalNetId = -1;

    if (isExternal) {
        externalNetId = groupConfigMDMap[grpDest].netId;
        assert(netId != externalNetId);
    }

    assert( groupConfigMap[grpDest].numN == groupConfigMap[grpSrc].numN);

    // NOTE: RadiusRF does not make a difference here: ignore
    for(int gPreN = groupConfigMDMap[grpSrc].gStartN, gPostN = groupConfigMDMap[grpDest].gStartN; gPreN <= groupConfigMDMap[grpSrc].gEndN; gPreN++, gPostN++)  {
        connectNeurons(netId, grpSrc, grpDest, gPreN, gPostN, connIt->connId, externalNetId);
        connIt->numberOfConnections++;
    }

    std::list<GroupConfigMD>::iterator grpIt;
    GroupConfigMD targetGrp;

    // update numPostSynapses and numPreSynapses of groups in the local network
    targetGrp.gGrpId = grpSrc; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPostSynapses += connIt->numberOfConnections;

    targetGrp.gGrpId = grpDest; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPreSynapses += connIt->numberOfConnections;

    // also update numPostSynapses and numPreSynapses of groups in the external network if the connection is external
    if (isExternal) {
        targetGrp.gGrpId = grpSrc; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPostSynapses += connIt->numberOfConnections;

        targetGrp.gGrpId = grpDest; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPreSynapses += connIt->numberOfConnections;
    }
}

// make 'C' random connections from grpSrc to grpDest
void SNN::connectRandom(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal) {
    int grpSrc = connIt->grpSrc;
    int grpDest = connIt->grpDest;
    int externalNetId = -1;

    if (isExternal) {
        externalNetId = groupConfigMDMap[grpDest].netId;
        assert(netId != externalNetId);
    }

    int gPreStart = groupConfigMDMap[grpSrc].gStartN;
    for(int gPreN = groupConfigMDMap[grpSrc].gStartN; gPreN <= groupConfigMDMap[grpSrc].gEndN; gPreN++) {
        Point3D locPre = getNeuronLocation3D(grpSrc, gPreN - gPreStart); // 3D coordinates of i
        int gPostStart = groupConfigMDMap[grpDest].gStartN;
        for(int gPostN = groupConfigMDMap[grpDest].gStartN; gPostN <= groupConfigMDMap[grpDest].gEndN; gPostN++) {
            // check whether pre-neuron location is in RF of post-neuron
            Point3D locPost = getNeuronLocation3D(grpDest, gPostN - gPostStart); // 3D coordinates of j
            if (!isPoint3DinRF(connIt->connRadius, locPre, locPost))
                continue;

            if (drand48() < connIt->connProbability) {
                connectNeurons(netId, grpSrc, grpDest, gPreN, gPostN, connIt->connId, externalNetId);
                connIt->numberOfConnections++;
            }
        }
    }

    std::list<GroupConfigMD>::iterator grpIt;
    GroupConfigMD targetGrp;

    // update numPostSynapses and numPreSynapses of groups in the local network
    targetGrp.gGrpId = grpSrc; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPostSynapses += connIt->numberOfConnections;

    targetGrp.gGrpId = grpDest; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPreSynapses += connIt->numberOfConnections;

    // also update numPostSynapses and numPreSynapses of groups in the external network if the connection is external
    if (isExternal) {
        targetGrp.gGrpId = grpSrc; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPostSynapses += connIt->numberOfConnections;

        targetGrp.gGrpId = grpDest; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPreSynapses += connIt->numberOfConnections;
    }
}

#ifdef LN_SETUP_NETWORK_MT
#include <thread>
#include <atomic>
#include <mutex>
//#define DEBUG_connectRandomMT_SEQ
// make 'C' random connections from grpSrc to grpDest
/* fast but not correct:
partitionSNNMT: 14.7s
Assertion failed: parsedConnections == networkConfigs[netId].numPostSynNet && parsedConnections == networkConfigs[netId].numPreSynNet, file src\snn_manager.cpp, line 3385
*/
void SNN::connectRandomMT(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal) {
    int grpSrc = connIt->grpSrc;
    int grpDest = connIt->grpDest;
    int externalNetId = -1;

    if (isExternal) {
        externalNetId = groupConfigMDMap[grpDest].netId;
        assert(netId != externalNetId);
    }

    int gPreStart = groupConfigMDMap[grpSrc].gStartN;

#ifdef DEBUG_connectRandomMT_SEQ


    for (int gPreN = groupConfigMDMap[grpSrc].gStartN; gPreN <= groupConfigMDMap[grpSrc].gEndN; gPreN++) {
        Point3D locPre = getNeuronLocation3D(grpSrc, gPreN - gPreStart); // 3D coordinates of i
        int gPostStart = groupConfigMDMap[grpDest].gStartN;
// 7.5s
        for (int gPostN = groupConfigMDMap[grpDest].gStartN; gPostN <= groupConfigMDMap[grpDest].gEndN; gPostN++) {
            // check whether pre-neuron location is in RF of post-neuron
            Point3D locPost = getNeuronLocation3D(grpDest, gPostN - gPostStart); // 3D coordinates of j
            if (!isPoint3DinRF(connIt->connRadius, locPre, locPost))
                continue;
// 32.5s
            if (drand48() < connIt->connProbability) {
                connectNeurons(netId, grpSrc, grpDest, gPreN, gPostN, connIt->connId, externalNetId);
                connIt->numberOfConnections++;
            }
// 75.7
        }

    }

#else 

    std::atomic_int numberOfConnections = connIt->numberOfConnections; 
    std::mutex mtx;           // mutex for critical section

    auto worker = [&, netId, externalNetId, grpSrc, grpDest, gPreStart]
            (int gPreN, RadiusRF &connRadius, float connProbability, int connId) {

        Point3D locPre = getNeuronLocation3D(grpSrc, gPreN - gPreStart); // 3D coordinates of i
        int gPostStart = groupConfigMDMap[grpDest].gStartN;
        for (int gPostN = groupConfigMDMap[grpDest].gStartN; gPostN <= groupConfigMDMap[grpDest].gEndN; gPostN++) {
            // check whether pre-neuron location is in RF of post-neuron
            Point3D locPost = getNeuronLocation3D(grpDest, gPostN - gPostStart); // 3D coordinates of j
            if (!isPoint3DinRF(connRadius, locPre, locPost))
                continue;
            
            //double r = drand48();  //  bingo drand48 -> rand is not thread safe!
            //srand::
            //double r = (double)(srand() / RAND_MAX); 
            // https://stackoverflow.com/questions/6161322/using-stdlibs-rand-from-multiple-threads
            //double r = drand48_r(); 
            double r = gPostN % 10; 
            if (r < connProbability) {          
                //std::lock_guard<std::mutex> guard(mtx);
                connectNeuronsMT(mtx, netId, grpSrc, grpDest, gPreN, gPostN, connId, externalNetId);  // ISSUE order dependent?
                numberOfConnections++;
            }
        }
        
    };

    //std::vector<std::thread> pool(groupConfigMDMap[grpSrc].gEndN - groupConfigMDMap[grpSrc].gStartN + 1);
    std::vector<std::thread> pool;

    for (int gPreN = groupConfigMDMap[grpSrc].gStartN; gPreN <= groupConfigMDMap[grpSrc].gEndN; gPreN++) 
        pool.push_back(move(std::thread(worker, gPreN, 
            connIt->connRadius,
            connIt->connProbability,
            connIt->connId)));

    for (int i = 0; i < pool.size(); i++)
        pool[i].join(); 

    connIt->numberOfConnections = numberOfConnections;

#endif

    printf("connectRandomMT connIt->connId: %d, ->numberOfConnections: %-10d\n", connIt->connId, connIt->numberOfConnections);

    std::list<GroupConfigMD>::iterator grpIt;
    GroupConfigMD targetGrp;

    // update numPostSynapses and numPreSynapses of groups in the local network
    targetGrp.gGrpId = grpSrc; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPostSynapses += connIt->numberOfConnections;

    targetGrp.gGrpId = grpDest; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPreSynapses += connIt->numberOfConnections;


    // also update numPostSynapses and numPreSynapses of groups in the external network if the connection is external
    if (isExternal) {
        targetGrp.gGrpId = grpSrc; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPostSynapses += connIt->numberOfConnections;

        targetGrp.gGrpId = grpDest; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPreSynapses += connIt->numberOfConnections;
    }


}
#endif

// FIXME: rewrite user-define call-back function
// user-defined functions called here...
// This is where we define our user-defined call-back function.  -- KDC
void SNN::connectUserDefined(int netId, std::list<ConnectConfig>::iterator connIt, bool isExternal) {
    int grpSrc = connIt->grpSrc;
    int grpDest = connIt->grpDest;
    int externalNetId = -1;

    if (isExternal) {
        externalNetId = groupConfigMDMap[grpDest].netId;
        assert(netId != externalNetId);
    }

    connIt->maxDelay = 0;
    int preStartN = groupConfigMDMap[grpSrc].gStartN;
    int postStartN = groupConfigMDMap[grpDest].gStartN;
    for (int pre_nid = groupConfigMDMap[grpSrc].gStartN; pre_nid <= groupConfigMDMap[grpSrc].gEndN; pre_nid++) {
        //Point3D loc_pre = getNeuronLocation3D(pre_nid); // 3D coordinates of i
        for (int post_nid = groupConfigMDMap[grpDest].gStartN; post_nid <= groupConfigMDMap[grpDest].gEndN; post_nid++) {
            float weight, maxWt, delay;
            bool connected;

            connIt->conn->connect(this, grpSrc, pre_nid - preStartN, grpDest, post_nid - postStartN, weight, maxWt, delay, connected);
            if (connected) {
                assert(delay >= 1);
                assert(delay <= MAX_SYN_DELAY);
                assert(abs(weight) <= abs(maxWt));

                if (GET_FIXED_PLASTIC(connIt->connProp) == SYN_FIXED)
                    maxWt = weight;

                if (fabs(maxWt) > connIt->maxWt)
                    connIt->maxWt = fabs(maxWt);

                if (delay > connIt->maxDelay)
                    connIt->maxDelay = delay;

                connectNeurons(netId, grpSrc, grpDest, pre_nid, post_nid, connIt->connId, weight, maxWt, delay, externalNetId);
                connIt->numberOfConnections++;
            }
        }
    }

    std::list<GroupConfigMD>::iterator grpIt;
    GroupConfigMD targetGrp;

    // update numPostSynapses and numPreSynapses of groups in the local network
    targetGrp.gGrpId = grpSrc; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPostSynapses += connIt->numberOfConnections;

    targetGrp.gGrpId = grpDest; // the other fields does not matter
    grpIt = std::find(groupPartitionLists[netId].begin(), groupPartitionLists[netId].end(), targetGrp);
    assert(grpIt != groupPartitionLists[netId].end());
    grpIt->numPreSynapses += connIt->numberOfConnections;

    // also update numPostSynapses and numPreSynapses of groups in the external network if the connection is external
    if (isExternal) {
        targetGrp.gGrpId = grpSrc; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPostSynapses += connIt->numberOfConnections;

        targetGrp.gGrpId = grpDest; // the other fields does not matter
        grpIt = std::find(groupPartitionLists[externalNetId].begin(), groupPartitionLists[externalNetId].end(), targetGrp);
        assert(grpIt != groupPartitionLists[externalNetId].end());
        grpIt->numPreSynapses += connIt->numberOfConnections;
    }
}

//void SNN::connectFull(short int connId) {
//  int grpSrc = connectConfigMap[connId].grpSrc;
//  int grpDest = connectConfigMap[connId].grpDest;
//  bool noDirect = (connectConfigMap[connId].type == CONN_FULL_NO_DIRECT);
//
//  // rebuild struct for easier handling
//  RadiusRF radius(connectConfigMap[connId].radX, connectConfigMap[connId].radY, connectConfigMap[connId].radZ);
//
//  for(int i = groupConfigMap[grpSrc].StartN; i <= groupConfigMap[grpSrc].EndN; i++)  {
//      Point3D loc_i = getNeuronLocation3D(i); // 3D coordinates of i
//      for(int j = groupConfigMap[grpDest].StartN; j <= groupConfigMap[grpDest].EndN; j++) { // j: the temp neuron id
//          // if flag is set, don't connect direct connections
//          if((noDirect) && (i - groupConfigMap[grpSrc].StartN) == (j - groupConfigMap[grpDest].StartN))
//              continue;
//
//          // check whether pre-neuron location is in RF of post-neuron
//          Point3D loc_j = getNeuronLocation3D(j); // 3D coordinates of j
//          if (!isPoint3DinRF(radius, loc_i, loc_j))
//              continue;
//
//          //uint8_t dVal = info->minDelay + (int)(0.5 + (drand48() * (info->maxDelay - info->minDelay)));
//          uint8_t dVal = connectConfigMap[connId].minDelay + rand() % (connectConfigMap[connId].maxDelay - connectConfigMap[connId].minDelay + 1);
//          assert((dVal >= connectConfigMap[connId].minDelay) && (dVal <= connectConfigMap[connId].maxDelay));
//          float synWt = generateWeight(connectConfigMap[connId].connProp, connectConfigMap[connId].initWt, connectConfigMap[connId].maxWt, i, grpSrc);
//
//          setConnection(grpSrc, grpDest, i, j, synWt, connectConfigMap[connId].maxWt, dVal, connectConfigMap[connId].connProp, connId);// info->connId);
//          connectConfigMap[connId].numberOfConnections++;
//      }
//  }
//
//  groupInfo[grpSrc].sumPostConn += connectConfigMap[connId].numberOfConnections;
//  groupInfo[grpDest].sumPreConn += connectConfigMap[connId].numberOfConnections;
//}

//void SNN::connectGaussian(short int connId) {
//  // rebuild struct for easier handling
//  // adjust with sqrt(2) in order to make the Gaussian kernel depend on 2*sigma^2
//  RadiusRF radius(connectConfigMap[connId].radX, connectConfigMap[connId].radY, connectConfigMap[connId].radZ);
//
//  // in case pre and post have different Grid3D sizes: scale pre to the grid size of post
//  int grpSrc = connectConfigMap[connId].grpSrc;
//  int grpDest = connectConfigMap[connId].grpDest;
//  Grid3D grid_i = getGroupGrid3D(grpSrc);
//  Grid3D grid_j = getGroupGrid3D(grpDest);
//  Point3D scalePre = Point3D(grid_j.numX, grid_j.numY, grid_j.numZ) / Point3D(grid_i.numX, grid_i.numY, grid_i.numZ);
//
//  for(int i = groupConfigMap[grpSrc].StartN; i <= groupConfigMap[grpSrc].EndN; i++)  {
//      Point3D loc_i = getNeuronLocation3D(i)*scalePre; // i: adjusted 3D coordinates
//
//      for(int j = groupConfigMap[grpDest].StartN; j <= groupConfigMap[grpDest].EndN; j++) { // j: the temp neuron id
//          // check whether pre-neuron location is in RF of post-neuron
//          Point3D loc_j = getNeuronLocation3D(j); // 3D coordinates of j
//
//          // make sure point is in RF
//          double rfDist = getRFDist3D(radius,loc_i,loc_j);
//          if (rfDist < 0.0 || rfDist > 1.0)
//              continue;
//
//          // if rfDist is valid, it returns a number between 0 and 1
//          // we want these numbers to fit to Gaussian weigths, so that rfDist=0 corresponds to max Gaussian weight
//          // and rfDist=1 corresponds to 0.1 times max Gaussian weight
//          // so we're looking at gauss = exp(-a*rfDist), where a such that exp(-a)=0.1
//          // solving for a, we find that a = 2.3026
//          double gauss = exp(-2.3026*rfDist);
//          if (gauss < 0.1)
//              continue;
//
//          if (drand48() < connectConfigMap[connId].p) {
//              uint8_t dVal = connectConfigMap[connId].minDelay + rand() % (connectConfigMap[connId].maxDelay - connectConfigMap[connId].minDelay + 1);
//              assert((dVal >= connectConfigMap[connId].minDelay) && (dVal <= connectConfigMap[connId].maxDelay));
//              float synWt = gauss * connectConfigMap[connId].initWt; // scale weight according to gauss distance
//              setConnection(grpSrc, grpDest, i, j, synWt, connectConfigMap[connId].maxWt, dVal, connectConfigMap[connId].connProp, connId);//info->connId);
//              connectConfigMap[connId].numberOfConnections++;
//          }
//      }
//  }
//
//  groupInfo[grpSrc].sumPostConn += connectConfigMap[connId].numberOfConnections;
//  groupInfo[grpDest].sumPreConn += connectConfigMap[connId].numberOfConnections;
//}
//
//void SNN::connectOneToOne(short int connId) {
//  int grpSrc = connectConfigMap[connId].grpSrc;
//  int grpDest = connectConfigMap[connId].grpDest;
//  assert( groupConfigMap[grpDest].SizeN == groupConfigMap[grpSrc].SizeN );
//
//  // NOTE: RadiusRF does not make a difference here: ignore
//  for(int nid=groupConfigMap[grpSrc].StartN,j=groupConfigMap[grpDest].StartN; nid<=groupConfigMap[grpSrc].EndN; nid++, j++)  {
//      uint8_t dVal = connectConfigMap[connId].minDelay + rand() % (connectConfigMap[connId].maxDelay - connectConfigMap[connId].minDelay + 1);
//      assert((dVal >= connectConfigMap[connId].minDelay) && (dVal <= connectConfigMap[connId].maxDelay));
//      float synWt = generateWeight(connectConfigMap[connId].connProp, connectConfigMap[connId].initWt, connectConfigMap[connId].maxWt, nid, grpSrc);
//      setConnection(grpSrc, grpDest, nid, j, synWt, connectConfigMap[connId].maxWt, dVal, connectConfigMap[connId].connProp, connId);//info->connId);
//      connectConfigMap[connId].numberOfConnections++;
//  }
//
//  groupInfo[grpSrc].sumPostConn += connectConfigMap[connId].numberOfConnections;
//  groupInfo[grpDest].sumPreConn += connectConfigMap[connId].numberOfConnections;
//}
//
//void SNN::connectRandom(short int connId) {
//  int grpSrc = connectConfigMap[connId].grpSrc;
//  int grpDest = connectConfigMap[connId].grpDest;
//
//  // rebuild struct for easier handling
//  RadiusRF radius(connectConfigMap[connId].radX, connectConfigMap[connId].radY, connectConfigMap[connId].radZ);
//
//  for(int pre_nid = groupConfigMap[grpSrc].StartN; pre_nid <= groupConfigMap[grpSrc].EndN; pre_nid++) {
//      Point3D loc_pre = getNeuronLocation3D(pre_nid); // 3D coordinates of i
//      for(int post_nid = groupConfigMap[grpDest].StartN; post_nid <= groupConfigMap[grpDest].EndN; post_nid++) {
//          // check whether pre-neuron location is in RF of post-neuron
//          Point3D loc_post = getNeuronLocation3D(post_nid); // 3D coordinates of j
//          if (!isPoint3DinRF(radius, loc_pre, loc_post))
//              continue;
//
//          if (drand48() < connectConfigMap[connId].p) {
//              //uint8_t dVal = info->minDelay + (int)(0.5+(drand48()*(info->maxDelay-info->minDelay)));
//              uint8_t dVal = connectConfigMap[connId].minDelay + rand() % (connectConfigMap[connId].maxDelay - connectConfigMap[connId].minDelay + 1);
//              assert((dVal >= connectConfigMap[connId].minDelay) && (dVal <= connectConfigMap[connId].maxDelay));
//              float synWt = generateWeight(connectConfigMap[connId].connProp, connectConfigMap[connId].initWt, connectConfigMap[connId].maxWt, pre_nid, grpSrc);
//              setConnection(grpSrc, grpDest, pre_nid, post_nid, synWt, connectConfigMap[connId].maxWt, dVal, connectConfigMap[connId].connProp, connId); //info->connId);
//              connectConfigMap[connId].numberOfConnections++;
//          }
//      }
//  }
//
//  groupInfo[grpSrc].sumPostConn += connectConfigMap[connId].numberOfConnections;
//  groupInfo[grpDest].sumPreConn += connectConfigMap[connId].numberOfConnections;
//}
//
//void SNN::connectUserDefined(short int connId) {
//  int grpSrc = connectConfigMap[connId].grpSrc;
//  int grpDest = connectConfigMap[connId].grpDest;
//  connectConfigMap[connId].maxDelay = 0;
//  for(int nid=groupConfigMap[grpSrc].StartN; nid<=groupConfigMap[grpSrc].EndN; nid++) {
//      for(int nid2=groupConfigMap[grpDest].StartN; nid2 <= groupConfigMap[grpDest].EndN; nid2++) {
//          int srcId  = nid  - groupConfigMap[grpSrc].StartN;
//          int destId = nid2 - groupConfigMap[grpDest].StartN;
//          float weight, maxWt, delay;
//          bool connected;
//
//          connectConfigMap[connId].conn->connect(this, grpSrc, srcId, grpDest, destId, weight, maxWt, delay, connected);
//          if(connected)  {
//              if (GET_FIXED_PLASTIC(connectConfigMap[connId].connProp) == SYN_FIXED)
//                  maxWt = weight;
//
//              connectConfigMap[connId].maxWt = maxWt;
//
//              assert(delay >= 1);
//              assert(delay <= MAX_SYN_DELAY);
//              assert(abs(weight) <= abs(maxWt));
//
//              // adjust the sign of the weight based on inh/exc connection
//              weight = isExcitatoryGroup(grpSrc) ? fabs(weight) : -1.0*fabs(weight);
//              maxWt  = isExcitatoryGroup(grpSrc) ? fabs(maxWt)  : -1.0*fabs(maxWt);
//
//              setConnection(grpSrc, grpDest, nid, nid2, weight, maxWt, delay, connectConfigMap[connId].connProp, connId);// info->connId);
//              connectConfigMap[connId].numberOfConnections++;
//              if(delay > connectConfigMap[connId].maxDelay) {
//                  connectConfigMap[connId].maxDelay = delay;
//              }
//          }
//      }
//  }
//
//  groupInfo[grpSrc].sumPostConn += connectConfigMap[connId].numberOfConnections;
//  groupInfo[grpDest].sumPreConn += connectConfigMap[connId].numberOfConnections;
//}

void SNN::deleteRuntimeData() {
    // FIXME: assert simulation use GPU first
    // wait for kernels to complete
#ifndef __NO_CUDA__
    CUDA_CHECK_ERRORS(cudaThreadSynchronize());
#endif

    #ifndef __NO_PTHREADS__ // POSIX
        pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
        cpu_set_t cpus;
        ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
        int threadCount = 0;
    #endif

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            if (netId < CPU_RUNTIME_BASE) // GPU runtime
                deleteRuntimeData_GPU(netId);
            else{ // CPU runtime
                #ifdef __NO_PTHREADS__
                    deleteRuntimeData_CPU(netId);
                #else // Linux or MAC
                    pthread_attr_t attr;
                    pthread_attr_init(&attr);
                    CPU_ZERO(&cpus);
                    CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                    pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                    argsThreadRoutine[threadCount].snn_pointer = this;
                    argsThreadRoutine[threadCount].netId = netId;
                    argsThreadRoutine[threadCount].lGrpId = 0;
                    argsThreadRoutine[threadCount].startIdx = 0;
                    argsThreadRoutine[threadCount].endIdx = 0;
                    argsThreadRoutine[threadCount].GtoLOffset = 0;

                    pthread_create(&threads[threadCount], &attr, &SNN::helperDeleteRuntimeData_CPU, (void*)&argsThreadRoutine[threadCount]);
                    pthread_attr_destroy(&attr);
                    threadCount++;
                #endif
            }
        }
    }

    #ifndef __NO_PTHREADS__ // POSIX
        // join all the threads
        for (int i=0; i<threadCount; i++){
            pthread_join(threads[i], NULL);
        }
    #endif

#ifndef __NO_CUDA__
    CUDA_DELETE_TIMER(timer);
#endif
}

// delete all objects (CPU and GPU side)
void SNN::deleteObjects() {
    if (simulatorDeleted)
        return;

    printSimSummary();

    // deallocate objects
    resetMonitors(true);
    resetConnectionConfigs(true);
#ifdef LN_I_CALC_TYPES
    resetGroupConfigs(true);
#endif


    // delete manager runtime data
    deleteManagerRuntimeData();

    deleteRuntimeData();

    // fclose file streams, unless in custom mode
    if (loggerMode_ != CUSTOM) {
        // don't fclose if it's stdout or stderr, otherwise they're gonna stay closed for the rest of the process
        if (fpInf_ != NULL && fpInf_ != stdout && fpInf_ != stderr)
            fclose(fpInf_);
        if (fpErr_ != NULL && fpErr_ != stdout && fpErr_ != stderr)
            fclose(fpErr_);
        if (fpDeb_ != NULL && fpDeb_ != stdout && fpDeb_ != stderr)
            fclose(fpDeb_);
        if (fpLog_ != NULL && fpLog_ != stdout && fpLog_ != stderr)
            fclose(fpLog_);
    }

    simulatorDeleted = true;
}

void SNN::findMaxNumSynapsesGroups(int* _maxNumPostSynGrp, int* _maxNumPreSynGrp) {
    *_maxNumPostSynGrp = 0;
    *_maxNumPreSynGrp = 0;

    //  scan all the groups and find the required information
    for (int gGrpId = 0; gGrpId < numGroups; gGrpId++) {
        // find the values for maximum postsynaptic length
        // and maximum pre-synaptic length
        if (groupConfigMDMap[gGrpId].numPostSynapses > *_maxNumPostSynGrp)
            *_maxNumPostSynGrp = groupConfigMDMap[gGrpId].numPostSynapses;
        if (groupConfigMDMap[gGrpId].numPreSynapses > *_maxNumPreSynGrp)
            *_maxNumPreSynGrp = groupConfigMDMap[gGrpId].numPreSynapses;
    }
}

void SNN::findMaxNumSynapsesNeurons(int _netId, int& _maxNumPostSynN, int& _maxNumPreSynN) {
    int *tempNpre, *tempNpost;
    int nSrc, nDest, numNeurons;
    std::map<int, int> globalToLocalOffset;

    numNeurons = networkConfigs[_netId].numNAssigned;
    tempNpre = new int[numNeurons];
    tempNpost = new int[numNeurons];
    memset(tempNpre, 0, sizeof(int) * numNeurons);
    memset(tempNpost, 0, sizeof(int) * numNeurons);

    // load offset between global neuron id and local neuron id
    for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[_netId].begin(); grpIt != groupPartitionLists[_netId].end(); grpIt++) {
        globalToLocalOffset[grpIt->gGrpId] = grpIt->GtoLOffset;
    }

    // calculate number of pre- and post- connections of each neuron
#ifdef LN_FIX_CONNLIST_
    for (std::vector<ConnectionInfo>::iterator connIt = connectionLists[_netId].begin(); connIt != connectionLists[_netId].end(); connIt++) {
#else
    for (std::list<ConnectionInfo>::iterator connIt = connectionLists[_netId].begin(); connIt != connectionLists[_netId].end(); connIt++) {
#endif
        nSrc = connIt->nSrc + globalToLocalOffset[connIt->grpSrc];
        nDest = connIt->nDest + globalToLocalOffset[connIt->grpDest];
        assert(nSrc < numNeurons); assert(nDest < numNeurons);
        tempNpost[nSrc]++;
        tempNpre[nDest]++;
    }

    // find out the maximum number of pre- and post- connections among neurons in a local network
    _maxNumPostSynN = 0;
    _maxNumPreSynN = 0;
    for (int nId = 0; nId < networkConfigs[_netId].numN; nId++) {
        if (tempNpost[nId] > _maxNumPostSynN) _maxNumPostSynN = tempNpost[nId];
        if (tempNpre[nId] > _maxNumPreSynN) _maxNumPreSynN = tempNpre[nId];
    }

    delete [] tempNpre;
    delete [] tempNpost;
}

void SNN::findMaxSpikesD1D2(int _netId, unsigned int& _maxSpikesD1, unsigned int& _maxSpikesD2) {
    _maxSpikesD1 = 0; _maxSpikesD2 = 0;
    for(std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[_netId].begin(); grpIt != groupPartitionLists[_netId].end(); grpIt++) {
        if (grpIt->maxOutgoingDelay == 1)
            _maxSpikesD1 += (groupConfigMap[grpIt->gGrpId].numN * NEURON_MAX_FIRING_RATE);
        else
            _maxSpikesD2 += (groupConfigMap[grpIt->gGrpId].numN * NEURON_MAX_FIRING_RATE);
    }
}

void SNN::findNumN(int _netId, int& _numN, int& _numNExternal, int& _numNAssigned,
                   int& _numNReg, int& _numNExcReg, int& _numNInhReg,
                   int& _numNPois, int& _numNExcPois, int& _numNInhPois) {
    _numN = 0; _numNExternal = 0; _numNAssigned = 0;
    _numNReg = 0; _numNExcReg = 0; _numNInhReg = 0;
    _numNPois = 0; _numNExcPois = 0; _numNInhPois = 0;
    for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[_netId].begin(); grpIt != groupPartitionLists[_netId].end(); grpIt++) {
        int sizeN = groupConfigMap[grpIt->gGrpId].numN;
        unsigned int type = groupConfigMap[grpIt->gGrpId].type;
        if (IS_EXCITATORY_TYPE(type) && (type & POISSON_NEURON) && grpIt->netId == _netId) {
            _numN += sizeN; _numNPois += sizeN; _numNExcPois += sizeN;
        } else if (IS_INHIBITORY_TYPE(type) && (type & POISSON_NEURON) && grpIt->netId == _netId) {
            _numN += sizeN; _numNPois += sizeN; _numNInhPois += sizeN;
        } else if (IS_EXCITATORY_TYPE(type) && !(type & POISSON_NEURON) && grpIt->netId == _netId) {
            _numN += sizeN; _numNReg += sizeN; _numNExcReg += sizeN;
        } else if (IS_INHIBITORY_TYPE(type) && !(type & POISSON_NEURON) && grpIt->netId == _netId) {
            _numN += sizeN; _numNReg += sizeN; _numNInhReg += sizeN;
        } else if (grpIt->netId != _netId) {
            _numNExternal += sizeN;
        } else {
            KERNEL_ERROR("Can't find catagory for the group [%d] ", grpIt->gGrpId);
            exitSimulation(KERNEL_ERROR_NO_CATAGORY);
        }
        _numNAssigned += sizeN;
    }

    assert(_numNReg == _numNExcReg + _numNInhReg);
    assert(_numNPois == _numNExcPois + _numNInhPois);
    assert(_numN == _numNReg + _numNPois);
    assert(_numNAssigned == _numN + _numNExternal);
}

void SNN::findNumNSpikeGenAndOffset(int _netId) {
    networkConfigs[_netId].numNSpikeGen = 0;

    for(int lGrpId = 0; lGrpId < networkConfigs[_netId].numGroups; lGrpId++) {
        if (_netId == groupConfigs[_netId][lGrpId].netId && groupConfigs[_netId][lGrpId].isSpikeGenerator && groupConfigs[_netId][lGrpId].isSpikeGenFunc) {
            groupConfigs[_netId][lGrpId].Noffset = networkConfigs[_netId].numNSpikeGen;
            networkConfigs[_netId].numNSpikeGen += groupConfigs[_netId][lGrpId].numN;
        }
    }

    assert(networkConfigs[_netId].numNSpikeGen <= networkConfigs[_netId].numNPois);
}

void SNN::findNumSynapsesNetwork(int _netId, int& _numPostSynNet, int& _numPreSynNet) {
    _numPostSynNet = 0;
    _numPreSynNet  = 0;

    for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[_netId].begin(); grpIt != groupPartitionLists[_netId].end(); grpIt++) {
        _numPostSynNet += grpIt->numPostSynapses;
        _numPreSynNet += grpIt->numPreSynapses;
        assert(_numPostSynNet < INT_MAX);
        assert(_numPreSynNet <  INT_MAX);
    }

    assert(_numPreSynNet == _numPostSynNet);
}

void SNN::fetchGroupState(int netId, int lGrpId) {
    if (netId < CPU_RUNTIME_BASE)
        copyGroupState(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], cudaMemcpyDeviceToHost, false);
    else
        copyGroupState(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], false);
}

void SNN::fetchWeightState(int netId, int lGrpId) {
    if (netId < CPU_RUNTIME_BASE)
        copyWeightState(netId, lGrpId, cudaMemcpyDeviceToHost);
    else
        copyWeightState(netId, lGrpId);
}

void SNN::fetchNeuronSpikeCount (int gGrpId) {
    if (gGrpId == ALL) {
        for (int gGrpId = 0; gGrpId < numGroups; gGrpId++) {
            fetchNeuronSpikeCount(gGrpId);
        }
    } else {
        int netId = groupConfigMDMap[gGrpId].netId;
        int lGrpId = groupConfigMDMap[gGrpId].lGrpId;
        int LtoGOffset = groupConfigMDMap[gGrpId].LtoGOffset;

        if (netId < CPU_RUNTIME_BASE)
            copyNeuronSpikeCount(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], cudaMemcpyDeviceToHost, false, LtoGOffset);
        else
            copyNeuronSpikeCount(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], false, LtoGOffset);
    }
}

void SNN::fetchSTPState(int gGrpId) {
}

void SNN::fetchConductanceAMPA(int gGrpId) {
    if (gGrpId == ALL) {
        for (int gGrpId = 0; gGrpId < numGroups; gGrpId++) {
            fetchConductanceAMPA(gGrpId);
        }
    } else {
        int netId = groupConfigMDMap[gGrpId].netId;
        int lGrpId = groupConfigMDMap[gGrpId].lGrpId;
        int LtoGOffset = groupConfigMDMap[gGrpId].LtoGOffset;

        if (netId < CPU_RUNTIME_BASE)
            copyConductanceAMPA(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], cudaMemcpyDeviceToHost, false, LtoGOffset);
        else
            copyConductanceAMPA(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], false, LtoGOffset);
    }
}

void SNN::fetchConductanceNMDA(int gGrpId) {
    if (gGrpId == ALL) {
        for (int gGrpId = 0; gGrpId < numGroups; gGrpId++) {
            fetchConductanceNMDA(gGrpId);
        }
    } else {
        int netId = groupConfigMDMap[gGrpId].netId;
        int lGrpId = groupConfigMDMap[gGrpId].lGrpId;
        int LtoGOffset = groupConfigMDMap[gGrpId].LtoGOffset;

        if (netId < CPU_RUNTIME_BASE)
            copyConductanceNMDA(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], cudaMemcpyDeviceToHost, false, LtoGOffset);
        else
            copyConductanceNMDA(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], false, LtoGOffset);
    }
}

void SNN::fetchConductanceGABAa(int gGrpId) {
    if (gGrpId == ALL) {
        for (int gGrpId = 0; gGrpId < numGroups; gGrpId++) {
            fetchConductanceGABAa(gGrpId);
        }
    } else {
        int netId = groupConfigMDMap[gGrpId].netId;
        int lGrpId = groupConfigMDMap[gGrpId].lGrpId;
        int LtoGOffset = groupConfigMDMap[gGrpId].LtoGOffset;

        if (netId < CPU_RUNTIME_BASE)
            copyConductanceGABAa(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], cudaMemcpyDeviceToHost, false, LtoGOffset);
        else
            copyConductanceGABAa(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], false, LtoGOffset);
    }
}

void SNN::fetchConductanceGABAb(int gGrpId) {
    if (gGrpId == ALL) {
        for (int gGrpId = 0; gGrpId < numGroups; gGrpId++) {
            fetchConductanceGABAb(gGrpId);
        }
    } else {
        int netId = groupConfigMDMap[gGrpId].netId;
        int lGrpId = groupConfigMDMap[gGrpId].lGrpId;
        int LtoGOffset = groupConfigMDMap[gGrpId].LtoGOffset;

        if (netId < CPU_RUNTIME_BASE)
            copyConductanceGABAb(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], cudaMemcpyDeviceToHost, false, LtoGOffset);
        else
            copyConductanceGABAb(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], false, LtoGOffset);
    }
}


void SNN::fetchGrpIdsLookupArray(int netId) {
    if (netId < CPU_RUNTIME_BASE)
        copyGrpIdsLookupArray(netId, cudaMemcpyDeviceToHost);
    else
        copyGrpIdsLookupArray(netId);
}

void SNN::fetchConnIdsLookupArray(int netId) {
    if (netId < CPU_RUNTIME_BASE)
        copyConnIdsLookupArray(netId, cudaMemcpyDeviceToHost);
    else
        copyConnIdsLookupArray(netId);
}

void SNN::fetchLastSpikeTime(int netId) {
    if (netId < CPU_RUNTIME_BASE)
        copyLastSpikeTime(netId, cudaMemcpyDeviceToHost);
    else
        copyLastSpikeTime(netId);
}

void SNN::fetchCurSpike(int netId) {
    assert(netId < MAX_NET_PER_SNN);

    if (netId < CPU_RUNTIME_BASE) { // GPU runtime
        copyCurSpikes(netId, cudaMemcpyDeviceToHost);
    } else { // CPU runtime
        copyCurSpikes(netId);
    }
}

void SNN::fetchRandNum(int netId) {
    assert(netId < MAX_NET_PER_SNN);

    if (netId < CPU_RUNTIME_BASE) { // GPU runtime
        copyRandNum(netId, cudaMemcpyDeviceToHost);
    } else { // CPU runtime
        copyRandNum(netId);
    }
}

void SNN::fetchPoissonFireRate(int netId) {
    assert(netId < MAX_NET_PER_SNN);

    if (netId < CPU_RUNTIME_BASE) { // GPU runtime
        copyPoissonFireRate(netId, cudaMemcpyDeviceToHost);
    } else { // CPU runtime
        copyPoissonFireRate(netId);
    }
}

void SNN::fetchSpikeGenBits(int netId) {
    assert(netId < MAX_NET_PER_SNN);

    if (netId < CPU_RUNTIME_BASE) { // GPU runtime
        copySpikeGenBits(netId, cudaMemcpyDeviceToHost);
    } else { // CPU runtime
        copySpikeGenBits(netId);
    }
}




void SNN::fetchPreConnectionInfo(int netId) {
    if (netId < CPU_RUNTIME_BASE)
        copyPreConnectionInfo(netId, ALL, &managerRuntimeData, &runtimeData[netId], cudaMemcpyDeviceToHost, false);
    else
        copyPreConnectionInfo(netId, ALL, &managerRuntimeData, &runtimeData[netId], false);
}

void SNN::fetchPostConnectionInfo(int netId) {
    if (netId < CPU_RUNTIME_BASE)
        copyPostConnectionInfo(netId, ALL, &managerRuntimeData, &runtimeData[netId], cudaMemcpyDeviceToHost, false);
    else
        copyPostConnectionInfo(netId, ALL, &managerRuntimeData, &runtimeData[netId], false);
}

void SNN::fetchSynapseState(int netId) {
    if (netId < CPU_RUNTIME_BASE)
        copySynapseState(netId, &managerRuntimeData, &runtimeData[netId], cudaMemcpyDeviceToHost, false);
    else
        copySynapseState(netId, &managerRuntimeData, &runtimeData[netId], false);
}


void SNN::fetchNetworkSpikeCount() {
    unsigned int spikeCountD1, spikeCountD2, spikeCountExtD1, spikeCountExtD2;

    managerRuntimeData.spikeCountD1 = 0;
    managerRuntimeData.spikeCountD2 = 0;
    managerRuntimeData.spikeCountExtRxD2 = 0;
    managerRuntimeData.spikeCountExtRxD1 = 0;
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {

            if (netId < CPU_RUNTIME_BASE) {
                copyNetworkSpikeCount(netId, cudaMemcpyDeviceToHost,
                    &spikeCountD1, &spikeCountD2,
                    &spikeCountExtD1, &spikeCountExtD2);
                //printf("netId:%d, D1:%d/D2:%d, extD1:%d/D2:%d\n", netId, spikeCountD1, spikeCountD2, spikeCountExtD1, spikeCountExtD2);
            } else {
                copyNetworkSpikeCount(netId,
                    &spikeCountD1, &spikeCountD2,
                    &spikeCountExtD1, &spikeCountExtD2);
                //printf("netId:%d, D1:%d/D2:%d, extD1:%d/D2:%d\n", netId, spikeCountD1, spikeCountD2, spikeCountExtD1, spikeCountExtD2);
            }

            managerRuntimeData.spikeCountD2 += spikeCountD2 - spikeCountExtD2;
            managerRuntimeData.spikeCountD1 += spikeCountD1 - spikeCountExtD1;
            managerRuntimeData.spikeCountExtRxD2 += spikeCountExtD2;
            managerRuntimeData.spikeCountExtRxD1 += spikeCountExtD1;
        }
    }

    managerRuntimeData.spikeCount = managerRuntimeData.spikeCountD1 + managerRuntimeData.spikeCountD2;
}

void SNN::fetchSpikeTables(int netId) {
    if (netId < CPU_RUNTIME_BASE)
        copySpikeTables(netId, cudaMemcpyDeviceToHost);
    else
        copySpikeTables(netId);
}

void SNN::fetchNeuronStateBuffer(int netId, int lGrpId) {
    if (netId < CPU_RUNTIME_BASE)
        copyNeuronStateBuffer(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], cudaMemcpyDeviceToHost, false);
    else
        copyNeuronStateBuffer(netId, lGrpId, &managerRuntimeData, &runtimeData[netId], false);
}

void SNN::fetchExtFiringTable(int netId) {
    assert(netId < MAX_NET_PER_SNN);

    if (netId < CPU_RUNTIME_BASE) { // GPU runtime
        copyExtFiringTable(netId, cudaMemcpyDeviceToHost);
    } else { // CPU runtime
        copyExtFiringTable(netId);
    }
}

void SNN::fetchTimeTable(int netId) {
    assert(netId < MAX_NET_PER_SNN);

    if (netId < CPU_RUNTIME_BASE) { // GPU runtime
        copyTimeTable(netId, cudaMemcpyDeviceToHost);
    } else {
        copyTimeTable(netId, true);
    }
}

void SNN::writeBackTimeTable(int netId) {
    assert(netId < MAX_NET_PER_SNN);

    if (netId < CPU_RUNTIME_BASE) { // GPU runtime
        copyTimeTable(netId, cudaMemcpyHostToDevice);
    } else {
        copyTimeTable(netId, false);
    }
}

void SNN::transferSpikes(void* dest, int destNetId, void* src, int srcNetId, int size) {
#ifndef __NO_CUDA__
    if (srcNetId < CPU_RUNTIME_BASE && destNetId < CPU_RUNTIME_BASE) {
        checkAndSetGPUDevice(destNetId);
        CUDA_CHECK_ERRORS(cudaMemcpyPeer(dest, destNetId, src, srcNetId, size));
    } else if (srcNetId >= CPU_RUNTIME_BASE && destNetId < CPU_RUNTIME_BASE) {
        checkAndSetGPUDevice(destNetId);
        CUDA_CHECK_ERRORS(cudaMemcpy(dest, src, size, cudaMemcpyHostToDevice));
    } else if (srcNetId < CPU_RUNTIME_BASE && destNetId >= CPU_RUNTIME_BASE) {
        checkAndSetGPUDevice(srcNetId);
        CUDA_CHECK_ERRORS(cudaMemcpy(dest, src, size, cudaMemcpyDeviceToHost));
    } else if(srcNetId >= CPU_RUNTIME_BASE && destNetId >= CPU_RUNTIME_BASE) {
        memcpy(dest, src, size);
    }
#else
    assert(srcNetId >= CPU_RUNTIME_BASE && destNetId >= CPU_RUNTIME_BASE);
    memcpy(dest, src, size);
#endif
}

void SNN::convertExtSpikesD2(int netId, int startIdx, int endIdx, int GtoLOffset) {
    if (netId < CPU_RUNTIME_BASE)
        convertExtSpikesD2_GPU(netId, startIdx, endIdx, GtoLOffset);
    else
        convertExtSpikesD2_CPU(netId, startIdx, endIdx, GtoLOffset);
}

void SNN::convertExtSpikesD1(int netId, int startIdx, int endIdx, int GtoLOffset) {
    if (netId < CPU_RUNTIME_BASE)
        convertExtSpikesD1_GPU(netId, startIdx, endIdx, GtoLOffset);
    else
        convertExtSpikesD1_CPU(netId, startIdx, endIdx, GtoLOffset);
}

void SNN::routeSpikes() {
    int firingTableIdxD2, firingTableIdxD1;
    int GtoLOffset;

    for (std::list<RoutingTableEntry>::iterator rteItr = spikeRoutingTable.begin(); rteItr != spikeRoutingTable.end(); rteItr++) {
        int srcNetId = rteItr->srcNetId;
        int destNetId = rteItr->destNetId;

        fetchExtFiringTable(srcNetId);

        fetchTimeTable(destNetId);
        firingTableIdxD2 = managerRuntimeData.timeTableD2[simTimeMs + glbNetworkConfig.maxDelay + 1];
        firingTableIdxD1 = managerRuntimeData.timeTableD1[simTimeMs + glbNetworkConfig.maxDelay + 1];
        //KERNEL_DEBUG("GPU1 D1:%d/D2:%d", firingTableIdxD1, firingTableIdxD2);
        //printf("srcNetId %d,destNetId %d, D1:%d/D2:%d\n", srcNetId, destNetId, firingTableIdxD1, firingTableIdxD2);

        #ifndef __NO_PTHREADS__ // POSIX
            pthread_t threads[(2 * networkConfigs[srcNetId].numGroups) + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
            cpu_set_t cpus;
            ThreadStruct argsThreadRoutine[(2 * networkConfigs[srcNetId].numGroups) + 1]; // same as above, +1 array size
            int threadCount = 0;
        #endif

        for (int lGrpId = 0; lGrpId < networkConfigs[srcNetId].numGroups; lGrpId++) {
            if (groupConfigs[srcNetId][lGrpId].hasExternalConnect && managerRuntimeData.extFiringTableEndIdxD2[lGrpId] > 0) {
                // search GtoLOffset of the neural group at destination local network
                bool isFound = false;
                for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[destNetId].begin(); grpIt != groupPartitionLists[destNetId].end(); grpIt++) {
                    if (grpIt->gGrpId == groupConfigs[srcNetId][lGrpId].gGrpId) {
                        GtoLOffset = grpIt->GtoLOffset;
                        isFound = true;
                        break;
                    }
                }

                if (isFound) {
                    transferSpikes(runtimeData[destNetId].firingTableD2 + firingTableIdxD2, destNetId,
                        managerRuntimeData.extFiringTableD2[lGrpId], srcNetId,
                        sizeof(int) * managerRuntimeData.extFiringTableEndIdxD2[lGrpId]);

                    if (destNetId < CPU_RUNTIME_BASE){
                        convertExtSpikesD2_GPU(destNetId, firingTableIdxD2,
                            firingTableIdxD2 + managerRuntimeData.extFiringTableEndIdxD2[lGrpId],
                            GtoLOffset); // [StartIdx, EndIdx)
                    }
                    else{// CPU runtime
                            #ifdef __NO_PTHREADS__
                                convertExtSpikesD2_CPU(destNetId, firingTableIdxD2,
                                    firingTableIdxD2 + managerRuntimeData.extFiringTableEndIdxD2[lGrpId],
                                    GtoLOffset); // [StartIdx, EndIdx)
                            #else // Linux or MAC
                                pthread_attr_t attr;
                                pthread_attr_init(&attr);
                                CPU_ZERO(&cpus);
                                CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                                pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                                argsThreadRoutine[threadCount].snn_pointer = this;
                                argsThreadRoutine[threadCount].netId = destNetId;
                                argsThreadRoutine[threadCount].lGrpId = 0;
                                argsThreadRoutine[threadCount].startIdx = firingTableIdxD2;
                                argsThreadRoutine[threadCount].endIdx = firingTableIdxD2 + managerRuntimeData.extFiringTableEndIdxD2[lGrpId];
                                argsThreadRoutine[threadCount].GtoLOffset = GtoLOffset;

                                pthread_create(&threads[threadCount], &attr, &SNN::helperConvertExtSpikesD2_CPU, (void*)&argsThreadRoutine[threadCount]);
                                pthread_attr_destroy(&attr);
                                threadCount++;
                            #endif
                    }

                    firingTableIdxD2 += managerRuntimeData.extFiringTableEndIdxD2[lGrpId];
                }
            }

            if (groupConfigs[srcNetId][lGrpId].hasExternalConnect && managerRuntimeData.extFiringTableEndIdxD1[lGrpId] > 0) {
                // search GtoLOffset of the neural group at destination local network
                bool isFound = false;
                for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[destNetId].begin(); grpIt != groupPartitionLists[destNetId].end(); grpIt++) {
                    if (grpIt->gGrpId == groupConfigs[srcNetId][lGrpId].gGrpId) {
                        GtoLOffset = grpIt->GtoLOffset;
                        isFound = true;
                        break;
                    }
                }

                if (isFound) {
                    transferSpikes(runtimeData[destNetId].firingTableD1 + firingTableIdxD1, destNetId,
                        managerRuntimeData.extFiringTableD1[lGrpId], srcNetId,
                        sizeof(int) * managerRuntimeData.extFiringTableEndIdxD1[lGrpId]);
                    if (destNetId < CPU_RUNTIME_BASE){
                        convertExtSpikesD1_GPU(destNetId, firingTableIdxD1,
                            firingTableIdxD1 + managerRuntimeData.extFiringTableEndIdxD1[lGrpId],
                            GtoLOffset); // [StartIdx, EndIdx)
                    }
                    else{// CPU runtime
                        #ifdef __NO_PTHREADS__
                                convertExtSpikesD1_CPU(destNetId, firingTableIdxD1,
                                    firingTableIdxD1 + managerRuntimeData.extFiringTableEndIdxD1[lGrpId],
                                    GtoLOffset); // [StartIdx, EndIdx)
                            #else // Linux or MAC
                                pthread_attr_t attr;
                                pthread_attr_init(&attr);
                                CPU_ZERO(&cpus);
                                CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                                pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                                argsThreadRoutine[threadCount].snn_pointer = this;
                                argsThreadRoutine[threadCount].netId = destNetId;
                                argsThreadRoutine[threadCount].lGrpId = 0;
                                argsThreadRoutine[threadCount].startIdx = firingTableIdxD1;
                                argsThreadRoutine[threadCount].endIdx = firingTableIdxD1 + managerRuntimeData.extFiringTableEndIdxD1[lGrpId];
                                argsThreadRoutine[threadCount].GtoLOffset = GtoLOffset;

                                pthread_create(&threads[threadCount], &attr, &SNN::helperConvertExtSpikesD1_CPU, (void*)&argsThreadRoutine[threadCount]);
                                pthread_attr_destroy(&attr);
                                threadCount++;
                            #endif
                    }
                    firingTableIdxD1 += managerRuntimeData.extFiringTableEndIdxD1[lGrpId];
                }
            }
            //KERNEL_DEBUG("GPU1 New D1:%d/D2:%d", firingTableIdxD1, firingTableIdxD2);
        }

        #ifndef __NO_PTHREADS__ // POSIX
            // join all the threads
            for (int i=0; i<threadCount; i++){
                pthread_join(threads[i], NULL);
            }
        #endif

        managerRuntimeData.timeTableD2[simTimeMs + glbNetworkConfig.maxDelay + 1] = firingTableIdxD2;
        managerRuntimeData.timeTableD1[simTimeMs + glbNetworkConfig.maxDelay + 1] = firingTableIdxD1;
        writeBackTimeTable(destNetId);
    }
}

//We need pass the neuron id (nid) and the grpId just for the case when we want to
//ramp up/down the weights.  In that case we need to set the weights of each synapse
//depending on their nid (their position with respect to one another). -- KDC
float SNN::generateWeight(int connProp, float initWt, float maxWt, int nid, int grpId) {
    float actWts;
    //bool setRandomWeights   = GET_INITWTS_RANDOM(connProp);
    //bool setRampDownWeights = GET_INITWTS_RAMPDOWN(connProp);
    //bool setRampUpWeights   = GET_INITWTS_RAMPUP(connProp);

    //if (setRandomWeights)
    //  actWts = initWt * drand48();
    //else if (setRampUpWeights)
    //  actWts = (initWt + ((nid - groupConfigs[0][grpId].StartN) * (maxWt - initWt) / groupConfigs[0][grpId].SizeN));
    //else if (setRampDownWeights)
    //  actWts = (maxWt - ((nid - groupConfigs[0][grpId].StartN) * (maxWt - initWt) / groupConfigs[0][grpId].SizeN));
    //else
        actWts = initWt;

    return actWts;
}

// checks whether a connection ID contains plastic synapses O(#connections)
bool SNN::isConnectionPlastic(short int connId) {
    assert(connId != ALL);
    assert(connId < numConnections);

    return GET_FIXED_PLASTIC(connectConfigMap[connId].connProp);
}

// FIXME: distinguish the function call at CONFIG_STATE and SETUP_STATE, where groupConfigs[0][] might not be available
// or groupConfigMap is not sync with groupConfigs[0][]
// returns whether group has homeostasis enabled
bool SNN::isGroupWithHomeostasis(int grpId) {
    assert(grpId>=0 && grpId<getNumGroups());
    return (groupConfigMap[grpId].homeoConfig.WithHomeostasis);
}

// performs various verification checkups before building the network
void SNN::verifyNetwork() {
    // make sure number of neuron parameters have been accumulated correctly
    // NOTE: this used to be updateParameters
    //verifyNumNeurons();

    // make sure compartment config is valid
    verifyCompartments();

    // make sure STDP post-group has some incoming plastic connections
    verifySTDP();

    // make sure every group with homeostasis also has STDP
    verifyHomeostasis();

    // make sure the max delay is within bound
    assert(glbNetworkConfig.maxDelay <= MAX_SYN_DELAY);

    // make sure there is sufficient buffer
    //if ((networkConfigs[0].maxSpikesD1 + networkConfigs[0].maxSpikesD2) < (numNExcReg + numNInhReg + numNPois) * UNKNOWN_NEURON_MAX_FIRING_RATE) {
    //  KERNEL_ERROR("Insufficient amount of buffer allocated...");
    //  exitSimulation(1);
    //}

    //make sure the number of pre- and post-connection does not exceed the limitation
    //if (maxNumPostSynGrp > MAX_NUM_POST_SYN) {
    //  for (int g = 0; g < numGroups; g++) {
    //      if (groupConfigMap[g].numPostSynapses>MAX_NUM_POST_SYN)
    //          KERNEL_ERROR("Grp: %s(%d) has too many output synapses (%d), max %d.",groupInfo[g].Name.c_str(),g,
    //                      groupConfigMap[g].numPostSynapses,MAX_NUM_POST_SYN);
    //  }
    //  assert(maxNumPostSynGrp <= MAX_NUM_POST_SYN);
    //}

    //if (maxNumPreSynGrp > MAX_NUM_PRE_SYN) {
    //  for (int g = 0; g < numGroups; g++) {
    //      if (groupConfigMap[g].numPreSynapses>MAX_NUM_PRE_SYN)
    //          KERNEL_ERROR("Grp: %s(%d) has too many input synapses (%d), max %d.",groupInfo[g].Name.c_str(),g,
 //                         groupConfigMap[g].numPreSynapses,MAX_NUM_PRE_SYN);
    //  }
    //  assert(maxNumPreSynGrp <= MAX_NUM_PRE_SYN);
    //}

    // make sure maxDelay == 1 if STP is enableed
    // \FIXME: need to figure out STP buffer for delays > 1
    if (sim_with_stp && glbNetworkConfig.maxDelay > 1) {
        KERNEL_ERROR("STP with delays > 1 ms is currently not supported.");
        exitSimulation(KERNEL_ERROR_MAX_STP_DELAY);
    }

    if (glbNetworkConfig.maxDelay > MAX_SYN_DELAY) {
        KERNEL_ERROR("You are using a synaptic delay (%d) greater than MAX_SYN_DELAY defined in config.h", glbNetworkConfig.maxDelay);
        exitSimulation(KERNEL_ERROR_MAX_SYN_DELAY);
    }
}

void SNN::verifyCompartments() {
    for (std::map<int, compConnectConfig>::iterator it = compConnectConfigMap.begin(); it != compConnectConfigMap.end(); it++)
    {
        int grpLower = it->second.grpSrc;
        int grpUpper = it->second.grpDest;

        // make sure groups are compartmentally enabled
        if (!groupConfigMap[grpLower].withCompartments) {
            KERNEL_ERROR("Group %s(%d) is not compartmentally enabled, cannot be part of a compartmental connection.",
                groupConfigMap[grpLower].grpName.c_str(), grpLower);
            exitSimulation(KERNEL_ERROR_COMPARTMENT_DISABLED);
        }
        if (!groupConfigMap[grpUpper].withCompartments) {
            KERNEL_ERROR("Group %s(%d) is not compartmentally enabled, cannot be part of a compartmental connection.",
                groupConfigMap[grpUpper].grpName.c_str(), grpUpper);
            exitSimulation(KERNEL_ERROR_COMPARTMENT_DISABLED2);
        }
    }
}

// checks whether STDP is set on a plastic connection
void SNN::verifySTDP() {
    for (int gGrpId=0; gGrpId<getNumGroups(); gGrpId++) {
        if (groupConfigMap[gGrpId].WithSTDP) {
            // for each post-group, check if any of the incoming connections are plastic
            bool isAnyPlastic = false;
            for (std::map<int, ConnectConfig>::iterator it = connectConfigMap.begin(); it != connectConfigMap.end(); it++) {
//LN2021 Adhoc Fix -> Kexin ?
// 
                //if (it->second.stdpConfig.WithSTDP) {
                //  if (GET_FIXED_PLASTIC(it->second.connProp)) {
                //      break;
                //  } else {
                //      KERNEL_ERROR("If STDP on connection %d is set, connection must be plastic.",it->second.connId);
                //      exitSimulation(1);
                //  }
                //}
                isAnyPlastic |= GET_FIXED_PLASTIC(it->second.connProp);
                if (isAnyPlastic) {
                    // at least one plastic connection found: break while
                    break;
                }
            }
             if (!isAnyPlastic) {
                KERNEL_ERROR("If STDP on group %d (%s) is set, group must have some incoming plastic connections.",
                    gGrpId, groupConfigMap[gGrpId].grpName.c_str());
                exitSimulation(KERNEL_ERROR_STDP_NO_IN_PLASTIC);
             }
        }
     }
}

// checks whether every group with Homeostasis also has STDP
void SNN::verifyHomeostasis() {
    for (int gGrpId=0; gGrpId<getNumGroups(); gGrpId++) {
        if (groupConfigMap[gGrpId].homeoConfig.WithHomeostasis) {
            KERNEL_INFO("group %d STDP %d", gGrpId, groupConfigMap[gGrpId].WithSTDP);
            if (!groupConfigMap[gGrpId].WithSTDP) {
                KERNEL_ERROR("If homeostasis is enabled on group %d (%s), then STDP must be enabled, too.",
                    gGrpId, groupConfigMap[gGrpId].grpName.c_str());
                exitSimulation(KERNEL_ERROR_STDP_HOMEO_INCONSIST);
            }
        }
    }
}

//void SNN::verifyNumNeurons() {
//  int nExcPois = 0;
//  int nInhPois = 0;
//  int nExcReg = 0;
//  int nInhReg = 0;
//
//  //  scan all the groups and find the required information
//  //  about the group (numN, numPostSynapses, numPreSynapses and others).
//  for(int g=0; g<numGroups; g++)  {
//      if (groupConfigMap[g].Type==UNKNOWN_NEURON) {
//          KERNEL_ERROR("Unknown group for %d (%s)", g, groupInfo[g].Name.c_str());
//          exitSimulation(1);
//      }
//
//      if (IS_INHIBITORY_TYPE(groupConfigMap[g].Type) && !(groupConfigMap[g].Type & POISSON_NEURON))
//          nInhReg += groupConfigMap[g].SizeN;
//      else if (IS_EXCITATORY_TYPE(groupConfigMap[g].Type) && !(groupConfigMap[g].Type & POISSON_NEURON))
//          nExcReg += groupConfigMap[g].SizeN;
//      else if (IS_EXCITATORY_TYPE(groupConfigMap[g].Type) &&  (groupConfigMap[g].Type & POISSON_NEURON))
//          nExcPois += groupConfigMap[g].SizeN;
//      else if (IS_INHIBITORY_TYPE(groupConfigMap[g].Type) &&  (groupConfigMap[g].Type & POISSON_NEURON))
//          nInhPois += groupConfigMap[g].SizeN;
//  }
//
//  // check the newly gathered information with class members
//  if (numN != nExcReg+nInhReg+nExcPois+nInhPois) {
//      KERNEL_ERROR("nExcReg+nInhReg+nExcPois+nInhPois=%d does not add up to numN=%d",
//          nExcReg+nInhReg+nExcPois+nInhPois, numN);
//      exitSimulation(1);
//  }
//  if (numNReg != nExcReg+nInhReg) {
//      KERNEL_ERROR("nExcReg+nInhReg=%d does not add up to numNReg=%d", nExcReg+nInhReg, numNReg);
//      exitSimulation(1);
//  }
//  if (numNPois != nExcPois+nInhPois) {
//      KERNEL_ERROR("nExcPois+nInhPois=%d does not add up to numNPois=%d", nExcPois+nInhPois, numNPois);
//      exitSimulation(1);
//  }
//
//  //printf("numN=%d == %d\n",numN,nExcReg+nInhReg+nExcPois+nInhPois);
//  //printf("numNReg=%d == %d\n",numNReg, nExcReg+nInhReg);
//  //printf("numNPois=%d == %d\n",numNPois, nExcPois+nInhPois);
//
//  assert(numN <= 1000000);
//  assert((numN > 0) && (numN == numNExcReg + numNInhReg + numNPois));
//}

// \FIXME: not sure where this should go... maybe create some helper file?
bool SNN::isPoint3DinRF(const RadiusRF& radius, const Point3D& pre, const Point3D& post) {
    // Note: RadiusRF rad is assumed to be the fanning in to the post neuron. So if the radius is 10 pixels, it means
    // that if you look at the post neuron, it will receive input from neurons that code for locations no more than
    // 10 pixels away. (The opposite is called a response/stimulus field.)

    double rfDist = getRFDist3D(radius, pre, post);
    return (rfDist >= 0.0 && rfDist <= 1.0);
}

double SNN::getRFDist3D(const RadiusRF& radius, const Point3D& pre, const Point3D& post) {
    // Note: RadiusRF rad is assumed to be the fanning in to the post neuron. So if the radius is 10 pixels, it means
    // that if you look at the post neuron, it will receive input from neurons that code for locations no more than
    // 10 pixels away.

    // ready output argument
    // SNN::isPoint3DinRF() will return true (connected) if rfDist e[0.0, 1.0]
    double rfDist = -1.0;

    // pre and post are connected in a generic 3D ellipsoid RF if x^2/a^2 + y^2/b^2 + z^2/c^2 <= 1.0, where
    // x = pre.x-post.x, y = pre.y-post.y, z = pre.z-post.z
    // x < 0 means:  connect if y and z satisfy some constraints, but ignore x
    // x == 0 means: connect if y and z satisfy some constraints, and enforce pre.x == post.x
    if (radius.radX==0 && pre.x!=post.x || radius.radY==0 && pre.y!=post.y || radius.radZ==0 && pre.z!=post.z) {
        rfDist = -1.0;
    } else {
        // 3D ellipsoid: x^2/a^2 + y^2/b^2 + z^2/c^2 <= 1.0
        double xTerm = (radius.radX<=0) ? 0.0 : pow(pre.x-post.x,2)/pow(radius.radX,2);
        double yTerm = (radius.radY<=0) ? 0.0 : pow(pre.y-post.y,2)/pow(radius.radY,2);
        double zTerm = (radius.radZ<=0) ? 0.0 : pow(pre.z-post.z,2)/pow(radius.radZ,2);
        rfDist = xTerm + yTerm + zTerm;
    }

    return rfDist;
}

void SNN::partitionSNN() {
    int numAssignedNeurons[MAX_NET_PER_SNN] = {0};

#ifndef __NO_CUDA__
    // get number of available GPU card(s) in the present machine
    numAvailableGPUs = configGPUDevice();
#endif

    for (std::map<int, GroupConfigMD>::iterator grpIt = groupConfigMDMap.begin(); grpIt != groupConfigMDMap.end(); grpIt++) {
        // assign a group to the GPU specified by users
        int gGrpId = grpIt->second.gGrpId;
        int netId = groupConfigMap[gGrpId].preferredNetId;
        if (netId != ANY) {
            assert(netId > ANY && netId < MAX_NET_PER_SNN);
            grpIt->second.netId = netId;
            numAssignedNeurons[netId] += groupConfigMap[gGrpId].numN;
            groupPartitionLists[netId].push_back(grpIt->second); // Copy by value, create a copy
        } else { // netId == ANY
            // TODO: add callback function that allow user to partition network by theirself
            // FIXME: make sure GPU(s) is available first
            // this parse separates groups into each local network and assign each group a netId
            if (preferredSimMode_ == CPU_MODE) {
                grpIt->second.netId = CPU_RUNTIME_BASE; // CPU 0
                numAssignedNeurons[CPU_RUNTIME_BASE] += groupConfigMap[gGrpId].numN;
                groupPartitionLists[CPU_RUNTIME_BASE].push_back(grpIt->second); // Copy by value, create a copy
            } else if (preferredSimMode_ == GPU_MODE) {
                grpIt->second.netId = GPU_RUNTIME_BASE; // GPU 0
                numAssignedNeurons[GPU_RUNTIME_BASE] += groupConfigMap[gGrpId].numN;
                groupPartitionLists[GPU_RUNTIME_BASE].push_back(grpIt->second); // Copy by value, create a copy
            } else  if (preferredSimMode_ == HYBRID_MODE) {
                // TODO: implement partition algorithm, use naive partition for now (allocate to CPU 0)
                grpIt->second.netId = CPU_RUNTIME_BASE; // CPU 0
                numAssignedNeurons[CPU_RUNTIME_BASE] += groupConfigMap[gGrpId].numN;
                groupPartitionLists[CPU_RUNTIME_BASE].push_back(grpIt->second); // Copy by value, create a copy
            } else {
                KERNEL_ERROR("Unkown simulation mode");
                exitSimulation(KERNEL_ERROR_UNKNOWN_SIM_MODE);
            }
        }

        if (grpIt->second.netId == -1) { // the group was not assigned to any computing backend
            KERNEL_ERROR("Can't assign the group [%d] to any partition", grpIt->second.gGrpId);
            exitSimulation(KERNEL_ERROR_NO_PARTION_ASSIGNED);
        }
    }

    // this parse finds local connections (i.e., connection configs that conect local groups)
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            for (std::map<int, ConnectConfig>::iterator connIt = connectConfigMap.begin(); connIt != connectConfigMap.end(); connIt++) {
                if (groupConfigMDMap[connIt->second.grpSrc].netId == netId && groupConfigMDMap[connIt->second.grpDest].netId == netId) {
                    localConnectLists[netId].push_back(connectConfigMap[connIt->second.connId]); // Copy by value
                }
            }

            //printf("The size of compConnectConfigMap is: %i\n", compConnectConfigMap.size());
            for (std::map<int, compConnectConfig>::iterator connIt = compConnectConfigMap.begin(); connIt != compConnectConfigMap.end(); connIt++) {
                if (groupConfigMDMap[connIt->second.grpSrc].netId == netId && groupConfigMDMap[connIt->second.grpDest].netId == netId) {
                    localCompConnectLists[netId].push_back(compConnectConfigMap[connIt->second.connId]); // Copy by value
                }
            }
        }
    }

    // this parse finds external groups and external connections
    spikeRoutingTable.clear();
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            for (std::map<int, ConnectConfig>::iterator connIt = connectConfigMap.begin(); connIt != connectConfigMap.end(); connIt++) {
                int srcNetId = groupConfigMDMap[connIt->second.grpSrc].netId;
                int destNetId = groupConfigMDMap[connIt->second.grpDest].netId;
                if (srcNetId == netId && destNetId != netId) {
                    // search the source group in groupPartitionLists and mark it as having external connections
                    GroupConfigMD targetGroup;
                    std::list<GroupConfigMD>::iterator srcGrpIt, destGrpIt;

                    targetGroup.gGrpId = connIt->second.grpSrc;
                    srcGrpIt = find(groupPartitionLists[srcNetId].begin(), groupPartitionLists[srcNetId].end(), targetGroup);
                    assert(srcGrpIt != groupPartitionLists[srcNetId].end());
                    srcGrpIt->hasExternalConnect = true;

                    // FIXME: fail to write external group if the only one external link across GPUs is uni directional (GPU0 -> GPU1, no GPU1 -> GPU0)
                    targetGroup.gGrpId = connIt->second.grpDest;
                    destGrpIt = find(groupPartitionLists[srcNetId].begin(), groupPartitionLists[srcNetId].end(), targetGroup);
                    if (destGrpIt == groupPartitionLists[srcNetId].end()) { // the "external" dest group has not yet been copied to te "local" group partition list
                        numAssignedNeurons[srcNetId] += groupConfigMap[connIt->second.grpDest].numN;
                        groupPartitionLists[srcNetId].push_back(groupConfigMDMap[connIt->second.grpDest]);
                    }

                    targetGroup.gGrpId = connIt->second.grpSrc;
                    srcGrpIt = find(groupPartitionLists[destNetId].begin(), groupPartitionLists[destNetId].end(), targetGroup);
                    if (srcGrpIt == groupPartitionLists[destNetId].end()) {
                        numAssignedNeurons[destNetId] += groupConfigMap[connIt->second.grpSrc].numN;
                        groupPartitionLists[destNetId].push_back(groupConfigMDMap[connIt->second.grpSrc]);
                    }

                    externalConnectLists[srcNetId].push_back(connectConfigMap[connIt->second.connId]); // Copy by value

                    // build the spike routing table by the way
                    //printf("%d,%d -> %d,%d\n", srcNetId, connIt->second.grpSrc, destNetId, connIt->second.grpDest);
                    RoutingTableEntry rte(srcNetId, destNetId);
                    spikeRoutingTable.push_back(rte);
                }
            }
        }
    }

    spikeRoutingTable.unique();

    // assign local neuron ids and, local group ids for each local network in the order
    // MPORTANT : NEURON ORGANIZATION/ARRANGEMENT MAP
    // <--- Excitatory --> | <-------- Inhibitory REGION ----------> | <-- Excitatory --> | <-- External -->
    // Excitatory-Regular  | Inhibitory-Regular | Inhibitory-Poisson | Excitatory-Poisson | External Neurons
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            int availableNeuronId = 0;
            int localGroupId = 0;
            for (int order = 0; order < 5; order++) {
                for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[netId].begin(); grpIt != groupPartitionLists[netId].end(); grpIt++) {
                    unsigned int type = groupConfigMap[grpIt->gGrpId].type;
                    if (IS_EXCITATORY_TYPE(type) && (type & POISSON_NEURON) && order == 3 && grpIt->netId == netId) {
                        availableNeuronId = assignGroup(grpIt, localGroupId, availableNeuronId);
                        localGroupId++;
                    } else if (IS_INHIBITORY_TYPE(type) && (type & POISSON_NEURON) && order == 2 && grpIt->netId == netId) {
                        availableNeuronId = assignGroup(grpIt, localGroupId, availableNeuronId);
                        localGroupId++;
                    } else if (IS_EXCITATORY_TYPE(type) && !(type & POISSON_NEURON) && order == 0 && grpIt->netId == netId) {
                        availableNeuronId = assignGroup(grpIt, localGroupId, availableNeuronId);
                        localGroupId++;
                    } else if (IS_INHIBITORY_TYPE(type) && !(type & POISSON_NEURON) && order == 1 && grpIt->netId == netId) {
                        availableNeuronId = assignGroup(grpIt, localGroupId, availableNeuronId);
                        localGroupId++;
                    } else if (order == 4 && grpIt->netId != netId) {
                        availableNeuronId = assignGroup(grpIt, localGroupId, availableNeuronId);
                        localGroupId++;
                    }
                }
            }
            assert(availableNeuronId == numAssignedNeurons[netId]);
            assert(localGroupId == groupPartitionLists[netId].size());
        }
    }


    // generation connections among groups according to group and connect configs
    // update ConnectConfig::numberOfConnections
    // update GroupConfig::numPostSynapses, GroupConfig::numPreSynapses
    if (loadSimFID == NULL) {
        connectNetwork();
    } else {
        KERNEL_INFO("Load Simulation");
        loadSimulation_internal(false);  // true or false doesn't matter here
    }

    collectGlobalNetworkConfigP();

    // print group and connection overview
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            KERNEL_INFO("\n+ Local Network (%d)", netId);
            KERNEL_INFO("|-+ Group List:");
            for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[netId].begin(); grpIt != groupPartitionLists[netId].end(); grpIt++)
                printGroupInfo(netId, grpIt);
        }

        if (!localConnectLists[netId].empty() || !externalConnectLists[netId].empty()) {
            KERNEL_INFO("|-+ Connection List:");
            for (std::list<ConnectConfig>::iterator connIt = localConnectLists[netId].begin(); connIt != localConnectLists[netId].end(); connIt++)
                printConnectionInfo(netId, connIt);

            for (std::list<ConnectConfig>::iterator connIt = externalConnectLists[netId].begin(); connIt != externalConnectLists[netId].end(); connIt++)
                printConnectionInfo(netId, connIt);
        }
    }

    // print spike routing table
    printSikeRoutingInfo();

    snnState = PARTITIONED_SNN;
}

#ifdef LN_SETUP_NETWORK_MT
// featFastSetup LN20201108
void SNN::partitionSNNMT() {
    int numAssignedNeurons[MAX_NET_PER_SNN] = { 0 };

    // get number of available GPU card(s) in the present machine
    numAvailableGPUs = configGPUDevice();

    for (std::map<int, GroupConfigMD>::iterator grpIt = groupConfigMDMap.begin(); grpIt != groupConfigMDMap.end(); grpIt++) {
        // assign a group to the GPU specified by users
        int gGrpId = grpIt->second.gGrpId;
        int netId = groupConfigMap[gGrpId].preferredNetId;
        if (netId != ANY) {
            assert(netId > ANY && netId < MAX_NET_PER_SNN);
            grpIt->second.netId = netId;
            numAssignedNeurons[netId] += groupConfigMap[gGrpId].numN;
            groupPartitionLists[netId].push_back(grpIt->second); // Copy by value, create a copy
        }
        else { // netId == ANY
               // TODO: add callback function that allow user to partition network by theirself
               // FIXME: make sure GPU(s) is available first
               // this parse separates groups into each local network and assign each group a netId
            if (preferredSimMode_ == CPU_MODE) {
                grpIt->second.netId = CPU_RUNTIME_BASE; // CPU 0
                numAssignedNeurons[CPU_RUNTIME_BASE] += groupConfigMap[gGrpId].numN;
                groupPartitionLists[CPU_RUNTIME_BASE].push_back(grpIt->second); // Copy by value, create a copy
            }
            else if (preferredSimMode_ == GPU_MODE) {
                grpIt->second.netId = GPU_RUNTIME_BASE; // GPU 0
                numAssignedNeurons[GPU_RUNTIME_BASE] += groupConfigMap[gGrpId].numN;
                groupPartitionLists[GPU_RUNTIME_BASE].push_back(grpIt->second); // Copy by value, create a copy
            }
            else  if (preferredSimMode_ == HYBRID_MODE) {
                // TODO: implement partition algorithm, use naive partition for now (allocate to CPU 0)
                grpIt->second.netId = CPU_RUNTIME_BASE; // CPU 0
                numAssignedNeurons[CPU_RUNTIME_BASE] += groupConfigMap[gGrpId].numN;
                groupPartitionLists[CPU_RUNTIME_BASE].push_back(grpIt->second); // Copy by value, create a copy
            }
            else {
                KERNEL_ERROR("Unkown simulation mode");
                exitSimulation(-1);
            }
        }

        if (grpIt->second.netId == -1) { // the group was not assigned to any computing backend
            KERNEL_ERROR("Can't assign the group [%d] to any partition", grpIt->second.gGrpId);
            exitSimulation(-1);
        }
    }

    // this parse finds local connections (i.e., connection configs that conect local groups)
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            for (std::map<int, ConnectConfig>::iterator connIt = connectConfigMap.begin(); connIt != connectConfigMap.end(); connIt++) {
                if (groupConfigMDMap[connIt->second.grpSrc].netId == netId && groupConfigMDMap[connIt->second.grpDest].netId == netId) {
                    localConnectLists[netId].push_back(connectConfigMap[connIt->second.connId]); // Copy by value
                }
            }

            //printf("The size of compConnectConfigMap is: %i\n", compConnectConfigMap.size());
            for (std::map<int, compConnectConfig>::iterator connIt = compConnectConfigMap.begin(); connIt != compConnectConfigMap.end(); connIt++) {
                if (groupConfigMDMap[connIt->second.grpSrc].netId == netId && groupConfigMDMap[connIt->second.grpDest].netId == netId) {
                    localCompConnectLists[netId].push_back(compConnectConfigMap[connIt->second.connId]); // Copy by value
                }
            }
        }
    }

    // this parse finds external groups and external connections
    spikeRoutingTable.clear();
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            for (std::map<int, ConnectConfig>::iterator connIt = connectConfigMap.begin(); connIt != connectConfigMap.end(); connIt++) {
                int srcNetId = groupConfigMDMap[connIt->second.grpSrc].netId;
                int destNetId = groupConfigMDMap[connIt->second.grpDest].netId;
                if (srcNetId == netId && destNetId != netId) {
                    // search the source group in groupPartitionLists and mark it as having external connections
                    GroupConfigMD targetGroup;
                    std::list<GroupConfigMD>::iterator srcGrpIt, destGrpIt;

                    targetGroup.gGrpId = connIt->second.grpSrc;
                    srcGrpIt = find(groupPartitionLists[srcNetId].begin(), groupPartitionLists[srcNetId].end(), targetGroup);
                    assert(srcGrpIt != groupPartitionLists[srcNetId].end());
                    srcGrpIt->hasExternalConnect = true;

                    // FIXME: fail to write external group if the only one external link across GPUs is uni directional (GPU0 -> GPU1, no GPU1 -> GPU0)
                    targetGroup.gGrpId = connIt->second.grpDest;
                    destGrpIt = find(groupPartitionLists[srcNetId].begin(), groupPartitionLists[srcNetId].end(), targetGroup);
                    if (destGrpIt == groupPartitionLists[srcNetId].end()) { // the "external" dest group has not yet been copied to te "local" group partition list
                        numAssignedNeurons[srcNetId] += groupConfigMap[connIt->second.grpDest].numN;
                        groupPartitionLists[srcNetId].push_back(groupConfigMDMap[connIt->second.grpDest]);
                    }

                    targetGroup.gGrpId = connIt->second.grpSrc;
                    srcGrpIt = find(groupPartitionLists[destNetId].begin(), groupPartitionLists[destNetId].end(), targetGroup);
                    if (srcGrpIt == groupPartitionLists[destNetId].end()) {
                        numAssignedNeurons[destNetId] += groupConfigMap[connIt->second.grpSrc].numN;
                        groupPartitionLists[destNetId].push_back(groupConfigMDMap[connIt->second.grpSrc]);
                    }

                    externalConnectLists[srcNetId].push_back(connectConfigMap[connIt->second.connId]); // Copy by value

                                                                                                       // build the spike routing table by the way
                                                                                                       //printf("%d,%d -> %d,%d\n", srcNetId, connIt->second.grpSrc, destNetId, connIt->second.grpDest);
                    RoutingTableEntry rte(srcNetId, destNetId);
                    spikeRoutingTable.push_back(rte);
                }
            }
        }
    }

    spikeRoutingTable.unique();

    // assign local neuron ids and, local group ids for each local network in the order
    // MPORTANT : NEURON ORGANIZATION/ARRANGEMENT MAP
    // <--- Excitatory --> | <-------- Inhibitory REGION ----------> | <-- Excitatory --> | <-- External -->
    // Excitatory-Regular  | Inhibitory-Regular | Inhibitory-Poisson | Excitatory-Poisson | External Neurons
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            int availableNeuronId = 0;
            int localGroupId = 0;
            for (int order = 0; order < 5; order++) {
                for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[netId].begin(); grpIt != groupPartitionLists[netId].end(); grpIt++) {
                    unsigned int type = groupConfigMap[grpIt->gGrpId].type;
                    if (IS_EXCITATORY_TYPE(type) && (type & POISSON_NEURON) && order == 3 && grpIt->netId == netId) {
                        availableNeuronId = assignGroup(grpIt, localGroupId, availableNeuronId);
                        localGroupId++;
                    }
                    else if (IS_INHIBITORY_TYPE(type) && (type & POISSON_NEURON) && order == 2 && grpIt->netId == netId) {
                        availableNeuronId = assignGroup(grpIt, localGroupId, availableNeuronId);
                        localGroupId++;
                    }
                    else if (IS_EXCITATORY_TYPE(type) && !(type & POISSON_NEURON) && order == 0 && grpIt->netId == netId) {
                        availableNeuronId = assignGroup(grpIt, localGroupId, availableNeuronId);
                        localGroupId++;
                    }
                    else if (IS_INHIBITORY_TYPE(type) && !(type & POISSON_NEURON) && order == 1 && grpIt->netId == netId) {
                        availableNeuronId = assignGroup(grpIt, localGroupId, availableNeuronId);
                        localGroupId++;
                    }
                    else if (order == 4 && grpIt->netId != netId) {
                        availableNeuronId = assignGroup(grpIt, localGroupId, availableNeuronId);
                        localGroupId++;
                    }
                }
            }
            assert(availableNeuronId == numAssignedNeurons[netId]);
            assert(localGroupId == groupPartitionLists[netId].size());
        }
    }


    // generation connections among groups according to group and connect configs
    // update ConnectConfig::numberOfConnections
    // update GroupConfig::numPostSynapses, GroupConfig::numPreSynapses
    if (loadSimFID == NULL) {
        connectNetworkMT();
    }
    else {
        KERNEL_INFO("Load Simulation");
        loadSimulation_internal(false);  // true or false doesn't matter here
    }

    collectGlobalNetworkConfigP();

    // print group and connection overview
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            KERNEL_INFO("\n+ Local Network (%d)", netId);
            KERNEL_INFO("|-+ Group List:");
            for (std::list<GroupConfigMD>::iterator grpIt = groupPartitionLists[netId].begin(); grpIt != groupPartitionLists[netId].end(); grpIt++)
                printGroupInfo(netId, grpIt);
        }

        if (!localConnectLists[netId].empty() || !externalConnectLists[netId].empty()) {
            KERNEL_INFO("|-+ Connection List:");
            for (std::list<ConnectConfig>::iterator connIt = localConnectLists[netId].begin(); connIt != localConnectLists[netId].end(); connIt++)
                printConnectionInfo(netId, connIt);

            for (std::list<ConnectConfig>::iterator connIt = externalConnectLists[netId].begin(); connIt != externalConnectLists[netId].end(); connIt++)
                printConnectionInfo(netId, connIt);
        }
    }

    // print spike routing table
    printSikeRoutingInfo();

    snnState = PARTITIONED_SNN;
}
#endif 

int SNN::loadSimulation_internal(bool onlyPlastic) {
    // TSC: so that we can restore the file position later...
    // MB: not sure why though...
    long file_position = ftell(loadSimFID);
    
    int tmpInt;
    float tmpFloat;

    bool readErr = false; // keep track of reading errors
    size_t result;


    // ------- read header ----------------

    fseek(loadSimFID, 0, SEEK_SET);

    // read file signature
    result = fread(&tmpInt, sizeof(int), 1, loadSimFID);
    readErr |= (result!=1);
    if (tmpInt != 294338571) {
        KERNEL_ERROR("loadSimulation: Unknown file signature. This does not seem to be a "
            "simulation file created with CARLsim::saveSimulation.");
        exitSimulation(KERNEL_ERROR_UNKNOWN_FILE_SIGNATURE);
    }

    // read file version number
    result = fread(&tmpFloat, sizeof(float), 1, loadSimFID);
    readErr |= (result!=1);
    if (tmpFloat > 0.3f) {
        KERNEL_ERROR("loadSimulation: Unsupported version number (%f)",tmpFloat);
        exitSimulation(KERNEL_ERROR_UNSUPPORTED_VERSION);
    }

    // read simulation time
    result = fread(&tmpFloat, sizeof(float), 1, loadSimFID);
    readErr |= (result!=1);

    // read execution time
    result = fread(&tmpFloat, sizeof(float), 1, loadSimFID);
    readErr |= (result!=1);

    // read number of neurons
    result = fread(&tmpInt, sizeof(int), 1, loadSimFID);
    readErr |= (result!=1);
    if (tmpInt != glbNetworkConfig.numN) {
        KERNEL_ERROR("loadSimulation: Number of neurons in file (%d) and simulation (%d) don't match.",
            tmpInt, glbNetworkConfig.numN);
        exitSimulation(KERNEL_ERROR_NEURON_MISMATCH);
    }

    // skip save and read pre-synapses & post-synapses in CARLsim5 since they are now netID based
    // read number of pre-synapses
    // result = fread(&tmpInt, sizeof(int), 1, loadSimFID);
    // readErr |= (result!=1);
    // if (numPreSynNet != tmpInt) {
    //  KERNEL_ERROR("loadSimulation: numPreSynNet in file (%d) and simulation (%d) don't match.",
    //      tmpInt, numPreSynNet);
    //  exitSimulation(-1);
    // }

    //result = fread(&tmpInt, sizeof(int), 1, loadSimFID);
    //readErr |= (result!=1);
    //if (numPostSynNet != tmpInt) {
    //  KERNEL_ERROR("loadSimulation: numPostSynNet in file (%d) and simulation (%d) don't match.",
    //      tmpInt, numPostSynNet);
    //  exitSimulation(-1);
    //}

    // read number of groups
    result = fread(&tmpInt, sizeof(int), 1, loadSimFID);
    readErr |= (result!=1);
    if (tmpInt != numGroups) {
        KERNEL_ERROR("loadSimulation: Number of groups in file (%d) and simulation (%d) don't match.",
            tmpInt, numGroups);
        exitSimulation(KERNEL_ERROR_GROUP_MISMATCH);
    }

    // throw reading error instead of proceeding
    if (readErr) {
        fprintf(stderr,"loadSimulation: Error while reading file header");  // \todo Jinwei: why fprintf instead of KERNEL_ERROR
        exitSimulation(KERNEL_ERROR_INVALID_HEADER);
    }


    // ------- read group information ----------------
    for (int g=0; g<numGroups; g++) {
        // read StartN
        result = fread(&tmpInt, sizeof(int), 1, loadSimFID);
        readErr |= (result!=1);
        if (tmpInt != groupConfigMDMap[g].gStartN) {
            KERNEL_ERROR("loadSimulation: StartN in file (%d) and grpInfo (%d) for group %d don't match.",
                tmpInt, groupConfigMDMap[g].gStartN, g);
            exitSimulation(KERNEL_ERROR_INVALID_START);
        }

        // read EndN
        result = fread(&tmpInt, sizeof(int), 1, loadSimFID);
        readErr |= (result!=1);
        if (tmpInt != groupConfigMDMap[g].gEndN) {
            KERNEL_ERROR("loadSimulation: EndN in file (%d) and grpInfo (%d) for group %d don't match.",
                tmpInt, groupConfigMDMap[g].gEndN, g);
            exitSimulation(KERNEL_ERROR_INVALID_END);
        }

        // read SizeX
        result = fread(&tmpInt, sizeof(int), 1, loadSimFID);
        readErr |= (result!=1);
        if (tmpInt != groupConfigMap[g].grid.numX) {
            KERNEL_ERROR("loadSimulation: numX in file (%d) and grpInfo (%d) for group %d don't match.",
                tmpInt, groupConfigMap[g].grid.numX, g);
            exitSimulation(KERNEL_ERROR_NUMX);
        }


        // read SizeY
        result = fread(&tmpInt, sizeof(int), 1, loadSimFID);
        readErr |= (result!=1);
        if (tmpInt != groupConfigMap[g].grid.numY) {
            KERNEL_ERROR("loadSimulation: numY in file (%d) and grpInfo (%d) for group %d don't match.",
                tmpInt, groupConfigMap[g].grid.numY, g);
            exitSimulation(KERNEL_ERROR_NUMY);
        }


        // read SizeZ
        result = fread(&tmpInt, sizeof(int), 1, loadSimFID);
        readErr |= (result!=1);
        if (tmpInt != groupConfigMap[g].grid.numZ) {
            KERNEL_ERROR("loadSimulation: numZ in file (%d) and grpInfo (%d) for group %d don't match.",
                tmpInt, groupConfigMap[g].grid.numZ, g);
            exitSimulation(KERNEL_ERROR_NUMZ);
        }


        // read group name
        char name[100];
        result = fread(name, sizeof(char), 100, loadSimFID);
        readErr |= (result!=100);
        if (strcmp(name,groupConfigMap[g].grpName.c_str()) != 0) {
            KERNEL_ERROR("loadSimulation: Group names in file (%s) and grpInfo (%s) don't match.", name,
                groupConfigMap[g].grpName.c_str());
            exitSimulation(KERNEL_ERROR_GROUP_NAMES_MISMATCH);
        }
    }

    if (readErr) {
        KERNEL_ERROR("loadSimulation: Error while reading group info");
        exitSimulation(KERNEL_ERROR_INVALID_GROUP_INFO);
    }
    //      // read weight
    //      result = fread(&weight, sizeof(float), 1, loadSimFID);
    //      readErr |= (result!=1);

    //      short int gIDpre = managerRuntimeData.grpIds[nIDpre];
    //      if (IS_INHIBITORY_TYPE(groupConfigs[0][gIDpre].Type) && (weight>0)
    //              || !IS_INHIBITORY_TYPE(groupConfigs[0][gIDpre].Type) && (weight<0)) {
    //          KERNEL_ERROR("loadSimulation: Sign of weight value (%s) does not match neuron type (%s)",
    //              ((weight>=0.0f)?"plus":"minus"),
    //              (IS_INHIBITORY_TYPE(groupConfigs[0][gIDpre].Type)?"inhibitory":"excitatory"));
    //          exitSimulation(-1);
    //      }

    //      // read max weight
    //      result = fread(&maxWeight, sizeof(float), 1, loadSimFID);
    //      readErr |= (result!=1);
    //      if (IS_INHIBITORY_TYPE(groupConfigs[0][gIDpre].Type) && (maxWeight>=0)
    //              || !IS_INHIBITORY_TYPE(groupConfigs[0][gIDpre].Type) && (maxWeight<=0)) {
    //          KERNEL_ERROR("loadSimulation: Sign of maxWeight value (%s) does not match neuron type (%s)",
    //              ((maxWeight>=0.0f)?"plus":"minus"),
    //              (IS_INHIBITORY_TYPE(groupConfigs[0][gIDpre].Type)?"inhibitory":"excitatory"));
    //          exitSimulation(-1);
    //      }

    // ------- read synapse information ----------------
    int net_count = 0;
    result = fread(&net_count, sizeof(int), 1, loadSimFID);
    readErr |= (result!=1);

    for (int i = 0; i < net_count; i++) {
        int synapse_count = 0;
        result = fread(&synapse_count, sizeof(int), 1, loadSimFID);
        for (int j = 0; j < synapse_count; j++) {
            int gGrpIdPre;
            int gGrpIdPost;
            int grpNIdPre;
            int grpNIdPost;
            int connId;
            float weight;
            float maxWeight;
            int delay;

            // read gGrpIdPre
            result = fread(&gGrpIdPre, sizeof(int), 1, loadSimFID);
            readErr |= (result!=1); // FIX  warning C4552: '!=': result of expression not used

            // read gGrpIdPost
            result = fread(&gGrpIdPost, sizeof(int), 1, loadSimFID);
            readErr |= (result!=1); // FIX  warning C4552: '!=': result of expression not used

            // read grpNIdPre
            result = fread(&grpNIdPre, sizeof(int), 1, loadSimFID);
            readErr |= (result!=1); // FIX  warning C4552: '!=': result of expression not used

            // read grpNIdPost
            result = fread(&grpNIdPost, sizeof(int), 1, loadSimFID);
            readErr |= (result!=1); // FIX  warning C4552: '!=': result of expression not used

            // read connId
            result = fread(&connId, sizeof(int), 1, loadSimFID);
            readErr |= (result!=1); // FIX  warning C4552: '!=': result of expression not used

            // read weight
            result = fread(&weight, sizeof(float), 1, loadSimFID);
            readErr |= (result!=1); // FIX  warning C4552: '!=': result of expression not used

            // read maxWeight
            result = fread(&maxWeight, sizeof(float), 1, loadSimFID);
            readErr |= (result!=1); // FIX  warning C4552: '!=': result of expression not used

            // read delay
            result = fread(&delay, sizeof(int), 1, loadSimFID);
            readErr |= (result!=1);  // FIX  warning C4552: '!=': result of expression not used


            // check connection
            if (connectConfigMap[connId].grpSrc != gGrpIdPre) {
                KERNEL_ERROR("loadSimulation: source group in file (%d) and in simulation (%d) for connection %d don't match.",
                    gGrpIdPre , connectConfigMap[connId].grpSrc, connId);
                exitSimulation(KERNEL_ERROR_SRC_GRP_CONN);
            }

            if (connectConfigMap[connId].grpDest != gGrpIdPost) {
                KERNEL_ERROR("loadSimulation: dest group in file (%d) and in simulation (%d) for connection %d don't match.",
                    gGrpIdPost , connectConfigMap[connId].grpDest, connId);
                exitSimulation(KERNEL_ERROR_DEST_GRP_CONN);
            }

            // connect synapse
            // find netid for two groups
            int netIdPre = groupConfigMDMap[gGrpIdPre].netId;
            int netIdPost = groupConfigMDMap[gGrpIdPost].netId;
            bool isExternal = (netIdPre != netIdPost);

            // find global neuron id for two neurons
            int globalNIdPre = groupConfigMDMap[gGrpIdPre].gStartN + grpNIdPre;
            int globalNIdPost = groupConfigMDMap[gGrpIdPost].gStartN + grpNIdPost;

            bool connected =false;
            if (!isExternal) {
                for (std::list<ConnectConfig>::iterator connIt = localConnectLists[netIdPre].begin(); connIt != localConnectLists[netIdPre].end() && (!connected); connIt++) {
                    if (connIt->connId == connId) {
                        // connect two neurons
                        connectNeurons(netIdPre, gGrpIdPre, gGrpIdPost, globalNIdPre, globalNIdPost, connId, weight, maxWeight, delay,  -1);
                        connected = true;
                        // update connection information
                        connIt->numberOfConnections++;
                        std::list<GroupConfigMD>::iterator grpIt;

                        // fix me maybe: numPostSynapses and numPreSynpases could also be loaded from saved information directly to save time
                        // the current implementation is a safer one
                        GroupConfigMD targetGrp;

                        targetGrp.gGrpId = gGrpIdPre;
                        grpIt = std::find(groupPartitionLists[netIdPre].begin(), groupPartitionLists[netIdPre].end(), targetGrp);
                        assert(grpIt != groupPartitionLists[netIdPre].end());
                        grpIt->numPostSynapses += 1;

                        targetGrp.gGrpId = gGrpIdPost;
                        grpIt = std::find(groupPartitionLists[netIdPre].begin(), groupPartitionLists[netIdPre].end(), targetGrp);
                        assert(grpIt != groupPartitionLists[netIdPost].end());
                        grpIt->numPreSynapses += 1;
                    }
                }
            } else {
                for (std::list<ConnectConfig>::iterator connIt = externalConnectLists[netIdPre].begin(); connIt != externalConnectLists[netIdPre].end() && (!connected); connIt++) {
                    if (connIt->connId == connId) {
                        // connect two neurons
                        connectNeurons(netIdPre, gGrpIdPre, gGrpIdPost, globalNIdPre, globalNIdPost, connId, weight, maxWeight, delay, netIdPost);
                        connected = true;
                        // update connection information
                        connIt->numberOfConnections++;

                        // fix me maybe: numPostSynapses and numPreSynpases could also be loaded from saved information directly to save time
                        // the current implementation is a safer one
                        GroupConfigMD targetGrp;
                        std::list<GroupConfigMD>::iterator grpIt;

                        targetGrp.gGrpId = gGrpIdPre;
                        grpIt = std::find(groupPartitionLists[netIdPre].begin(), groupPartitionLists[netIdPre].end(), targetGrp);
                        assert(grpIt != groupPartitionLists[netIdPre].end());
                        grpIt->numPostSynapses += 1;

                        targetGrp.gGrpId = gGrpIdPost;
                        grpIt = std::find(groupPartitionLists[netIdPre].begin(), groupPartitionLists[netIdPre].end(), targetGrp);
                        assert(grpIt != groupPartitionLists[netIdPost].end());
                        grpIt->numPreSynapses += 1;

                        // update group information in another network
                        targetGrp.gGrpId = gGrpIdPre;
                        grpIt = std::find(groupPartitionLists[netIdPost].begin(), groupPartitionLists[netIdPost].end(), targetGrp);
                        assert(grpIt != groupPartitionLists[netIdPost].end());
                        grpIt->numPostSynapses += 1;

                        targetGrp.gGrpId = gGrpIdPost;
                        grpIt = std::find(groupPartitionLists[netIdPost].begin(), groupPartitionLists[netIdPost].end(), targetGrp);
                        assert(grpIt != groupPartitionLists[netIdPost].end());
                        grpIt->numPreSynapses += 1;
                    }
                }
            }
        }
    }

    fseek(loadSimFID,file_position,SEEK_SET);

    return 0;
}

void SNN::generateRuntimeSNN() {
    // 1. genearte configurations for the simulation
    // generate (copy) group configs from groupPartitionLists[]
    generateRuntimeGroupConfigs();

    // generate (copy) connection configs from localConnectLists[] and exeternalConnectLists[]
    generateRuntimeConnectConfigs();

    // generate local network configs and accquire maximum size of rumtime data
    generateRuntimeNetworkConfigs();

    // 2. allocate space of runtime data used by the manager
    // - allocate firingTableD1, firingTableD2, timeTableD1, timeTableD2
    // - reset firingTableD1, firingTableD2, timeTableD1, timeTableD2
    allocateManagerSpikeTables();
    // - allocate voltage, recovery, Izh_a, Izh_b, Izh_c, Izh_d, current, extCurrent, gAMPA, gNMDA, gGABAa, gGABAb
    // lastSpikeTime, nSpikeCnt, stpu, stpx, Npre, Npre_plastic, Npost, cumulativePost, cumulativePre,
    // postSynapticIds, postDelayInfo, wt, wtChange, synSpikeTime, maxSynWt, preSynapticIds, grpIds, connIdsPreIdx,
    // grpDA, grp5HT, grpACh, grpNE, grpDABuffer, grp5HTBuffer, grpAChBuffer, grpNEBuffer, mulSynFast, mulSynSlow
    // - reset all above
    allocateManagerRuntimeData();

    // 3. initialize manager runtime data according to partitions (i.e., local networks)
    // 4a. allocate appropriate memory space (e.g., main memory (CPU) or device memory (GPU)).
    // 4b. load (copy) them to appropriate memory space for execution
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            KERNEL_INFO("");
            if (netId < CPU_RUNTIME_BASE) {
                KERNEL_INFO("*****************      Initializing GPU %d Runtime      *************************", netId);
            } else {
                KERNEL_INFO("*****************      Initializing CPU %d Runtime      *************************", (netId - CPU_RUNTIME_BASE));
            }
            // build the runtime data according to local network, group, connection configuirations

            // generate runtime data for each group
            for(int lGrpId = 0; lGrpId < networkConfigs[netId].numGroups; lGrpId++) {
                // local poisson neurons
                if (groupConfigs[netId][lGrpId].netId == netId && (groupConfigs[netId][lGrpId].Type & POISSON_NEURON)) {
                    // - init lstSpikeTime
                    // - reset avgFiring, stpu, stpx
                    // - init stpx
                    generatePoissonGroupRuntime(netId, lGrpId);
                }
                // local regular neurons
                if (groupConfigs[netId][lGrpId].netId == netId && !(groupConfigs[netId][lGrpId].Type & POISSON_NEURON)) {
                    // - init grpDA, grp5HT, grpACh, grpNE
                    // - init Izh_a, Izh_b, Izh_c, Izh_d, voltage, recovery, stpu, stpx
                    // - init baseFiring, avgFiring
                    // - init lastSpikeTime
                    generateGroupRuntime(netId, lGrpId);
                }
            }

            // - init grpIds
            for (int lNId = 0; lNId < networkConfigs[netId].numNAssigned; lNId++) {
                managerRuntimeData.grpIds[lNId] = -1;
                for(int lGrpId = 0; lGrpId < networkConfigs[netId].numGroupsAssigned; lGrpId++) {
                    if (lNId >= groupConfigs[netId][lGrpId].lStartN && lNId <= groupConfigs[netId][lGrpId].lEndN) {
                        managerRuntimeData.grpIds[lNId] = (short int)lGrpId;
                        break;
                    }
                }
                assert(managerRuntimeData.grpIds[lNId] != -1);
            }

            // - init mulSynFast, mulSynSlow
            // - init Npre, Npre_plastic, Npost, cumulativePre, cumulativePost, preSynapticIds, postSynapticIds, postDelayInfo
            // - init wt, maxSynWt
            generateConnectionRuntime(netId);

            generateCompConnectionRuntime(netId);

            // - reset current
            resetCurrent(netId);
            // - reset conductance
            resetConductances(netId);

            // - reset wtChange
            // - init synSpikeTime
            resetSynapse(netId, false);

            allocateSNN(netId);
        }
    }

    // count allocated CPU/GPU runtime
    numGPUs = 0; numCores = 0;
    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (netId < CPU_RUNTIME_BASE && runtimeData[netId].allocated)
            numGPUs++;
        if (netId >= CPU_RUNTIME_BASE && runtimeData[netId].allocated)
            numCores++;
    }

    // 5. declare the spiking neural network is excutable
    snnState = EXECUTABLE_SNN;
}

void SNN::resetConductances(int netId) {
#ifdef LN_I_CALC_TYPES
    // always allocate memory for explicid rise/decay as it may be partitionated by groups
    if (networkConfigs[netId].sim_with_conductances) {
        memset(managerRuntimeData.gAMPA, 0, sizeof(float) * networkConfigs[netId].numNReg);
        memset(managerRuntimeData.gNMDA_r, 0, sizeof(float) * networkConfigs[netId].numNReg);
        memset(managerRuntimeData.gNMDA_d, 0, sizeof(float) * networkConfigs[netId].numNReg);
        memset(managerRuntimeData.gNMDA, 0, sizeof(float) * networkConfigs[netId].numNReg);
        memset(managerRuntimeData.gGABAa, 0, sizeof(float) * networkConfigs[netId].numNReg);
        memset(managerRuntimeData.gGABAb_r, 0, sizeof(float) * networkConfigs[netId].numNReg);
        memset(managerRuntimeData.gGABAb_d, 0, sizeof(float) * networkConfigs[netId].numNReg);
        memset(managerRuntimeData.gGABAb, 0, sizeof(float) * networkConfigs[netId].numNReg);
    }
#else
    if (networkConfigs[netId].sim_with_conductances) {
        memset(managerRuntimeData.gAMPA, 0, sizeof(float) * networkConfigs[netId].numNReg);
        if (networkConfigs[netId].sim_with_NMDA_rise) {
            memset(managerRuntimeData.gNMDA_r, 0, sizeof(float) * networkConfigs[netId].numNReg);
            memset(managerRuntimeData.gNMDA_d, 0, sizeof(float) * networkConfigs[netId].numNReg);
        } else {
            memset(managerRuntimeData.gNMDA, 0, sizeof(float) * networkConfigs[netId].numNReg);
        }
        memset(managerRuntimeData.gGABAa, 0, sizeof(float) * networkConfigs[netId].numNReg);
        if (networkConfigs[netId].sim_with_GABAb_rise) {
            memset(managerRuntimeData.gGABAb_r, 0, sizeof(float) * networkConfigs[netId].numNReg);
            memset(managerRuntimeData.gGABAb_d, 0, sizeof(float) * networkConfigs[netId].numNReg);
        } else {
            memset(managerRuntimeData.gGABAb, 0, sizeof(float) * networkConfigs[netId].numNReg);
        }
    }
#endif
}

void SNN::resetCurrent(int netId) {
    assert(managerRuntimeData.current != NULL);
    memset(managerRuntimeData.current, 0, sizeof(float) * networkConfigs[netId].numNReg);
}

// FIXME: unused function
void SNN::resetFiringInformation() {
    // Reset firing tables and time tables to default values..

    // reset various times...
    simTimeMs  = 0;
    simTimeSec = 0;
    simTime    = 0;

    // reset the propogation Buffer.
    resetPropogationBuffer();
    // reset Timing  Table..
    resetTimeTable();
}

void SNN::resetTiming() {
    prevExecutionTime = cumExecutionTime;
    executionTime = 0.0f;
}

void SNN::resetNeuromodulator(int netId, int lGrpId) {
    managerRuntimeData.grpDA[lGrpId] = groupConfigs[netId][lGrpId].baseDP;
    managerRuntimeData.grp5HT[lGrpId] = groupConfigs[netId][lGrpId].base5HT;
    managerRuntimeData.grpACh[lGrpId] = groupConfigs[netId][lGrpId].baseACh;
    managerRuntimeData.grpNE[lGrpId] = groupConfigs[netId][lGrpId].baseNE;
}

void SNN::resetNeuron(int netId, int lGrpId, int lNId) {
    int gGrpId = groupConfigs[netId][lGrpId].gGrpId; // get global group id
    assert(lNId < networkConfigs[netId].numNReg);

    if (groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_a == -1 && groupConfigMap[gGrpId].isLIF == 0) {
        KERNEL_ERROR("setNeuronParameters must be called for group %s (G:%d,L:%d)",groupConfigMap[gGrpId].grpName.c_str(), gGrpId, lGrpId);
        exitSimulation(KERNEL_ERROR_IZH_PARAMS_NOT_SET);
    }

    if (groupConfigMap[gGrpId].neuralDynamicsConfig.lif_tau_m == -1 && groupConfigMap[gGrpId].isLIF == 1) {
        KERNEL_ERROR("setNeuronParametersLIF must be called for group %s (G:%d,L:%d)",groupConfigMap[gGrpId].grpName.c_str(), gGrpId, lGrpId);
        exitSimulation(KERNEL_ERROR_LIF_PARAMS_NOT_SET);
    }

    managerRuntimeData.Izh_a[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_a + groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_a_sd * (float)drand48();
    managerRuntimeData.Izh_b[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_b + groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_b_sd * (float)drand48();
    managerRuntimeData.Izh_c[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_c + groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_c_sd * (float)drand48();
    managerRuntimeData.Izh_d[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_d + groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_d_sd * (float)drand48();
    managerRuntimeData.Izh_C[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_C + groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_C_sd * (float)drand48();
    managerRuntimeData.Izh_k[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_k + groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_k_sd * (float)drand48();
    managerRuntimeData.Izh_vr[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vr + groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vr_sd * (float)drand48();
    managerRuntimeData.Izh_vt[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vt + groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vt_sd * (float)drand48();
    managerRuntimeData.Izh_vpeak[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vpeak + groupConfigMap[gGrpId].neuralDynamicsConfig.Izh_vpeak_sd * (float)drand48();
    managerRuntimeData.lif_tau_m[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.lif_tau_m;
    managerRuntimeData.lif_tau_ref[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.lif_tau_ref;
    managerRuntimeData.lif_tau_ref_c[lNId] = 0;
    managerRuntimeData.lif_vTh[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.lif_vTh;
    managerRuntimeData.lif_vReset[lNId] = groupConfigMap[gGrpId].neuralDynamicsConfig.lif_vReset;

    // calculate gain and bias for the lif neuron
    if (groupConfigs[netId][lGrpId].isLIF){
        // gain an bias of the LIF neuron is calculated based on Membrane resistance
        float rmRange = (float)(groupConfigMap[gGrpId].neuralDynamicsConfig.lif_maxRmem - groupConfigMap[gGrpId].neuralDynamicsConfig.lif_minRmem);
        float minRmem = (float)groupConfigMap[gGrpId].neuralDynamicsConfig.lif_minRmem;
        managerRuntimeData.lif_bias[lNId] = 0.0f;
        managerRuntimeData.lif_gain[lNId] = minRmem + rmRange * (float)drand48();
    }

    managerRuntimeData.nextVoltage[lNId] = managerRuntimeData.voltage[lNId] = groupConfigs[netId][lGrpId].isLIF ? managerRuntimeData.lif_vReset[lNId] : (groupConfigs[netId][lGrpId].withParamModel_9 ? managerRuntimeData.Izh_vr[lNId] : managerRuntimeData.Izh_c[lNId]);
    managerRuntimeData.recovery[lNId] = groupConfigs[netId][lGrpId].withParamModel_9 ? 0.0f : managerRuntimeData.Izh_b[lNId] * managerRuntimeData.voltage[lNId];

    if (groupConfigs[netId][lGrpId].WithHomeostasis) {
        // set the baseFiring with some standard deviation.
        if (drand48() > 0.5) {
            managerRuntimeData.baseFiring[lNId] = groupConfigMap[gGrpId].homeoConfig.baseFiring + groupConfigMap[gGrpId].homeoConfig.baseFiringSD * -log(drand48());
        } else {
            managerRuntimeData.baseFiring[lNId] = groupConfigMap[gGrpId].homeoConfig.baseFiring - groupConfigMap[gGrpId].homeoConfig.baseFiringSD * -log(drand48());
            if(managerRuntimeData.baseFiring[lNId] < 0.1f) managerRuntimeData.baseFiring[lNId] = 0.1f;
        }

        if (groupConfigMap[gGrpId].homeoConfig.baseFiring != 0.0f) {
            managerRuntimeData.avgFiring[lNId] = managerRuntimeData.baseFiring[lNId];
        } else {
            managerRuntimeData.baseFiring[lNId] = 0.0f;
            managerRuntimeData.avgFiring[lNId]  = 0.0f;
        }
    }

    managerRuntimeData.lastSpikeTime[lNId] = MAX_SIMULATION_TIME;

    if(groupConfigs[netId][lGrpId].WithSTP) {
        for (int j = 0; j < networkConfigs[netId].maxDelay + 1; j++) { // is of size maxDelay_+1
            int index = STP_BUF_POS(lNId, j, networkConfigs[netId].maxDelay);
            managerRuntimeData.stpu[index] = 0.0f;
            managerRuntimeData.stpx[index] = 1.0f;
        }
    }
}

void SNN::resetMonitors(bool deallocate) {
    // order is important! monitor objects might point to SNN or CARLsim,
    // need to deallocate them first


    // -------------- DEALLOCATE MONITOR OBJECTS ---------------------- //

    // delete all SpikeMonitor objects
    // don't kill SpikeMonitorCore objects, they will get killed automatically
    for (int i=0; i<numSpikeMonitor; i++) {
        if (spikeMonList[i]!=NULL && deallocate) delete spikeMonList[i];
        spikeMonList[i]=NULL;
    }

    // delete all NeuronMonitor objects
    // don't kill NeuronMonitorCore objects, they will get killed automatically
    for (int i = 0; i<numNeuronMonitor; i++) {
        if (neuronMonList[i] != NULL && deallocate) delete neuronMonList[i];
        neuronMonList[i] = NULL;
    }

    // delete all GroupMonitor objects
    // don't kill GroupMonitorCore objects, they will get killed automatically
    for (int i=0; i<numGroupMonitor; i++) {
        if (groupMonList[i]!=NULL && deallocate) delete groupMonList[i];
        groupMonList[i]=NULL;
    }

    // delete all ConnectionMonitor objects
    // don't kill ConnectionMonitorCore objects, they will get killed automatically
    for (int i=0; i<numConnectionMonitor; i++) {
        if (connMonList[i]!=NULL && deallocate) delete connMonList[i];
        connMonList[i]=NULL;
    }
}

void SNN::resetGroupConfigs(bool deallocate) {
    // clear all existing group configurations
    if (deallocate) groupConfigMap.clear();
}

void SNN::resetConnectionConfigs(bool deallocate) {
    // clear all existing connection configurations
    if (deallocate) connectConfigMap.clear();
}

void SNN::deleteManagerRuntimeData() {
    if (spikeBuf!=NULL) delete spikeBuf;
    if (managerRuntimeData.spikeGenBits!=NULL) delete[] managerRuntimeData.spikeGenBits;
    spikeBuf=NULL; managerRuntimeData.spikeGenBits=NULL;

    // LN20201103 featSpikes poisson
    if (managerRuntimeData.randNum!=NULL) {
        delete[] managerRuntimeData.randNum; 
        managerRuntimeData.randNum = NULL;
    }
    if (managerRuntimeData.poissonFireRate!=NULL) {
        delete[] managerRuntimeData.poissonFireRate; 
        managerRuntimeData.poissonFireRate = NULL;
    }

    // clear data (i.e., concentration of neuromodulator) of groups
    if (managerRuntimeData.grpDA != NULL) delete [] managerRuntimeData.grpDA;
    if (managerRuntimeData.grp5HT != NULL) delete [] managerRuntimeData.grp5HT;
    if (managerRuntimeData.grpACh != NULL) delete [] managerRuntimeData.grpACh;
    if (managerRuntimeData.grpNE != NULL) delete [] managerRuntimeData.grpNE;
    managerRuntimeData.grpDA = NULL;
    managerRuntimeData.grp5HT = NULL;
    managerRuntimeData.grpACh = NULL;
    managerRuntimeData.grpNE = NULL;

    // clear assistive data buffer for group monitor
    if (managerRuntimeData.grpDABuffer != NULL) delete [] managerRuntimeData.grpDABuffer;
    if (managerRuntimeData.grp5HTBuffer != NULL) delete [] managerRuntimeData.grp5HTBuffer;
    if (managerRuntimeData.grpAChBuffer != NULL) delete [] managerRuntimeData.grpAChBuffer;
    if (managerRuntimeData.grpNEBuffer != NULL) delete [] managerRuntimeData.grpNEBuffer;
    managerRuntimeData.grpDABuffer = NULL; managerRuntimeData.grp5HTBuffer = NULL;
    managerRuntimeData.grpAChBuffer = NULL; managerRuntimeData.grpNEBuffer = NULL;

    // -------------- DEALLOCATE CORE OBJECTS ---------------------- //

    if (managerRuntimeData.voltage!=NULL) delete[] managerRuntimeData.voltage;
    if (managerRuntimeData.nextVoltage != NULL) delete[] managerRuntimeData.nextVoltage;
    if (managerRuntimeData.recovery!=NULL) delete[] managerRuntimeData.recovery;
    if (managerRuntimeData.current!=NULL) delete[] managerRuntimeData.current;
    if (managerRuntimeData.extCurrent!=NULL) delete[] managerRuntimeData.extCurrent;
    if (managerRuntimeData.totalCurrent != NULL) delete[] managerRuntimeData.totalCurrent;
    if (managerRuntimeData.curSpike != NULL) delete[] managerRuntimeData.curSpike;
    if (managerRuntimeData.nVBuffer != NULL) delete[] managerRuntimeData.nVBuffer;
    if (managerRuntimeData.nUBuffer != NULL) delete[] managerRuntimeData.nUBuffer;
    if (managerRuntimeData.nIBuffer != NULL) delete[] managerRuntimeData.nIBuffer;
    managerRuntimeData.voltage=NULL; managerRuntimeData.recovery=NULL; managerRuntimeData.current=NULL; managerRuntimeData.extCurrent=NULL;
    managerRuntimeData.nextVoltage = NULL; managerRuntimeData.totalCurrent = NULL; managerRuntimeData.curSpike = NULL;
    managerRuntimeData.nVBuffer = NULL; managerRuntimeData.nUBuffer = NULL; managerRuntimeData.nIBuffer = NULL;

    if (managerRuntimeData.Izh_a!=NULL) delete[] managerRuntimeData.Izh_a;
    if (managerRuntimeData.Izh_b!=NULL) delete[] managerRuntimeData.Izh_b;
    if (managerRuntimeData.Izh_c!=NULL) delete[] managerRuntimeData.Izh_c;
    if (managerRuntimeData.Izh_d!=NULL) delete[] managerRuntimeData.Izh_d;
    if (managerRuntimeData.Izh_C!=NULL) delete[] managerRuntimeData.Izh_C;
    if (managerRuntimeData.Izh_k!=NULL) delete[] managerRuntimeData.Izh_k;
    if (managerRuntimeData.Izh_vr!=NULL) delete[] managerRuntimeData.Izh_vr;
    if (managerRuntimeData.Izh_vt!=NULL) delete[] managerRuntimeData.Izh_vt;
    if (managerRuntimeData.Izh_vpeak!=NULL) delete[] managerRuntimeData.Izh_vpeak;
    managerRuntimeData.Izh_a=NULL; managerRuntimeData.Izh_b=NULL; managerRuntimeData.Izh_c=NULL; managerRuntimeData.Izh_d=NULL;
    managerRuntimeData.Izh_C = NULL; managerRuntimeData.Izh_k = NULL; managerRuntimeData.Izh_vr = NULL; managerRuntimeData.Izh_vt = NULL; managerRuntimeData.Izh_vpeak = NULL;

    if (managerRuntimeData.lif_tau_m!=NULL) delete[] managerRuntimeData.lif_tau_m;
    if (managerRuntimeData.lif_tau_ref!=NULL) delete[] managerRuntimeData.lif_tau_ref;
    if (managerRuntimeData.lif_tau_ref_c!=NULL) delete[] managerRuntimeData.lif_tau_ref_c;
    if (managerRuntimeData.lif_vTh!=NULL) delete[] managerRuntimeData.lif_vTh;
    if (managerRuntimeData.lif_vReset!=NULL) delete[] managerRuntimeData.lif_vReset;
    if (managerRuntimeData.lif_gain!=NULL) delete[] managerRuntimeData.lif_gain;
    if (managerRuntimeData.lif_bias!=NULL) delete[] managerRuntimeData.lif_bias;
    managerRuntimeData.lif_tau_m=NULL; managerRuntimeData.lif_tau_ref=NULL; managerRuntimeData.lif_vTh=NULL;
    managerRuntimeData.lif_vReset=NULL; managerRuntimeData.lif_gain=NULL; managerRuntimeData.lif_bias=NULL;
    managerRuntimeData.lif_tau_ref_c=NULL;

    if (managerRuntimeData.Npre!=NULL) delete[] managerRuntimeData.Npre;
    if (managerRuntimeData.Npre_plastic!=NULL) delete[] managerRuntimeData.Npre_plastic;
    if (managerRuntimeData.Npost!=NULL) delete[] managerRuntimeData.Npost;
    managerRuntimeData.Npre=NULL; managerRuntimeData.Npre_plastic=NULL; managerRuntimeData.Npost=NULL;

    if (managerRuntimeData.cumulativePre!=NULL) delete[] managerRuntimeData.cumulativePre;
    if (managerRuntimeData.cumulativePost!=NULL) delete[] managerRuntimeData.cumulativePost;
    managerRuntimeData.cumulativePre=NULL; managerRuntimeData.cumulativePost=NULL;

    if (managerRuntimeData.gAMPA!=NULL) delete[] managerRuntimeData.gAMPA;
    if (managerRuntimeData.gNMDA!=NULL) delete[] managerRuntimeData.gNMDA;
    if (managerRuntimeData.gNMDA_r!=NULL) delete[] managerRuntimeData.gNMDA_r;
    if (managerRuntimeData.gNMDA_d!=NULL) delete[] managerRuntimeData.gNMDA_d;
    if (managerRuntimeData.gGABAa!=NULL) delete[] managerRuntimeData.gGABAa;
    if (managerRuntimeData.gGABAb!=NULL) delete[] managerRuntimeData.gGABAb;
    if (managerRuntimeData.gGABAb_r!=NULL) delete[] managerRuntimeData.gGABAb_r;
    if (managerRuntimeData.gGABAb_d!=NULL) delete[] managerRuntimeData.gGABAb_d;
    managerRuntimeData.gAMPA=NULL; managerRuntimeData.gNMDA=NULL; managerRuntimeData.gNMDA_r=NULL; managerRuntimeData.gNMDA_d=NULL;
    managerRuntimeData.gGABAa=NULL; managerRuntimeData.gGABAb=NULL; managerRuntimeData.gGABAb_r=NULL; managerRuntimeData.gGABAb_d=NULL;

    if (managerRuntimeData.stpu!=NULL) delete[] managerRuntimeData.stpu;
    if (managerRuntimeData.stpx!=NULL) delete[] managerRuntimeData.stpx;
    managerRuntimeData.stpu=NULL; managerRuntimeData.stpx=NULL;

    if (managerRuntimeData.avgFiring!=NULL) delete[] managerRuntimeData.avgFiring;
    if (managerRuntimeData.baseFiring!=NULL) delete[] managerRuntimeData.baseFiring;
    managerRuntimeData.avgFiring=NULL; managerRuntimeData.baseFiring=NULL;

    if (managerRuntimeData.lastSpikeTime!=NULL) delete[] managerRuntimeData.lastSpikeTime;
    if (managerRuntimeData.synSpikeTime !=NULL) delete[] managerRuntimeData.synSpikeTime;
    if (managerRuntimeData.nSpikeCnt!=NULL) delete[] managerRuntimeData.nSpikeCnt;
    managerRuntimeData.lastSpikeTime=NULL; managerRuntimeData.synSpikeTime=NULL; managerRuntimeData.nSpikeCnt=NULL;

    if (managerRuntimeData.postDelayInfo!=NULL) delete[] managerRuntimeData.postDelayInfo;
    if (managerRuntimeData.preSynapticIds!=NULL) delete[] managerRuntimeData.preSynapticIds;
    if (managerRuntimeData.postSynapticIds!=NULL) delete[] managerRuntimeData.postSynapticIds;
    managerRuntimeData.postDelayInfo=NULL; managerRuntimeData.preSynapticIds=NULL; managerRuntimeData.postSynapticIds=NULL;

    if (managerRuntimeData.wt!=NULL) delete[] managerRuntimeData.wt;
    if (managerRuntimeData.maxSynWt!=NULL) delete[] managerRuntimeData.maxSynWt;
    if (managerRuntimeData.wtChange !=NULL) delete[] managerRuntimeData.wtChange;
    managerRuntimeData.wt=NULL; managerRuntimeData.maxSynWt=NULL; managerRuntimeData.wtChange=NULL;

    if (mulSynFast!=NULL) delete[] mulSynFast;
    if (mulSynSlow!=NULL) delete[] mulSynSlow;
    if (managerRuntimeData.connIdsPreIdx!=NULL) delete[] managerRuntimeData.connIdsPreIdx;
    mulSynFast=NULL; mulSynSlow=NULL; managerRuntimeData.connIdsPreIdx=NULL;

    if (managerRuntimeData.grpIds!=NULL) delete[] managerRuntimeData.grpIds;
    managerRuntimeData.grpIds=NULL;

    if (managerRuntimeData.timeTableD2 != NULL) delete [] managerRuntimeData.timeTableD2;
    if (managerRuntimeData.timeTableD1 != NULL) delete [] managerRuntimeData.timeTableD1;
    managerRuntimeData.timeTableD2 = NULL; managerRuntimeData.timeTableD1 = NULL;

    if (managerRuntimeData.firingTableD2!=NULL) delete[] managerRuntimeData.firingTableD2;
    if (managerRuntimeData.firingTableD1!=NULL) delete[] managerRuntimeData.firingTableD1;
    //if (managerRuntimeData.firingTableD2!=NULL) CUDA_CHECK_ERRORS(cudaFreeHost(managerRuntimeData.firingTableD2));
    //if (managerRuntimeData.firingTableD1!=NULL) CUDA_CHECK_ERRORS(cudaFreeHost(managerRuntimeData.firingTableD1));
    managerRuntimeData.firingTableD2 = NULL; managerRuntimeData.firingTableD1 = NULL;

#ifdef LN_AXON_PLAST
    if (managerRuntimeData.firingTimesD2 != NULL) delete[] managerRuntimeData.firingTimesD2;
    managerRuntimeData.firingTimesD2 = NULL;
#endif

    if (managerRuntimeData.extFiringTableD2!=NULL) delete[] managerRuntimeData.extFiringTableD2;
    if (managerRuntimeData.extFiringTableD1!=NULL) delete[] managerRuntimeData.extFiringTableD1;
    //if (managerRuntimeData.extFiringTableD2!=NULL) CUDA_CHECK_ERRORS(cudaFreeHost(managerRuntimeData.extFiringTableD2));
    //if (managerRuntimeData.extFiringTableD1!=NULL) CUDA_CHECK_ERRORS(cudaFreeHost(managerRuntimeData.extFiringTableD1));
    managerRuntimeData.extFiringTableD2 = NULL; managerRuntimeData.extFiringTableD1 = NULL;

    if (managerRuntimeData.extFiringTableEndIdxD1 != NULL) delete[] managerRuntimeData.extFiringTableEndIdxD1;
    if (managerRuntimeData.extFiringTableEndIdxD2 != NULL) delete[] managerRuntimeData.extFiringTableEndIdxD2;
    //if (managerRuntimeData.extFiringTableEndIdxD1 != NULL) CUDA_CHECK_ERRORS(cudaFreeHost(managerRuntimeData.extFiringTableEndIdxD1));
    //if (managerRuntimeData.extFiringTableEndIdxD2 != NULL) CUDA_CHECK_ERRORS(cudaFreeHost(managerRuntimeData.extFiringTableEndIdxD2));
    managerRuntimeData.extFiringTableEndIdxD1 = NULL; managerRuntimeData.extFiringTableEndIdxD2 = NULL;
}

void SNN::resetPoissonNeuron(int netId, int lGrpId, int lNId) {
    assert(lNId < networkConfigs[netId].numN);
    managerRuntimeData.lastSpikeTime[lNId] = MAX_SIMULATION_TIME;
    if (groupConfigs[netId][lGrpId].WithHomeostasis)
        managerRuntimeData.avgFiring[lNId] = 0.0f;

    if (groupConfigs[netId][lGrpId].WithSTP) {
        for (int j = 0; j < networkConfigs[netId].maxDelay + 1; j++) { // is of size maxDelay_+1
            int index = STP_BUF_POS(lNId, j, networkConfigs[netId].maxDelay);
            managerRuntimeData.stpu[index] = 0.0f;
            managerRuntimeData.stpx[index] = 1.0f;
        }
    }
}

void SNN::resetPropogationBuffer() {
    // FIXME: why 1023?
    spikeBuf->reset(0, 1023);
}

//Reset wt, wtChange, pre-firing time values to default values, rewritten to
//integrate changes between JMN and MDR -- KDC
//if changeWeights is false, we should keep the values of the weights as they currently
//are but we should be able to change them to plastic or fixed synapses. -- KDC
// FIXME: imlement option of resetting weights
void SNN::resetSynapse(int netId, bool changeWeights) {
    memset(managerRuntimeData.wtChange, 0, sizeof(float) * networkConfigs[netId].numPreSynNet); // reset the synaptic derivatives

    for (int syn = 0; syn < networkConfigs[netId].numPreSynNet; syn++)
        managerRuntimeData.synSpikeTime[syn] = MAX_SIMULATION_TIME; // reset the spike time of each syanpse
}

void SNN::resetTimeTable() {
    memset(managerRuntimeData.timeTableD2, 0, sizeof(int) * (1000 + glbNetworkConfig.maxDelay + 1));
    memset(managerRuntimeData.timeTableD1, 0, sizeof(int) * (1000 + glbNetworkConfig.maxDelay + 1));
}

void SNN::resetFiringTable() {
    memset(managerRuntimeData.firingTableD2, 0, sizeof(int) * managerRTDSize.maxMaxSpikeD2);
    memset(managerRuntimeData.firingTableD1, 0, sizeof(int) * managerRTDSize.maxMaxSpikeD1);
#ifdef LN_AXON_PLAST
    memset(managerRuntimeData.firingTimesD2, 0, sizeof(unsigned int) * managerRTDSize.maxMaxSpikeD2);
#endif
    memset(managerRuntimeData.extFiringTableEndIdxD2, 0, sizeof(int) * managerRTDSize.maxNumGroups);
    memset(managerRuntimeData.extFiringTableEndIdxD1, 0, sizeof(int) * managerRTDSize.maxNumGroups);
    memset(managerRuntimeData.extFiringTableD2, 0, sizeof(int*) * managerRTDSize.maxNumGroups);
    memset(managerRuntimeData.extFiringTableD1, 0, sizeof(int*) * managerRTDSize.maxNumGroups);
}

void SNN::resetSpikeCnt(int gGrpId) {
    assert(gGrpId >= ALL);

    if (gGrpId == ALL) {
        #ifndef __NO_PTHREADS__ // POSIX
            pthread_t threads[numCores + 1]; // 1 additional array size if numCores == 0, it may work though bad practice
            cpu_set_t cpus;
            ThreadStruct argsThreadRoutine[numCores + 1]; // same as above, +1 array size
            int threadCount = 0;
        #endif

        for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
            if (!groupPartitionLists[netId].empty()) {
                if (netId < CPU_RUNTIME_BASE) // GPU runtime
                    resetSpikeCnt_GPU(netId, ALL);
                else{ // CPU runtime
                    #ifdef __NO_PTHREADS__
                        resetSpikeCnt_CPU(netId, ALL);
                    #else // Linux or MAC
                        pthread_attr_t attr;
                        pthread_attr_init(&attr);
                        CPU_ZERO(&cpus);
                        CPU_SET(threadCount%NUM_CPU_CORES, &cpus);
                        pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);

                        argsThreadRoutine[threadCount].snn_pointer = this;
                        argsThreadRoutine[threadCount].netId = netId;
                        argsThreadRoutine[threadCount].lGrpId = ALL;
                        argsThreadRoutine[threadCount].startIdx = 0;
                        argsThreadRoutine[threadCount].endIdx = 0;
                        argsThreadRoutine[threadCount].GtoLOffset = 0;

                        pthread_create(&threads[threadCount], &attr, &SNN::helperResetSpikeCnt_CPU, (void*)&argsThreadRoutine[threadCount]);
                        pthread_attr_destroy(&attr);
                        threadCount++;
                    #endif
                }
            }
        }

        #ifndef __NO_PTHREADS__ // POSIX
            // join all the threads
            for (int i=0; i<threadCount; i++){
                pthread_join(threads[i], NULL);
            }
        #endif
    }
    else {
        int netId = groupConfigMDMap[gGrpId].netId;
        int lGrpId = groupConfigMDMap[gGrpId].lGrpId;

        if (netId < CPU_RUNTIME_BASE) // GPU runtime
            resetSpikeCnt_GPU(netId, lGrpId);
        else // CPU runtime
            resetSpikeCnt_CPU(netId, lGrpId);
    }
}


inline SynInfo SNN::SET_CONN_ID(int nId, int sId, int grpId) {
    if (grpId > GROUP_ID_MASK) {
        KERNEL_ERROR("Error: Group Id (%d) exceeds maximum limit (%d)", grpId, GROUP_ID_MASK);
        exitSimulation(ID_OVERFLOW_ERROR);
    }

    SynInfo synInfo;
    //p.postId = (((sid)<<CONN_SYN_NEURON_BITS)+((nid)&CONN_SYN_NEURON_MASK));
    //p.grpId  = grpId;
    synInfo.gsId = ((grpId << NUM_SYNAPSE_BITS) | sId);
    synInfo.nId = nId;

    return synInfo;
}


void SNN::setGrpTimeSlice(int gGrpId, int timeSlice) {
    if (gGrpId == ALL) {
        for(int grpId = 0; grpId < numGroups; grpId++) {
            if (groupConfigMap[grpId].isSpikeGenerator)
                setGrpTimeSlice(grpId, timeSlice);
        }
    } else {
        assert((timeSlice > 0 ) && (timeSlice <= MAX_TIME_SLICE));
        // the group should be poisson spike generator group
        groupConfigMDMap[gGrpId].currTimeSlice = timeSlice;
    }
}

// method to set const member randSeed_
int SNN::setRandSeed(int seed) {
    if (seed<0)
        return time(NULL);
    else if(seed==0)
        return 123;
    else
        return seed;
}

void SNN::fillSpikeGenBits(int netId) {
    SpikeBuffer::SpikeIterator spikeBufIter;
    SpikeBuffer::SpikeIterator spikeBufIterEnd = spikeBuf->back();

    // Covert spikes stored in spikeBuffer to SpikeGenBit
    for (spikeBufIter = spikeBuf->front(); spikeBufIter != spikeBufIterEnd; ++spikeBufIter) {
        // get the global neuron id and group id for this particular spike
        int gGrpId = spikeBufIter->grpId;

        if (groupConfigMDMap[gGrpId].netId == netId) {
            int lGrpId = groupConfigMDMap[gGrpId].lGrpId;
            int lNId = spikeBufIter->neurId /* gNId */ + groupConfigMDMap[gGrpId].GtoLOffset;

            // add spike to spikeGentBit
            assert(groupConfigMap[gGrpId].isSpikeGenerator == true);

            int nIdPos = (lNId - groupConfigs[netId][lGrpId].lStartN + groupConfigs[netId][lGrpId].Noffset);
            int nIdBitPos = nIdPos % 32;
            int nIdIndex = nIdPos / 32;

            assert(nIdIndex < (networkConfigs[netId].numNSpikeGen / 32 + 1));

            managerRuntimeData.spikeGenBits[nIdIndex] |= (1 << nIdBitPos);
        }
    }
}

void SNN::startTiming() { prevExecutionTime = cumExecutionTime; }
void SNN::stopTiming() {
    executionTime += (cumExecutionTime - prevExecutionTime);
    prevExecutionTime = cumExecutionTime;
}

// enters testing phase
// in testing, no weight changes can be made, allowing you to evaluate learned weights, etc.
void SNN::startTesting(bool shallUpdateWeights) {
    // because this can be called at any point in time, if we're off the 1-second grid, we want to make
    // sure to apply the accumulated weight changes to the weight matrix
    // but we don't reset the wt update interval counter
    if (shallUpdateWeights && !sim_in_testing) {
        // careful: need to temporarily adjust stdpScaleFactor to make this right
        if (wtANDwtChangeUpdateIntervalCnt_) {
            float storeScaleSTDP = stdpScaleFactor_;
            stdpScaleFactor_ = 1.0f/wtANDwtChangeUpdateIntervalCnt_;

            updateWeights();

            stdpScaleFactor_ = storeScaleSTDP;
        }
    }

    sim_in_testing = true;

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            networkConfigs[netId].sim_in_testing = true;
            updateNetworkConfig(netId); // update networkConfigRT struct (|TODO copy only a single boolean)
        }
    }
}

// exits testing phase
void SNN::stopTesting() {
    sim_in_testing = false;

    for (int netId = 0; netId < MAX_NET_PER_SNN; netId++) {
        if (!groupPartitionLists[netId].empty()) {
            networkConfigs[netId].sim_in_testing = false;
            updateNetworkConfig(netId); // update networkConfigRT struct (|TODO copy only a single boolean)
        }
    }
}

void SNN::updateConnectionMonitor(short int connId) {
    for (int monId=0; monId<numConnectionMonitor; monId++) {
        if (connId==ALL || connMonCoreList[monId]->getConnectId()==connId) {
            int timeInterval = connMonCoreList[monId]->getUpdateTimeIntervalSec();
            if (timeInterval==1 || timeInterval>1 && (getSimTime()%timeInterval)==0) {
                // this ConnectionMonitor wants periodic recording
                connMonCoreList[monId]->writeConnectFileSnapshot(simTime,
                    getWeightMatrix2D(connMonCoreList[monId]->getConnectId()));
            }
        }
    }
}

// FIXME: modify this for multi-GPUs
std::vector< std::vector<float> > SNN::getWeightMatrix2D(short int connId) {
    assert(connId > ALL); // ALL == -1
    std::vector< std::vector<float> > wtConnId;

    int grpIdPre = connectConfigMap[connId].grpSrc;
    int grpIdPost = connectConfigMap[connId].grpDest;

    int netIdPost = groupConfigMDMap[grpIdPost].netId;
    int lGrpIdPost = groupConfigMDMap[grpIdPost].lGrpId;

    // init weight matrix with right dimensions
    for (int i = 0; i < groupConfigMap[grpIdPre].numN; i++) {
        std::vector<float> wtSlice;
        for (int j = 0; j < groupConfigMap[grpIdPost].numN; j++) {
            wtSlice.push_back(NAN);
        }
        wtConnId.push_back(wtSlice);
    }

    // copy the weights for a given post-group from device
    // \TODO: check if the weights for this grpIdPost have already been copied
    // \TODO: even better, but tricky because of ordering, make copyWeightState connection-based

    assert(grpIdPost > ALL); // ALL == -1

    // Note, copyWeightState() also copies pre-connections information (e.g., Npre, Npre_plastic, cumulativePre, and preSynapticIds)
    fetchWeightState(netIdPost, lGrpIdPost);
    fetchConnIdsLookupArray(netIdPost);

    for (int lNIdPost = groupConfigs[netIdPost][lGrpIdPost].lStartN; lNIdPost <= groupConfigs[netIdPost][lGrpIdPost].lEndN; lNIdPost++) {
        unsigned int pos_ij = managerRuntimeData.cumulativePre[lNIdPost];
        for (int i = 0; i < managerRuntimeData.Npre[lNIdPost]; i++, pos_ij++) {
            // skip synapses that belong to a different connection ID
            if (managerRuntimeData.connIdsPreIdx[pos_ij] != connId) //connInfo->connId)
                continue;

            // find pre-neuron ID and update ConnectionMonitor container
            int lNIdPre = GET_CONN_NEURON_ID(managerRuntimeData.preSynapticIds[pos_ij]);
            int lGrpIdPre = GET_CONN_GRP_ID(managerRuntimeData.preSynapticIds[pos_ij]);
            wtConnId[lNIdPre - groupConfigs[netIdPost][lGrpIdPre].lStartN][lNIdPost - groupConfigs[netIdPost][lGrpIdPost].lStartN] =
                fabs(managerRuntimeData.wt[pos_ij]);
        }
    }

    return wtConnId;
}

void SNN::updateGroupMonitor(int gGrpId) {
    // don't continue if no group monitors in the network
    if (!numGroupMonitor)
        return;

    if (gGrpId == ALL) {
        for (int gGrpId = 0; gGrpId < numGroups; gGrpId++)
            updateGroupMonitor(gGrpId);
    } else {
        int netId = groupConfigMDMap[gGrpId].netId;
        int lGrpId = groupConfigMDMap[gGrpId].lGrpId;
        // update group monitor of a specific group
        // find index in group monitor arrays
        int monitorId = groupConfigMDMap[gGrpId].groupMonitorId;

        // don't continue if no group monitor enabled for this group
        if (monitorId < 0) return;

        // find last update time for this group
        GroupMonitorCore* grpMonObj = groupMonCoreList[monitorId];
        int lastUpdate = grpMonObj->getLastUpdated();

        // don't continue if time interval is zero (nothing to update)
        if (getSimTime() - lastUpdate <= 0)
            return;

        if (getSimTime() - lastUpdate > 1000)
            KERNEL_ERROR("updateGroupMonitor(grpId=%d) must be called at least once every second", gGrpId);

        // copy the group status (neuromodulators) to the manager runtime
        fetchGroupState(netId, lGrpId);

        // find the time interval in which to update group status
        // usually, we call updateGroupMonitor once every second, so the time interval is [0,1000)
        // however, updateGroupMonitor can be called at any time t \in [0,1000)... so we can have the cases
        // [0,t), [t,1000), and even [t1, t2)
        int numMsMin = lastUpdate % 1000; // lower bound is given by last time we called update
        int numMsMax = getSimTimeMs(); // upper bound is given by current time
        if (numMsMax == 0)
            numMsMax = 1000; // special case: full second
        assert(numMsMin < numMsMax);

        // current time is last completed second in milliseconds (plus t to be added below)
        // special case is after each completed second where !getSimTimeMs(): here we look 1s back
        int currentTimeSec = getSimTimeSec();
        if (!getSimTimeMs())
            currentTimeSec--;

        // save current time as last update time
        grpMonObj->setLastUpdated(getSimTime());

        // prepare fast access
        FILE* grpFileId = groupMonCoreList[monitorId]->getGroupFileId();
        bool writeGroupToFile = grpFileId != NULL;
        bool writeGroupToArray = grpMonObj->isRecording();
        //{ /featGroupMonitorFileWrite  
        //float data; 
        // LN20201003
        float data[4] = {.0f, .0f, .0f, .0f};  // DA,5HT,ACh,NE   --> solution: DA or all 4 -> 1 flag in monitor creation: full .. ..
            // -> header 
            // argumentation: most applications are DA , her a definitive need for OAT 
            // if "Krichmar.full" .. is implemented, usually all neurotransmitter work in concert, 
            // then all are neccessary  => flag:  DA only  or all neuro transmitter  4 ? 
        size_t nTransM = grpMonObj->isInAllMode()?4:1; // nTransmitter, FULL = 4,  DA = 1  --> init, mode , header
        //}

        // Read one peice of data at a time from the buffer and put the data to an appopriate monitor buffer. Later the user
        // may need need to dump these group status data to an output file
        for(int t = numMsMin; t < numMsMax; t++) {
            // fetch group status data, support dopamine concentration currently
            data[0] = managerRuntimeData.grpDABuffer[lGrpId * 1000 + t];                
            // prepared for full mode 
            if(grpMonObj->isInAllMode()) {
#define LN_FIX_GRP_ALL_BUFFER
                data[1] = managerRuntimeData.grp5HTBuffer[lGrpId * 1000 + t];  // ISSUE, does this work ? if no recording 
                //printf("data[1]=%f\n", data[1]); 
                data[2] = managerRuntimeData.grpAChBuffer[lGrpId * 1000 + t];
                //data[4] = managerRuntimeData.grpNEBuffer[lGrpId * 1000 + t]; // LN20201017 Ooopsi   1>c:\test\github\carlsim4\carlsim\kernel\src\snn_manager.cpp(6402): warning C4789: buffer 'data' of size 16 bytes will be overrun; 4 bytes will be written starting at offset 16
                data[3] = managerRuntimeData.grpNEBuffer[lGrpId * 1000 + t]; // LN20201017 Ooopsi   1>c:\test\github\carlsim4\carlsim\kernel\src\snn_manager.cpp(6402): warning C4789: buffer 'data' of size 16 bytes will be overrun; 4 bytes will be written starting at offset 16
            }
            // current time is last completed second plus whatever is leftover in t
            int time = currentTimeSec * 1000 + t;

            if (writeGroupToFile) {
                // TODO: write to group status file
                //{ /featGroupMonitorFileWrite LN20201003  --> to monitor DA concentration with OAT 
                size_t cnt;
                cnt = fwrite(&time, sizeof(int), 1, grpFileId); assert(cnt==1);
                cnt = fwrite(&data,  sizeof(float), nTransM, grpFileId); assert(cnt==nTransM); // DA[,HT,ACh,NE]
                //}
            }

            if (writeGroupToArray) {
                if(grpMonObj->isInAllMode()) 
                    grpMonObj->pushData(time, data[0], data[1], data[2], data[3]);  
                else 
                    grpMonObj->pushData(time, data[0]);  // LN backward compatibilty DA only
            }
        }

        if (grpFileId!=NULL) // flush group status file
            fflush(grpFileId);
    }
}

// FIXME: wrong to use groupConfigs[0]
void SNN::userDefinedSpikeGenerator(int gGrpId) {
    // \FIXME this function is a mess
    SpikeGeneratorCore* spikeGenFunc = groupConfigMap[gGrpId].spikeGenFunc;
    int netId = groupConfigMDMap[gGrpId].netId;
    int timeSlice = groupConfigMDMap[gGrpId].currTimeSlice;
    int currTime = simTime;
    bool done;

    fetchLastSpikeTime(netId);

    for(int gNId = groupConfigMDMap[gGrpId].gStartN; gNId <= groupConfigMDMap[gGrpId].gEndN; gNId++) {
        // start the time from the last time it spiked, that way we can ensure that the refractory period is maintained
        int lNId = gNId + groupConfigMDMap[gGrpId].GtoLOffset;
        int nextTime = managerRuntimeData.lastSpikeTime[lNId];
        if (nextTime == MAX_SIMULATION_TIME)
            nextTime = 0;

        // the end of the valid time window is either the length of the scheduling time slice from now (because that
        // is the max of the allowed propagated buffer size) or simply the end of the simulation
        int endOfTimeWindow = std::min<int>(currTime+timeSlice, simTimeRunStop);

        done = false;
        while (!done) {
            // generate the next spike time (nextSchedTime) from the nextSpikeTime callback
            int nextSchedTime = spikeGenFunc->nextSpikeTime(this, gGrpId, gNId - groupConfigMDMap[gGrpId].gStartN, currTime, nextTime, endOfTimeWindow);

            // the generated spike time is valid only if:
            // - it has not been scheduled before (nextSchedTime > nextTime)
            //    - but careful: we would drop spikes at t=0, because we cannot initialize nextTime to -1...
            // - it is within the scheduling time slice (nextSchedTime < endOfTimeWindow)
            // - it is not in the past (nextSchedTime >= currTime)
            if ((nextSchedTime==0 || nextSchedTime>nextTime) && nextSchedTime<endOfTimeWindow && nextSchedTime>=currTime) {
//              fprintf(stderr,"%u: spike scheduled for %d at %u\n",currTime, i-groupConfigs[0][grpId].StartN,nextSchedTime);
                // scheduled spike...
                // \TODO CPU mode does not check whether the same AER event has been scheduled before (bug #212)
                // check how GPU mode does it, then do the same here.
                nextTime = nextSchedTime;
                spikeBuf->schedule(gNId, gGrpId, nextTime - currTime);
            } else {
                done = true;
            }
        }
    }
}

void SNN::generateUserDefinedSpikes() {
    for(int gGrpId = 0; gGrpId < numGroups; gGrpId++) {
        if (groupConfigMap[gGrpId].isSpikeGenerator) {
            // This evaluation is done to check if its time to get new set of spikes..
            // check whether simTime has advance more than the current time slice, in which case we need to schedule
            // spikes for the next time slice
            // we always have to run this the first millisecond of a new runNetwork call; that is,
            // when simTime==simTimeRunStart
            if(((simTime - groupConfigMDMap[gGrpId].sliceUpdateTime) >= groupConfigMDMap[gGrpId].currTimeSlice || simTime == simTimeRunStart)) {
                int timeSlice = groupConfigMDMap[gGrpId].currTimeSlice;
                groupConfigMDMap[gGrpId].sliceUpdateTime = simTime;

                // we dont generate any poisson spike if during the
                // current call we might exceed the maximum 32 bit integer value
                if ((simTime + timeSlice) == MAX_SIMULATION_TIME || (simTime + timeSlice) < 0)
                    return;

                if (groupConfigMap[gGrpId].spikeGenFunc != NULL) {
                    userDefinedSpikeGenerator(gGrpId);
                }
            }
        }
    }
}

void SNN::allocateManagerSpikeTables() {
    managerRuntimeData.firingTableD2 = new int[managerRTDSize.maxMaxSpikeD2];
    managerRuntimeData.firingTableD1 = new int[managerRTDSize.maxMaxSpikeD1];

#ifdef LN_AXON_PLAST
    managerRuntimeData.firingTimesD2 = new unsigned int[managerRTDSize.maxMaxSpikeD2];
#endif

    managerRuntimeData.extFiringTableEndIdxD2 = new int[managerRTDSize.maxNumGroups];
    managerRuntimeData.extFiringTableEndIdxD1 = new int[managerRTDSize.maxNumGroups];
    managerRuntimeData.extFiringTableD2 = new int*[managerRTDSize.maxNumGroups];
    managerRuntimeData.extFiringTableD1 = new int*[managerRTDSize.maxNumGroups];

    //CUDA_CHECK_ERRORS(cudaMallocHost(&managerRuntimeData.firingTableD2, sizeof(int) * managerRTDSize.maxMaxSpikeD2));
    //CUDA_CHECK_ERRORS(cudaMallocHost(&managerRuntimeData.firingTableD1, sizeof(int) * managerRTDSize.maxMaxSpikeD1));
    //CUDA_CHECK_ERRORS(cudaMallocHost(&managerRuntimeData.extFiringTableEndIdxD2, sizeof(int) * managerRTDSize.maxNumGroups));
    //CUDA_CHECK_ERRORS(cudaMallocHost(&managerRuntimeData.extFiringTableEndIdxD1, sizeof(int) * managerRTDSize.maxNumGroups));
    //CUDA_CHECK_ERRORS(cudaMallocHost(&managerRuntimeData.extFiringTableD2, sizeof(int*) * managerRTDSize.maxNumGroups));
    //CUDA_CHECK_ERRORS(cudaMallocHost(&managerRuntimeData.extFiringTableD1, sizeof(int*) * managerRTDSize.maxNumGroups));
    resetFiringTable();

    managerRuntimeData.timeTableD2 = new unsigned int[TIMING_COUNT];
    managerRuntimeData.timeTableD1 = new unsigned int[TIMING_COUNT];
    resetTimeTable();
}

// updates simTime, returns true when new second started
bool SNN::updateTime() {
    bool finishedOneSec = false;

    // done one second worth of simulation
    // update relevant parameters...now
    if(++simTimeMs == 1000) {
        simTimeMs = 0;
        simTimeSec++;
        finishedOneSec = true;
    }

    simTime++;
    if(simTime == MAX_SIMULATION_TIME || simTime < 0){
        // reached the maximum limit of the simulation time using 32 bit value...
        KERNEL_WARN("Maximum Simulation Time Reached...Resetting simulation time");
    }

    return finishedOneSec;
}

#ifdef LN_UPDATE_CURSPIKES
//#define DEBUG_UPDATE_CURSPIKES
// LN20201101 mock to test fetchCurSpikes
void SNN::updateCurSpike(std::vector<bool>& gFiring, int netId) {

    if (netId == ALL) {
        for (int id = 0; id  < MAX_NET_PER_SNN; id ++)
            if (!groupPartitionLists[id].empty())
                updateCurSpike(gFiring, id);
    } 
    else {
        // translate CurSpike of regular neurons into firing 
        int regLength = networkConfigs[netId].numNReg;
        assert(gFiring.size() >= regLength);

        int genLength = networkConfigs[netId].numNSpikeGen;
        assert(gFiring.size() >= regLength + genLength);

        int nPois = networkConfigs[netId].numNPois;
        int poisLength = nPois - genLength;
        assert(gFiring.size() >= regLength + poisLength);

        assert(networkConfigs[netId].numN >= regLength + genLength + poisLength);  // lif

        int rateGenLength = networkConfigs[netId].numNRateGen;

        int length = networkConfigs[netId].numN;
        std::vector<bool> lFiring(length, false);

#ifdef DEBUG_UPDATE_CURSPIKES
        printf("numN: %d numNReg:%d  numNPois:%d numNSpikeGen:%d numNPoisGen:%d\n",
            length, regLength, poisLength, genLength, rateGenLength);
#endif

        // copy the neuron firing information to the manager runtime
        fetchCurSpike(netId);

        // copy Poisson neuron firing to the manager runtime
        if (poisLength > 0) {
            fetchRandNum(netId);
            fetchPoissonFireRate(netId);
        }

        // copy SpikeGenerator neuron firing to the manager runtime
        if (genLength > 0) {
            fetchSpikeGenBits(netId);
        }


        if (genLength > 0) {
#ifdef DEBUG_UPDATE_CURSPIKES
            printf("SpikGen: %d, Spikes (t=%01d.%03ds): ", regLength, simTimeMs / 1000, simTimeMs); // gen is captured before the step
#endif
            for (int lNId = regLength; lNId < genLength + regLength; lNId++) {
                const int nIdPos = lNId - regLength;
                //\sa getSpikeGenBit (crashes on GPU)
                const int nIdBitPos = nIdPos % 32;
                const int nIdIndex = nIdPos / 32;
                bool fired = ((managerRuntimeData.spikeGenBits[nIdIndex] >> nIdBitPos) & 0x1);
                lFiring[lNId] = fired;
#ifdef DEBUG_UPDATE_CURSPIKES
                printf("%s", fired ? "^" : "-");
#endif
            }
#ifdef DEBUG_UPDATE_CURSPIKES
            printf("\n");
#endif
        }

        if (poisLength > 0) {
#ifdef DEBUG_UPDATE_CURSPIKES
            printf("Poisson: %d, Spikes (t=%01d.%03ds): ", regLength, simTimeMs / 1000, simTimeMs);
#endif
            for (int lNId = regLength + genLength; lNId < regLength + genLength + poisLength; lNId++) {
                //\sa getPoissonSpike (crashes on GPU)
                bool fired = managerRuntimeData.randNum[lNId - regLength] * 1000.0f
                    < managerRuntimeData.poissonFireRate[lNId - regLength];
                lFiring[lNId] = fired;
#ifdef DEBUG_UPDATE_CURSPIKES
                printf("%s", fired ? "^" : "-");
#endif
            }
#ifdef DEBUG_UPDATE_CURSPIKES
            printf("\n");
#endif
        }

#ifdef DEBUG_UPDATE_CURSPIKES
        printf("Regular: %d, Spikes (t=%01d.%03ds): ", regLength, simTimeMs / 1000, simTimeMs);
#endif

        for (int lNId = 0; lNId < regLength; lNId++) {
            bool fired = managerRuntimeData.curSpike[lNId];
            lFiring[lNId] = fired;
#ifdef DEBUG_UPDATE_CURSPIKES
            printf("%s", fired ? "^" : "-");
#endif
        }
#ifdef DEBUG_UPDATE_CURSPIKES
        printf("\n");
#endif

        // translate local to global    
        //std::map<int, GroupConfigMD>
        for (auto iter = groupConfigMDMap.begin(); iter != groupConfigMDMap.end(); iter++) {
            int gGrpId = iter->first;
            GroupConfigMD &groupConfig = iter->second;
            if (groupConfig.netId == netId) {
                for (int lNId = groupConfig.lStartN, gNId = groupConfig.gStartN;
                    lNId <= groupConfig.lEndN && gNId <= groupConfig.gEndN;
                    lNId++, gNId++)
                {
                    assert(gNId == lNId + groupConfig.LtoGOffset);
                    assert(lNId == gNId + groupConfig.GtoLOffset);
                    gFiring[gNId] = lFiring[lNId];
                }
            }
        }

    }
}
#endif

#ifdef LN_UPDATE_CURSPIKES_MT
//#define DEBUG_UPDATE_CURSPIKES_MT
//#define DEBUG_UPDATE_CURSPIKES_MT_TIMING
//#define DEBUG_UPDATE_CURSPIKES_MT_MAP_TIMING
//#define DEBUG_UPDATE_CURSPIKES_MT_MAP_SEQ
#include <thread>
#include <chrono>
//#define DEBUG_UPDATE_CURSPIKES
// LN20201101 mock to test fetchCurSpikes
// https://en.cppreference.com/w/cpp/language/lambda
// https://en.cppreference.com/w/cpp/thread/thread/join
void SNN::updateCurSpikeMT(std::vector<bool>& gFiring, int netId) {

    // prototype does not support -1 see Single Threaded solution 

    //if (netId == ALL) {
    //  for (int id = 0; id < MAX_NET_PER_SNN; id++)
    //      if (!groupPartitionLists[id].empty())
    //          updateCurSpike(gFiring, id);
    //}
    //else {


    // translate CurSpike of regular neurons into firing 
    int regLength = networkConfigs[netId].numNReg;
    assert(gFiring.size() >= regLength);

    int genLength = networkConfigs[netId].numNSpikeGen;
    assert(gFiring.size() >= regLength + genLength);

    int nPois = networkConfigs[netId].numNPois;
    int poisLength = nPois - genLength;
    assert(gFiring.size() >= regLength + poisLength);

    assert(networkConfigs[netId].numN >= regLength + genLength + poisLength);  // lif

    int rateGenLength = networkConfigs[netId].numNRateGen;

    int length = networkConfigs[netId].numN;
    std::vector<bool> lFiring(length, false);

#ifdef DEBUG_UPDATE_CURSPIKES_MT
    printf("numN: %d numNReg:%d  numNPois:%d numNSpikeGen:%d numNPoisGen:%d\n",
        length, regLength, poisLength, genLength, rateGenLength);
#endif

    // copy the neuron firing information to the manager runtime
    fetchCurSpike(netId);

    // copy Poisson neuron firing to the manager runtime
    if (poisLength > 0) {
        fetchRandNum(netId);
        fetchPoissonFireRate(netId);
    }

    // copy SpikeGenerator neuron firing to the manager runtime
    if (genLength > 0) {
        fetchSpikeGenBits(netId);
    }

    std::vector<std::thread> gen_workers(genLength);  // avoid less performant push_back
    std::vector<std::thread> pois_workers(poisLength);  // avoid less performant push_back
    std::vector<std::thread> reg_workers(regLength);  // avoid less performant push_back

    if (genLength > 0) {
        for (int lNId = regLength; lNId < genLength + regLength; lNId++) {
            auto worker = [&, lNId]() {  // all be ref, except lNId by copy
                const int nIdPos = lNId - regLength;
                //\sa getSpikeGenBit (crashes on GPU)
                const int nIdBitPos = nIdPos % 32;
                const int nIdIndex = nIdPos / 32;
                bool fired = ((managerRuntimeData.spikeGenBits[nIdIndex] >> nIdBitPos) & 0x1);
#ifdef DEBUG_UPDATE_CURSPIKES_MT_TIMING
                std::this_thread::sleep_for(std::chrono::seconds(2));
#endif
                lFiring[lNId] = fired;
            };
            gen_workers[lNId-regLength] = std::thread(worker);
        }
        assert(gen_workers.size() == genLength);
    }

    if (poisLength>0) {
        for (int lNId = regLength + genLength; lNId<regLength + genLength + poisLength; lNId++) {
            auto worker = [&, lNId]() {
                //\sa getPoissonSpike (crashes on GPU)
                bool fired = managerRuntimeData.randNum[lNId - regLength] * 1000.0f
                    < managerRuntimeData.poissonFireRate[lNId - regLength];
#ifdef DEBUG_UPDATE_CURSPIKES_MT_TIMING
                std::this_thread::sleep_for(std::chrono::seconds(8));
#endif
                lFiring[lNId] = fired;
            }; 
            pois_workers[lNId - regLength - genLength] = std::thread(worker);
        }
        assert(pois_workers.size() == poisLength);
    }

    if (regLength > 0) {
        for (int lNId = 0; lNId < regLength; lNId++) {
            auto worker = [&, lNId]() {
                bool fired = managerRuntimeData.curSpike[lNId];
#ifdef DEBUG_UPDATE_CURSPIKES_MT_TIMING
                std::this_thread::sleep_for(std::chrono::seconds(10));
#endif
                lFiring[lNId] = fired;
            };
            reg_workers[lNId] = std::thread(worker);
        }
        assert(reg_workers.size() == regLength);
    }

    // later
    for (int lNId = regLength; lNId < genLength + regLength; lNId++)
        gen_workers[lNId-regLength].join();

    for (int lNId = regLength + genLength; lNId<regLength + genLength + poisLength; lNId++)
        pois_workers[lNId - regLength - genLength].join();

    for (int lNId = 0; lNId<regLength; lNId++)
        reg_workers[lNId].join();


    // after join later
#ifdef DEBUG_UPDATE_CURSPIKES_MT
    if (genLength > 0) {
        printf("SpikGen: %d, Spikes (t=%01d.%03ds): ", regLength, simTimeMs / 1000, simTimeMs); // gen is captured before the step
        for (int lNId = regLength; lNId < genLength + regLength; lNId++)
            printf("%s", lFiring[lNId] ? "^" : "-");
        printf("\n");
    }
    if (poisLength > 0) {
        printf("Poisson: %d, Spikes (t=%01d.%03ds): ", regLength, simTimeMs / 1000, simTimeMs);
        for (int lNId = regLength + genLength; lNId < regLength + genLength + poisLength; lNId++)
            printf("%s", lFiring[lNId] ? "^" : "-");
        printf("\n");
    }
    if (regLength > 0) {
        printf("Regular: %d, Spikes (t=%01d.%03ds): ", regLength, simTimeMs / 1000, simTimeMs);
        for (int lNId = 0; lNId < regLength; lNId++)
            printf("%s", lFiring[lNId] ? "^" : "-");
        printf("\n");
    }
#endif


    // translate local to global    
    int threadIdx = 0;
    std::vector<std::thread> map_workers(groupConfigMDMap.size());  // avoid less performant push_back
    for (auto iter = groupConfigMDMap.begin(); iter != groupConfigMDMap.end(); iter++) {
            auto worker = [&, iter]() {  // copy iter and therefor the reference to groupConfig
                int gGrpId = iter->first;
                GroupConfigMD &groupConfig = iter->second;  // ref groupConfig              
                if (groupConfig.netId == netId) {
                    for (int lNId = groupConfig.lStartN, gNId = groupConfig.gStartN;
                        lNId <= groupConfig.lEndN && gNId <= groupConfig.gEndN;
                        lNId++, gNId++)
                    {
                        assert(gNId == lNId + groupConfig.LtoGOffset);
                        assert(lNId == gNId + groupConfig.GtoLOffset);
#ifdef DEBUG_UPDATE_CURSPIKES_MT_MAP_TIMING
                        //std::this_thread::sleep_for(std::chrono::seconds(1));  // pretty deterministic randomness
                        std::this_thread::sleep_for(std::chrono::milliseconds(lNId));  // pretty deterministic randomness
#endif
                        gFiring[gNId] = lFiring[lNId];
                    }
                }
            };
#ifdef DEBUG_UPDATE_CURSPIKES_MT_MAP_SEQ
            worker(); // sequencial: sum all groups * 1s = 12s  reg 
#else
            map_workers[threadIdx++] = std::thread(worker);  // parallel: 1s * largest group = 4s
#endif
    }
#ifndef DEBUG_UPDATE_CURSPIKES_MT_MAP_SEQ 
    assert(threadIdx == groupConfigMDMap.size());   // hint: comment out to run sequ
    for(threadIdx=0; threadIdx<map_workers.size(); threadIdx++)
        map_workers[threadIdx].join();
#endif

}

#endif //CURSPIKES_MT


#ifdef LN_AXON_PLAST
void SNN::findWavefrontPath(std::vector<int>& path, std::vector<float>& eligibility, int netId, int grpId, int startNId, int goalNId) {
    if (netId < CPU_RUNTIME_BASE) 
        ; // GPU runtime
    else {
        findWavefrontPath_CPU(path, eligibility, netId, grpId, startNId, goalNId);
    }

}


bool SNN::updateDelays(int gGrpIdPre, int gGrpIdPost, std::vector<std::tuple<int, int, uint8_t>> connDelays) {
    int netIdPre = groupConfigMDMap[gGrpIdPre].netId;
    int netIdPost = groupConfigMDMap[gGrpIdPost].netId;
    assert(netIdPre == netIdPost);  // KERNEL Error
    int netId = netIdPre;
    int lGrpIdPost = groupConfigMDMap[gGrpIdPost].lGrpId;
    int lGrpIdPre = -1;  // SNN::getDelays
    for (int lGrpId = 0; lGrpId < networkConfigs[netIdPost].numGroupsAssigned; lGrpId++)
        if (groupConfigs[netIdPost][lGrpId].gGrpId == gGrpIdPre) {
            lGrpIdPre = lGrpId;
            break;
        }
    assert(lGrpIdPre != -1);

    bool success = false;
    if (netId < CPU_RUNTIME_BASE) // GPU runtime
        success = updateDelays_GPU(netId, lGrpIdPre, lGrpIdPost, connDelays); 
    else {
        success = updateDelays_CPU(netId, lGrpIdPre, lGrpIdPost, connDelays); 
    }
    return success;
}

                                                       
void SNN::printEntrails(char* buffer, unsigned length, int gGrpIdPre, int gGrpIdPost) {

    int netIdPre = groupConfigMDMap[gGrpIdPre].netId;
    int netIdPost = groupConfigMDMap[gGrpIdPost].netId;
    assert(netIdPre == netIdPost);  // KERNEL Error
    int netId = netIdPre;
    int lGrpIdPost = groupConfigMDMap[gGrpIdPost].lGrpId;
    int lGrpIdPre = -1;  // SNN::getDelays
    for (int lGrpId = 0; lGrpId < networkConfigs[netIdPost].numGroupsAssigned; lGrpId++)
        if (groupConfigs[netIdPost][lGrpId].gGrpId == gGrpIdPre) {
            lGrpIdPre = lGrpId;
            break;
        }
    assert(lGrpIdPre != -1);

    if (netId < CPU_RUNTIME_BASE) // GPU runtime 
        printEntrails_GPU(buffer, length, netId, lGrpIdPre, lGrpIdPost);
    else {
        //#ifdef __NO_PTHREADS__
        printEntrails_CPU(buffer, length, netId, lGrpIdPre, lGrpIdPost);
    }

}


#endif

// FIXME: modify this for multi-GPUs
void SNN::updateSpikeMonitor(int gGrpId) {
    // don't continue if no spike monitors in the network
    if (!numSpikeMonitor)
        return;

    if (gGrpId == ALL) {
        for (int gGrpId = 0; gGrpId < numGroups; gGrpId++)
            updateSpikeMonitor(gGrpId);
    } else {
        int netId = groupConfigMDMap[gGrpId].netId;
        int lGrpId = groupConfigMDMap[gGrpId].lGrpId;
        // update spike monitor of a specific group
        // find index in spike monitor arrays
        int monitorId = groupConfigMDMap[gGrpId].spikeMonitorId;

        // don't continue if no spike monitor enabled for this group
        if (monitorId < 0) return;

        // find last update time for this group
        SpikeMonitorCore* spkMonObj = spikeMonCoreList[monitorId];
        long int lastUpdate = spkMonObj->getLastUpdated();

        // don't continue if time interval is zero (nothing to update)
        if ( ((long int)getSimTime()) - lastUpdate <= 0)
            return;

        if ( ((long int)getSimTime()) - lastUpdate > 1000)
            KERNEL_ERROR("updateSpikeMonitor(grpId=%d) must be called at least once every second",gGrpId);

        // AER buffer max size warning here.
        // Because of C++ short-circuit evaluation, the last condition should not be evaluated
        // if the previous conditions are false.
        if (spkMonObj->getAccumTime() > LONG_SPIKE_MON_DURATION \
                && this->getGroupNumNeurons(gGrpId) > LARGE_SPIKE_MON_GRP_SIZE \
                && spkMonObj->isBufferBig()){
            // change this warning message to correct message
            KERNEL_WARN("updateSpikeMonitor(grpId=%d) is becoming very large. (>%lu MB)",gGrpId,(long int) MAX_SPIKE_MON_BUFFER_SIZE/1024 );// make this better
            KERNEL_WARN("Reduce the cumulative recording time (currently %lu minutes) or the group size (currently %d) to avoid this.",spkMonObj->getAccumTime()/(1000*60),this->getGroupNumNeurons(gGrpId));
        }

        // copy the neuron firing information to the manager runtime
        fetchSpikeTables(netId);
        fetchGrpIdsLookupArray(netId);

        // find the time interval in which to update spikes
        // usually, we call updateSpikeMonitor once every second, so the time interval is [0,1000)
        // however, updateSpikeMonitor can be called at any time t \in [0,1000)... so we can have the cases
        // [0,t), [t,1000), and even [t1, t2)
        int numMsMin = lastUpdate % 1000; // lower bound is given by last time we called update
        int numMsMax = getSimTimeMs(); // upper bound is given by current time
        if (numMsMax == 0)
            numMsMax = 1000; // special case: full second
        assert(numMsMin < numMsMax);

        // current time is last completed second in milliseconds (plus t to be added below)
        // special case is after each completed second where !getSimTimeMs(): here we look 1s back
        int currentTimeSec = getSimTimeSec();
        if (!getSimTimeMs())
            currentTimeSec--;

        // save current time as last update time
        spkMonObj->setLastUpdated( (long int)getSimTime() );

        // prepare fast access
        FILE* spkFileId = spikeMonCoreList[monitorId]->getSpikeFileId();
        bool writeSpikesToFile = spkFileId != NULL;
        bool writeSpikesToArray = spkMonObj->getMode()==AER && spkMonObj->isRecording();

        // Read one spike at a time from the buffer and put the spikes to an appopriate monitor buffer. Later the user
        // may need need to dump these spikes to an output file
        for (int k = 0; k < 2; k++) {
            unsigned int* timeTablePtr = (k == 0) ? managerRuntimeData.timeTableD2 : managerRuntimeData.timeTableD1;
            int* fireTablePtr = (k == 0) ? managerRuntimeData.firingTableD2 : managerRuntimeData.firingTableD1;
            for(int t = numMsMin; t < numMsMax; t++) {
                for(auto i = timeTablePtr[t + glbNetworkConfig.maxDelay]; i < timeTablePtr[t + glbNetworkConfig.maxDelay + 1]; i++) {
                    // retrieve the neuron id
                    int lNId = fireTablePtr[i];

                    // make sure neuron belongs to currently relevant group
                    int this_grpId = managerRuntimeData.grpIds[lNId];
                    if (this_grpId != lGrpId)
                        continue;

                    // adjust nid to be 0-indexed for each group
                    // this way, if a group has 10 neurons, their IDs in the spike file and spike monitor will be
                    // indexed from 0..9, no matter what their real nid is
                    int nId = lNId - groupConfigs[netId][lGrpId].lStartN;
                    assert(nId >= 0);

                    // current time is last completed second plus whatever is leftover in t
                    int time = currentTimeSec * 1000 + t;

                    if (writeSpikesToFile) {
                        int cnt;
                        cnt = fwrite(&time, sizeof(int), 1, spkFileId); assert(cnt==1);
                        cnt = fwrite(&nId,  sizeof(int), 1, spkFileId); assert(cnt==1);
                    }

                    if (writeSpikesToArray) {
                        spkMonObj->pushAER(time, nId);
                    }
                }
            }
        }

        if (spkFileId!=NULL) // flush spike file
            fflush(spkFileId);
    }
}

// FIXME: modify this for multi-GPUs
void SNN::updateNeuronMonitor(int gGrpId) {
    // don't continue if no neuron monitors in the network
    if (!numNeuronMonitor)
        return;

    //printf("The global group id is: %i\n", gGrpId);

    if (gGrpId == ALL) {
        for (int gGrpId = 0; gGrpId < numGroups; gGrpId++)
            updateNeuronMonitor(gGrpId);
    }
    else {
        //printf("UpdateNeuronMonitor is being executed!\n");
        int netId = groupConfigMDMap[gGrpId].netId;
        int lGrpId = groupConfigMDMap[gGrpId].lGrpId;
        // update neuron monitor of a specific group
        // find index in neuron monitor arrays
        int monitorId = groupConfigMDMap[gGrpId].neuronMonitorId;

        // don't continue if no spike monitor enabled for this group
        if (monitorId < 0) return;

        // find last update time for this group
        NeuronMonitorCore* nrnMonObj = neuronMonCoreList[monitorId];
        long int lastUpdate = nrnMonObj->getLastUpdated();

        // don't continue if time interval is zero (nothing to update)
        if (((long int)getSimTime()) - lastUpdate <= 0)
            return;

        if (((long int)getSimTime()) - lastUpdate > 1000)
            KERNEL_ERROR("updateNeuronMonitor(grpId=%d) must be called at least once every second", gGrpId);

        // AER buffer max size warning here.
        // Because of C++ short-circuit evaluation, the last condition should not be evaluated
        // if the previous conditions are false.

        /*if (nrnMonObj->getAccumTime() > LONG_NEURON_MON_DURATION \
            && this->getGroupNumNeurons(gGrpId) > LARGE_NEURON_MON_GRP_SIZE \
            && nrnMonObj->isBufferBig()) {
            // change this warning message to correct message
            KERNEL_WARN("updateNeuronMonitor(grpId=%d) is becoming very large. (>%lu MB)", gGrpId, (long int)MAX_NEURON_MON_BUFFER_SIZE / 1024);// make this better
            KERNEL_WARN("Reduce the cumulative recording time (currently %lu minutes) or the group size (currently %d) to avoid this.", nrnMonObj->getAccumTime() / (1000 * 60), this->getGroupNumNeurons(gGrpId));
        }*/

        // copy the neuron information to manager runtime
        fetchNeuronStateBuffer(netId, lGrpId);

        // find the time interval in which to update neuron state info
        // usually, we call updateNeuronMonitor once every second, so the time interval is [0,1000)
        // however, updateNeuronMonitor can be called at any time t \in [0,1000)... so we can have the cases
        // [0,t), [t,1000), and even [t1, t2)
        int numMsMin = lastUpdate % 1000; // lower bound is given by last time we called update
        int numMsMax = getSimTimeMs(); // upper bound is given by current time
        if (numMsMax == 0)
            numMsMax = 1000; // special case: full second
        assert(numMsMin < numMsMax);
        //KERNEL_INFO("lastUpdate: %d -- numMsMin: %d -- numMsMax: %d", lastUpdate, numMsMin, numMsMax);

        // current time is last completed second in milliseconds (plus t to be added below)
        // special case is after each completed second where !getSimTimeMs(): here we look 1s back
        int currentTimeSec = getSimTimeSec();
        if (!getSimTimeMs())
            currentTimeSec--;

        // save current time as last update time
        nrnMonObj->setLastUpdated((long int)getSimTime());

        // prepare fast access
        FILE* nrnFileId = neuronMonCoreList[monitorId]->getNeuronFileId();
        bool writeNeuronStateToFile = nrnFileId != NULL;
        bool writeNeuronStateToArray = nrnMonObj->isRecording();

        // Read one neuron state value at a time from the buffer and put the neuron state values to an appopriate monitor buffer.
        // Later the user may need need to dump these neuron state values to an output file
        //printf("The numMsMin is: %i; and numMsMax is: %i\n", numMsMin, numMsMax);
        for (int t = numMsMin; t < numMsMax; t++) {
            int grpNumNeurons = groupConfigs[netId][lGrpId].lEndN - groupConfigs[netId][lGrpId].lStartN + 1;
            //printf("The lStartN is: %i; and lEndN is: %i\n", groupConfigs[netId][lGrpId].lStartN, groupConfigs[netId][lGrpId].lEndN);
            // for (int lNId = groupConfigs[netId][lGrpId].lStartN; lNId <= groupConfigs[netId][lGrpId].lEndN; lNId++) {
            for (int tmpNId = 0; tmpNId < std::min(MAX_NEURON_MON_GRP_SZIE, grpNumNeurons); tmpNId++) {
                int lNId = groupConfigs[netId][lGrpId].lStartN + tmpNId;
                float v, u, I;

                // make sure neuron belongs to currently relevant group
                int this_grpId = managerRuntimeData.grpIds[lNId];
                if (this_grpId != lGrpId)
                    continue;

                // adjust nid to be 0-indexed for each group
                // this way, if a group has 10 neurons, their IDs in the spike file and spike monitor will be
                // indexed from 0..9, no matter what their real nid is
                int nId = lNId - groupConfigs[netId][lGrpId].lStartN;
                assert(nId >= 0);

                int idxBase = networkConfigs[netId].numGroups * MAX_NEURON_MON_GRP_SZIE * t + lGrpId * MAX_NEURON_MON_GRP_SZIE;
                v = managerRuntimeData.nVBuffer[idxBase + nId];
                u = managerRuntimeData.nUBuffer[idxBase + nId];
                I = managerRuntimeData.nIBuffer[idxBase + nId];

                //printf("Voltage recorded is: %f\n", v);

                // current time is last completed second plus whatever is leftover in t
                int time = currentTimeSec * 1000 + t;

                //KERNEL_INFO("t: %d -- time: %d --base: %d -- nId: %d -- v: %f -- u: %f, --I: %f", t, time, idxBase + nId, nId, v, u, I);

                // WRITE TO A TEXT FILE INSTEAD OF BINARY
                if (writeNeuronStateToFile) {
                    //KERNEL_INFO("Save to file");
                    int cnt;
                    cnt = fwrite(&time, sizeof(int), 1, nrnFileId); assert(cnt == 1);
                    cnt = fwrite(&nId, sizeof(int), 1, nrnFileId); assert(cnt == 1);
                    cnt = fwrite(&v, sizeof(float), 1, nrnFileId); assert(cnt == 1);
                    cnt = fwrite(&u, sizeof(float), 1, nrnFileId); assert(cnt == 1);
                    cnt = fwrite(&I, sizeof(float), 1, nrnFileId); assert(cnt == 1);
                }

                if (writeNeuronStateToArray) {
                    //KERNEL_INFO("Save to array");
                    nrnMonObj->pushNeuronState(nId, v, u, I);
                }
            }
        }

        if (nrnFileId != NULL) // flush neuron state file
            fflush(nrnFileId);
    }
}

// FIXME: update summary format for multiGPUs
void SNN::printSimSummary() {
    float etime;

    // FIXME: measure total execution time, and GPU excution time
    stopTiming();
    etime = executionTime;

    fetchNetworkSpikeCount();

    KERNEL_INFO("\n");
    KERNEL_INFO("********************    Simulation Summary      ***************************");

    KERNEL_INFO("Network Parameters: \tnumNeurons = %d (numNExcReg:numNInhReg = %2.1f:%2.1f)",
        glbNetworkConfig.numN, 100.0 * glbNetworkConfig.numNExcReg / glbNetworkConfig.numN, 100.0 * glbNetworkConfig.numNInhReg / glbNetworkConfig.numN);
    KERNEL_INFO("\t\t\tnumSynapses = %d", glbNetworkConfig.numSynNet);
    KERNEL_INFO("\t\t\tmaxDelay = %d", glbNetworkConfig.maxDelay);
    KERNEL_INFO("Simulation Mode:\t%s",sim_with_conductances?"COBA":"CUBA");
    KERNEL_INFO("Random Seed:\t\t%d", randSeed_);
    KERNEL_INFO("Timing:\t\t\tModel Simulation Time = %lld sec", (unsigned long long)simTimeSec);
    KERNEL_INFO("\t\t\tActual Execution Time = %4.2f sec", etime/1000.0f);
    float speed = float(simTimeSec) / std::max(.001f, etime / 1000.0f); 
#ifdef _DEBUG
    const char* build = "(Debug)";
#else
    const char* build = "";
#endif
    if (speed >= 10.f) {
        KERNEL_INFO("\t\t\tSpeed Factor (Model/Real) = %.0f x %s", speed, build);
    } else 
    if (speed < 1.0f) {
        KERNEL_INFO("\t\t\tSpeed Factor (Model/Real) = %2.1f %% %s", speed*100.f, build);
    } else
        KERNEL_INFO("\t\t\tSpeed Factor (Model/Real) = %1.1f x %s", speed, build);
    KERNEL_INFO("Average Firing Rate:\t2+ms delay = %3.3f Hz",
        glbNetworkConfig.numN2msDelay > 0 ? managerRuntimeData.spikeCountD2 / (1.0 * simTimeSec * glbNetworkConfig.numN2msDelay) : 0.0f);
    KERNEL_INFO("\t\t\t1ms delay = %3.3f Hz",
        glbNetworkConfig.numN1msDelay > 0 ? managerRuntimeData.spikeCountD1 / (1.0 * simTimeSec * glbNetworkConfig.numN1msDelay) : 0.0f);
    KERNEL_INFO("\t\t\tOverall = %3.3f Hz", managerRuntimeData.spikeCount / (1.0 * simTimeSec * glbNetworkConfig.numN));
    KERNEL_INFO("Overall Spike Count Transferred:");
    KERNEL_INFO("\t\t\t2+ms delay = %d", managerRuntimeData.spikeCountExtRxD2);
    KERNEL_INFO("\t\t\t1ms delay = %d", managerRuntimeData.spikeCountExtRxD1);
    KERNEL_INFO("Overall Spike Count:\t2+ms delay = %d", managerRuntimeData.spikeCountD2);
    KERNEL_INFO("\t\t\t1ms delay = %d", managerRuntimeData.spikeCountD1);
    KERNEL_INFO("\t\t\tTotal = %d", managerRuntimeData.spikeCount);
    KERNEL_INFO("*********************************************************************************\n");
}

//------------------------------ legacy code --------------------------------//

// We parallelly cleanup the postSynapticIds array to minimize any other wastage in that array by compacting the store
// Appropriate alignment specified by ALIGN_COMPACTION macro is used to ensure some level of alignment (if necessary)
//void SNN::compactConnections() {
//  unsigned int* tmp_cumulativePost = new unsigned int[numN];
//  unsigned int* tmp_cumulativePre  = new unsigned int[numN];
//  unsigned int lastCnt_pre         = 0;
//  unsigned int lastCnt_post        = 0;
//
//  tmp_cumulativePost[0]   = 0;
//  tmp_cumulativePre[0]    = 0;
//
//  for(int i=1; i < numN; i++) {
//      lastCnt_post = tmp_cumulativePost[i-1]+managerRuntimeData.Npost[i-1]; //position of last pointer
//      lastCnt_pre  = tmp_cumulativePre[i-1]+managerRuntimeData.Npre[i-1]; //position of last pointer
//      #if COMPACTION_ALIGNMENT_POST
//          lastCnt_post= lastCnt_post + COMPACTION_ALIGNMENT_POST-lastCnt_post%COMPACTION_ALIGNMENT_POST;
//          lastCnt_pre = lastCnt_pre  + COMPACTION_ALIGNMENT_PRE- lastCnt_pre%COMPACTION_ALIGNMENT_PRE;
//      #endif
//      tmp_cumulativePost[i] = lastCnt_post;
//      tmp_cumulativePre[i]  = lastCnt_pre;
//      assert(tmp_cumulativePost[i] <= managerRuntimeData.cumulativePost[i]);
//      assert(tmp_cumulativePre[i]  <= managerRuntimeData.cumulativePre[i]);
//  }
//
//  // compress the post_synaptic array according to the new values of the tmp_cumulative counts....
//  unsigned int tmp_numPostSynNet = tmp_cumulativePost[numN-1]+managerRuntimeData.Npost[numN-1];
//  unsigned int tmp_numPreSynNet  = tmp_cumulativePre[numN-1]+managerRuntimeData.Npre[numN-1];
//  assert(tmp_numPostSynNet <= allocatedPost);
//  assert(tmp_numPreSynNet  <= allocatedPre);
//  assert(tmp_numPostSynNet <= numPostSynNet);
//  assert(tmp_numPreSynNet  <= numPreSynNet);
//  KERNEL_DEBUG("******************");
//  KERNEL_DEBUG("CompactConnection: ");
//  KERNEL_DEBUG("******************");
//  KERNEL_DEBUG("old_postCnt = %d, new_postCnt = %d", numPostSynNet, tmp_numPostSynNet);
//  KERNEL_DEBUG("old_preCnt = %d,  new_postCnt = %d", numPreSynNet,  tmp_numPreSynNet);
//
//  // new buffer with required size + 100 bytes of additional space just to provide limited overflow
//  SynInfo* tmp_postSynapticIds   = new SynInfo[tmp_numPostSynNet+100];
//
//  // new buffer with required size + 100 bytes of additional space just to provide limited overflow
//  SynInfo* tmp_preSynapticIds = new SynInfo[tmp_numPreSynNet+100];
//  float* tmp_wt                   = new float[tmp_numPreSynNet+100];
//  float* tmp_maxSynWt             = new float[tmp_numPreSynNet+100];
//  short int *tmp_cumConnIdPre         = new short int[tmp_numPreSynNet+100];
//  float *tmp_mulSynFast           = new float[numConnections];
//  float *tmp_mulSynSlow           = new float[numConnections];
//
//  // compact synaptic information
//  for(int i=0; i<numN; i++) {
//      assert(tmp_cumulativePost[i] <= managerRuntimeData.cumulativePost[i]);
//      assert(tmp_cumulativePre[i]  <= managerRuntimeData.cumulativePre[i]);
//      for( int j=0; j<managerRuntimeData.Npost[i]; j++) {
//          unsigned int tmpPos = tmp_cumulativePost[i]+j;
//          unsigned int oldPos = managerRuntimeData.cumulativePost[i]+j;
//          tmp_postSynapticIds[tmpPos] = managerRuntimeData.postSynapticIds[oldPos];
//          tmp_SynapticDelay[tmpPos]   = tmp_SynapticDelay[oldPos];
//      }
//      for( int j=0; j<managerRuntimeData.Npre[i]; j++) {
//          unsigned int tmpPos =  tmp_cumulativePre[i]+j;
//          unsigned int oldPos =  managerRuntimeData.cumulativePre[i]+j;
//          tmp_preSynapticIds[tmpPos]  = managerRuntimeData.preSynapticIds[oldPos];
//          tmp_maxSynWt[tmpPos]        = managerRuntimeData.maxSynWt[oldPos];
//          tmp_wt[tmpPos]              = managerRuntimeData.wt[oldPos];
//          tmp_cumConnIdPre[tmpPos]    = managerRuntimeData.connIdsPreIdx[oldPos];
//      }
//  }
//
//  // delete old buffer space
//  delete[] managerRuntimeData.postSynapticIds;
//  managerRuntimeData.postSynapticIds = tmp_postSynapticIds;
//  cpuSnnSz.networkInfoSize -= (sizeof(SynInfo)*numPostSynNet);
//  cpuSnnSz.networkInfoSize += (sizeof(SynInfo)*(tmp_numPostSynNet+100));
//
//  delete[] managerRuntimeData.cumulativePost;
//  managerRuntimeData.cumulativePost  = tmp_cumulativePost;
//
//  delete[] managerRuntimeData.cumulativePre;
//  managerRuntimeData.cumulativePre   = tmp_cumulativePre;
//
//  delete[] managerRuntimeData.maxSynWt;
//  managerRuntimeData.maxSynWt = tmp_maxSynWt;
//  cpuSnnSz.synapticInfoSize -= (sizeof(float)*numPreSynNet);
//  cpuSnnSz.synapticInfoSize += (sizeof(float)*(tmp_numPreSynNet+100));
//
//  delete[] managerRuntimeData.wt;
//  managerRuntimeData.wt = tmp_wt;
//  cpuSnnSz.synapticInfoSize -= (sizeof(float)*numPreSynNet);
//  cpuSnnSz.synapticInfoSize += (sizeof(float)*(tmp_numPreSynNet+100));
//
//  delete[] managerRuntimeData.connIdsPreIdx;
//  managerRuntimeData.connIdsPreIdx = tmp_cumConnIdPre;
//  cpuSnnSz.synapticInfoSize -= (sizeof(short int)*numPreSynNet);
//  cpuSnnSz.synapticInfoSize += (sizeof(short int)*(tmp_numPreSynNet+100));
//
//  // compact connection-centric information
//  for (int i=0; i<numConnections; i++) {
//      tmp_mulSynFast[i] = mulSynFast[i];
//      tmp_mulSynSlow[i] = mulSynSlow[i];
//  }
//  delete[] mulSynFast;
//  delete[] mulSynSlow;
//  mulSynFast = tmp_mulSynFast;
//  mulSynSlow = tmp_mulSynSlow;
//  cpuSnnSz.networkInfoSize -= (2*sizeof(uint8_t)*numPreSynNet);
//  cpuSnnSz.networkInfoSize += (2*sizeof(uint8_t)*(tmp_numPreSynNet+100));
//
//
//  delete[] managerRuntimeData.preSynapticIds;
//  managerRuntimeData.preSynapticIds  = tmp_preSynapticIds;
//  cpuSnnSz.synapticInfoSize -= (sizeof(SynInfo)*numPreSynNet);
//  cpuSnnSz.synapticInfoSize += (sizeof(SynInfo)*(tmp_numPreSynNet+100));
//
//  numPreSynNet    = tmp_numPreSynNet;
//  numPostSynNet   = tmp_numPostSynNet;
//}

//The post synaptic connections are sorted based on delay here so that we can reduce storage requirement
//and generation of spike at the post-synaptic side.
//We also create the delay_info array has the delay_start and delay_length parameter
//void SNN::reorganizeDelay()
//{
//  for(int grpId=0; grpId < numGroups; grpId++) {
//      for(int nid=groupConfigs[0][grpId].StartN; nid <= groupConfigs[0][grpId].EndN; nid++) {
//          unsigned int jPos=0;                    // this points to the top of the delay queue
//          unsigned int cumN=managerRuntimeData.cumulativePost[nid];   // cumulativePost[] is unsigned int
//          unsigned int cumDelayStart=0;           // Npost[] is unsigned short
//          for(int td = 0; td < maxDelay_; td++) {
//              unsigned int j=jPos;                // start searching from top of the queue until the end
//              unsigned int cnt=0;                 // store the number of nodes with a delay of td;
//              while(j < managerRuntimeData.Npost[nid]) {
//                  // found a node j with delay=td and we put
//                  // the delay value = 1 at array location td=0;
//                  if(td==(tmp_SynapticDelay[cumN+j]-1)) {
//                      assert(jPos<managerRuntimeData.Npost[nid]);
//                      swapConnections(nid, j, jPos);
//
//                      jPos=jPos+1;
//                      cnt=cnt+1;
//                  }
//                  j=j+1;
//              }
//
//              // update the delay_length and start values...
//              managerRuntimeData.postDelayInfo[nid*(maxDelay_+1)+td].delay_length      = cnt;
//              managerRuntimeData.postDelayInfo[nid*(maxDelay_+1)+td].delay_index_start  = cumDelayStart;
//              cumDelayStart += cnt;
//
//              assert(cumDelayStart <= managerRuntimeData.Npost[nid]);
//          }
//
//          // total cumulative delay should be equal to number of post-synaptic connections at the end of the loop
//          assert(cumDelayStart == managerRuntimeData.Npost[nid]);
//          for(unsigned int j=1; j < managerRuntimeData.Npost[nid]; j++) {
//              unsigned int cumN=managerRuntimeData.cumulativePost[nid]; // cumulativePost[] is unsigned int
//              if( tmp_SynapticDelay[cumN+j] < tmp_SynapticDelay[cumN+j-1]) {
//                  KERNEL_ERROR("Post-synaptic delays not sorted correctly... id=%d, delay[%d]=%d, delay[%d]=%d",
//                      nid, j, tmp_SynapticDelay[cumN+j], j-1, tmp_SynapticDelay[cumN+j-1]);
//                  assert( tmp_SynapticDelay[cumN+j] >= tmp_SynapticDelay[cumN+j-1]);
//              }
//          }
//      }
//  }
//}

//void SNN::swapConnections(int nid, int oldPos, int newPos) {
//  unsigned int cumN=managerRuntimeData.cumulativePost[nid];
//
//  // Put the node oldPos to the top of the delay queue
//  SynInfo tmp = managerRuntimeData.postSynapticIds[cumN+oldPos];
//  managerRuntimeData.postSynapticIds[cumN+oldPos]= managerRuntimeData.postSynapticIds[cumN+newPos];
//  managerRuntimeData.postSynapticIds[cumN+newPos]= tmp;
//
//  // Ensure that you have shifted the delay accordingly....
//  uint8_t tmp_delay = tmp_SynapticDelay[cumN+oldPos];
//  tmp_SynapticDelay[cumN+oldPos] = tmp_SynapticDelay[cumN+newPos];
//  tmp_SynapticDelay[cumN+newPos] = tmp_delay;
//
//  // update the pre-information for the postsynaptic neuron at the position oldPos.
//  SynInfo  postInfo = managerRuntimeData.postSynapticIds[cumN+oldPos];
//  int  post_nid = GET_CONN_NEURON_ID(postInfo);
//  int  post_sid = GET_CONN_SYN_ID(postInfo);
//
//  SynInfo* preId    = &(managerRuntimeData.preSynapticIds[managerRuntimeData.cumulativePre[post_nid]+post_sid]);
//  int  pre_nid  = GET_CONN_NEURON_ID((*preId));
//  int  pre_sid  = GET_CONN_SYN_ID((*preId));
//  int  pre_gid  = GET_CONN_GRP_ID((*preId));
//  assert (pre_nid == nid);
//  assert (pre_sid == newPos);
//  *preId = SET_CONN_ID( pre_nid, oldPos, pre_gid);
//
//  // update the pre-information for the postsynaptic neuron at the position newPos
//  postInfo = managerRuntimeData.postSynapticIds[cumN+newPos];
//  post_nid = GET_CONN_NEURON_ID(postInfo);
//  post_sid = GET_CONN_SYN_ID(postInfo);
//
//  preId    = &(managerRuntimeData.preSynapticIds[managerRuntimeData.cumulativePre[post_nid]+post_sid]);
//  pre_nid  = GET_CONN_NEURON_ID((*preId));
//  pre_sid  = GET_CONN_SYN_ID((*preId));
//  pre_gid  = GET_CONN_GRP_ID((*preId));
//  assert (pre_nid == nid);
//  assert (pre_sid == oldPos);
//  *preId = SET_CONN_ID( pre_nid, newPos, pre_gid);
//}

// set one specific connection from neuron id 'src' to neuron id 'dest'
//inline void SNN::setConnection(int srcGrp,  int destGrp,  unsigned int src, unsigned int dest, float synWt,
//                                  float maxWt, uint8_t dVal, int connProp, short int connId) {
//  assert(dest<=CONN_SYN_NEURON_MASK);         // total number of neurons is less than 1 million within a GPU
//  assert((dVal >=1) && (dVal <= maxDelay_));
//
//  // adjust sign of weight based on pre-group (negative if pre is inhibitory)
//  synWt = isExcitatoryGroup(srcGrp) ? fabs(synWt) : -1.0*fabs(synWt);
//  maxWt = isExcitatoryGroup(srcGrp) ? fabs(maxWt) : -1.0*fabs(maxWt);
//
//  // we have exceeded the number of possible connection for one neuron
//  if(managerRuntimeData.Npost[src] >= groupConfigs[0][srcGrp].numPostSynapses)    {
//      KERNEL_ERROR("setConnection(%d (Grp=%s), %d (Grp=%s), %f, %d)", src, groupInfo[srcGrp].Name.c_str(),
//                  dest, groupInfo[destGrp].Name.c_str(), synWt, dVal);
//      KERNEL_ERROR("Large number of postsynaptic connections established (%d), max for this group %d.", managerRuntimeData.Npost[src], groupConfigs[0][srcGrp].numPostSynapses);
//      exitSimulation(1);
//  }
//
//  if(managerRuntimeData.Npre[dest] >= groupConfigs[0][destGrp].numPreSynapses) {
//      KERNEL_ERROR("setConnection(%d (Grp=%s), %d (Grp=%s), %f, %d)", src, groupInfo[srcGrp].Name.c_str(),
//                  dest, groupInfo[destGrp].Name.c_str(), synWt, dVal);
//      KERNEL_ERROR("Large number of presynaptic connections established (%d), max for this group %d.", managerRuntimeData.Npre[dest], groupConfigs[0][destGrp].numPreSynapses);
//      exitSimulation(1);
//  }
//
//  int p = managerRuntimeData.Npost[src];
//
//  assert(managerRuntimeData.Npost[src] >= 0);
//  assert(managerRuntimeData.Npre[dest] >= 0);
//  assert((src * maxNumPostSynGrp + p) / numN < maxNumPostSynGrp); // divide by numN to prevent INT overflow
//
//  unsigned int post_pos = managerRuntimeData.cumulativePost[src] + managerRuntimeData.Npost[src];
//  unsigned int pre_pos  = managerRuntimeData.cumulativePre[dest] + managerRuntimeData.Npre[dest];
//
//  assert(post_pos < numPostSynNet);
//  assert(pre_pos  < numPreSynNet);
//
//  //generate a new postSynapticIds id for the current connection
//  managerRuntimeData.postSynapticIds[post_pos]   = SET_CONN_ID(dest, managerRuntimeData.Npre[dest], destGrp);
//  tmp_SynapticDelay[post_pos] = dVal;
//
//  managerRuntimeData.preSynapticIds[pre_pos] = SET_CONN_ID(src, managerRuntimeData.Npost[src], srcGrp);
//  managerRuntimeData.wt[pre_pos]    = synWt;
//  managerRuntimeData.maxSynWt[pre_pos] = maxWt;
//  managerRuntimeData.connIdsPreIdx[pre_pos] = connId;
//
//  bool synWtType = GET_FIXED_PLASTIC(connProp);
//
//  if (synWtType == SYN_PLASTIC) {
//      sim_with_fixedwts = false; // if network has any plastic synapses at all, this will be set to true
//      managerRuntimeData.Npre_plastic[dest]++;
//      // homeostasis
//      if (groupConfigs[0][destGrp].WithHomeostasis && groupConfigs[0][destGrp].homeoId ==-1)
//          groupConfigs[0][destGrp].homeoId = dest; // this neuron info will be printed
//  }
//
//  managerRuntimeData.Npre[dest] += 1;
//  managerRuntimeData.Npost[src] += 1;
//
//  groupInfo[srcGrp].numPostConn++;
//  groupInfo[destGrp].numPreConn++;
//
//  if (managerRuntimeData.Npost[src] > groupInfo[srcGrp].maxPostConn)
//      groupInfo[srcGrp].maxPostConn = managerRuntimeData.Npost[src];
//  if (managerRuntimeData.Npre[dest] > groupInfo[destGrp].maxPreConn)
//  groupInfo[destGrp].maxPreConn = managerRuntimeData.Npre[src];
//}