group_monitor_core.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 <group_monitor_core.h>

#include <snn.h>                // CARLsim private implementation
#include <snn_definitions.h>    // KERNEL_ERROR, KERNEL_INFO, ...

#include <algorithm>            // std::sort

// we aren't using namespace std so pay attention!
GroupMonitorCore::GroupMonitorCore(SNN* snn, int monitorId, int grpId, int mode) {
    snn_ = snn;
    grpId_= grpId;
    monitorId_ = monitorId;
    mode_ = mode; 

    groupFileId_ = NULL;
    recordSet_ = false;
    grpMonLastUpdated_ = 0;

    persistentData_ = false;

    needToWriteFileHeader_ = true;
    groupFileSignature_ = 206661989;
    groupFileVersion_ = 0.2f;

    // defer all unsafe operations to init function
    init();
}

void GroupMonitorCore::init() {
    nNeurons_ = snn_->getGroupNumNeurons(grpId_);
    assert(nNeurons_> 0);



    clear();

    // use KERNEL_{ERROR|WARNING|etc} typesetting (const FILE*)
    fpInf_ = snn_->getLogFpInf();
    fpErr_ = snn_->getLogFpErr();
    fpDeb_ = snn_->getLogFpDeb();
    fpLog_ = snn_->getLogFpLog();
}

GroupMonitorCore::~GroupMonitorCore() {
    if (groupFileId_ != NULL) {
        fclose(groupFileId_);
        groupFileId_ = NULL;
    }
}

// +++++ PUBLIC METHODS: +++++++++++++++++++++++++++++++++++++++++++++++//

void GroupMonitorCore::clear() {
    assert(!isRecording());
    recordSet_ = false;
    startTime_ = -1;
    startTimeLast_ = -1;
    stopTime_ = -1;
    accumTime_ = 0;
    totalTime_ = -1;

    timeVector_.clear();
    dataVector_.clear();
}

void GroupMonitorCore::pushData(int time, float data) {
    assert(isRecording());

    timeVector_.push_back(time);
    dataVector_.push_back(data);
}

void GroupMonitorCore::pushData(int time, float _DA, float _5HT, float _ACh, float _NE) {
    assert(isRecording());

    timeVector_.push_back(time);
    data4Vector_[0].push_back(_DA);
    data4Vector_[1].push_back(_5HT);
    data4Vector_[2].push_back(_ACh);
    data4Vector_[3].push_back(_NE);
}

std::vector<float> GroupMonitorCore::getDataVector(){
    return dataVector_;
}

std::vector<float> GroupMonitorCore::getDataVector(transmitter_t transmitter){
    return data4Vector_[transmitter];
}

std::vector<int> GroupMonitorCore::getTimeVector(){
    return timeVector_;
}

std::vector<int> GroupMonitorCore::getPeakTimeVector() {
    std::vector<int> peakTimeVector;

    int size = dataVector_.size() - 1;
    for (int i = 1; i < size; i++) {
        if (dataVector_[i-1] < dataVector_[i] && dataVector_[i] > dataVector_[i+1])
            peakTimeVector.push_back(timeVector_[i]);
    }

    return peakTimeVector;
}

std::vector<int> GroupMonitorCore::getSortedPeakTimeVector() {
    std::vector<int> sortedPeakTimeVector;

    int size = dataVector_.size() - 1;
    for (int i = 1; i < size; i++) {
        if (dataVector_[i-1] < dataVector_[i] && dataVector_[i] > dataVector_[i+1])
            sortedPeakTimeVector.push_back(timeVector_[i]);
    }

    std::sort(sortedPeakTimeVector.begin(), sortedPeakTimeVector.end());
    std::reverse(sortedPeakTimeVector.begin(), sortedPeakTimeVector.end());
    
    return sortedPeakTimeVector;
}

std::vector<float> GroupMonitorCore::getPeakValueVector() {
    std::vector<float> peakValueVector;

    int size = dataVector_.size() - 1;
    for (int i = 1; i < size; i++) {
        if (dataVector_[i-1] < dataVector_[i] && dataVector_[i] > dataVector_[i+1])
            peakValueVector.push_back(dataVector_[i]);
    }

    return peakValueVector;
}

std::vector<float> GroupMonitorCore::getSortedPeakValueVector() {
    std::vector<float> sortedPeakValueVector;

    int size = dataVector_.size() - 1;
    for (int i = 1; i < size; i++) {
        if (dataVector_[i-1] < dataVector_[i] && dataVector_[i] > dataVector_[i+1])
            sortedPeakValueVector.push_back(dataVector_[i]);
    }

    std::sort(sortedPeakValueVector.begin(), sortedPeakValueVector.end());
    std::reverse(sortedPeakValueVector.begin(), sortedPeakValueVector.end());

    return sortedPeakValueVector;
}

void GroupMonitorCore::startRecording() {
    if (!persistentData_) {
        // if persistent mode is off (default behavior), automatically call clear() here
        clear();
    }

    // call updateGroupMonitor to make sure group data file and the data vector are up-to-date
    // Caution: must be called before recordSet_ is set to true!
    snn_->updateGroupMonitor(grpId_);

    recordSet_ = true;
    int currentTime = snn_->getSimTimeSec()*1000+snn_->getSimTimeMs();

    if (persistentData_) {
        // persistent mode on: accumulate all times
        // change start time only if this is the first time running it
        startTime_ = (startTime_<0) ? currentTime : startTime_;
        startTimeLast_ = currentTime;
        accumTime_ = (totalTime_>0) ? totalTime_ : 0;
    } else {
        // persistent mode off: we only care about the last probe
        startTime_ = currentTime;
        startTimeLast_ = currentTime;
        accumTime_ = 0;
    }
}

void GroupMonitorCore::stopRecording() {
    assert(isRecording());
    assert(startTime_>-1 && startTimeLast_>-1 && accumTime_>-1);

    // call updateGroupMonitor to make sure group data file and the data vector are up-to-date
    // Caution: must be called before recordSet_ is set to false!
    snn_->updateGroupMonitor(grpId_);

    recordSet_ = false;
    stopTime_ = snn_->getSimTimeSec()*1000+snn_->getSimTimeMs();

    // total time is the amount of time of the last probe plus all accumulated time from previous probes
    totalTime_ = stopTime_-startTimeLast_ + accumTime_;
    assert(totalTime_>=0);
}

void GroupMonitorCore::setGroupFileId(FILE* groupFileId) {
    assert(!isRecording());

    // \TODO consider the case where this function is called more than once
    if (groupFileId_ != NULL)
        KERNEL_ERROR("GroupMonitorCore: setGroupFileId() has already been called.");

    groupFileId_ = groupFileId;

    if (groupFileId_ == NULL)
        needToWriteFileHeader_ = false;
    else {
        // for now: file pointer has changed, so we need to write header (again)
        needToWriteFileHeader_ = true;
        writeGroupFileHeader();
    }
}

// write the header section of the group data file
// this should be done once per file, and should be the very first entries in the file
void GroupMonitorCore::writeGroupFileHeader() {
    if (!needToWriteFileHeader_)
        return;

    // write file signature
    if (!fwrite(&groupFileSignature_, sizeof(int), 1, groupFileId_))
        KERNEL_ERROR("GroupMonitorCore: writeSpikeFileHeader has fwrite error");

    // write version number
    if (!fwrite(&groupFileVersion_, sizeof(float), 1, groupFileId_))
        KERNEL_ERROR("GroupMonitorCore: writeGroupFileHeader has fwrite error");

    // write grid dimensions
    Grid3D grid = snn_->getGroupGrid3D(grpId_);
    int tmpInt = grid.numX;
    if (!fwrite(&tmpInt,sizeof(int), 1, groupFileId_))
        KERNEL_ERROR("GroupMonitorCore: writeGroupFileHeader has fwrite error");
    //printf("group file header tmpInt/grid.numX: %d\n", tmpInt);

    tmpInt = grid.numY;
    if (!fwrite(&tmpInt,sizeof(int),1,groupFileId_))
        KERNEL_ERROR("GroupMonitorCore: writeGroupFileHeader has fwrite error");
    //printf("group file header tmpInt/grid.numY: %d\n", tmpInt);

    tmpInt = grid.numZ;
    if (!fwrite(&tmpInt,sizeof(int),1,groupFileId_))
        KERNEL_ERROR("GroupMonitorCore: writeGroupFileHeader has fwrite error");
    //printf("group file header tmpInt/grid.numZ: %d\n", tmpInt);

    // the header is written once at the beginning, so the actual size is not known
    //tmpInt = timeVector_.size(); 
    //if (!fwrite(&tmpInt,sizeof(int),1,groupFileId_))
    //  KERNEL_ERROR("ConnectionMonitor: writeConnectFileHeader has fwrite error");
    //printf("group file header tmpInt/timeVector_.size(): %d \n", tmpInt);

    // LN: issue: how to handle remainting Neurotransmitter 5HT, ACL and NOR ? 
    // Var 1: handle each transmitter seprately 
    // Var 2: make a new array t x 4  (-) backward comp -> irrelevant, du it is not yet implemented

    // V2 feat: compression => store only data <> base concentration
    // V2 feat: bit mask from header:  e.g. ACH | DA  => stores and retrieves DA, ACH in that order
            
    // LN: DA or ALL Transmitter 
    tmpInt = mode_;  
    if (!fwrite(&tmpInt,sizeof(int),1,groupFileId_))
        KERNEL_ERROR("ConnectionMonitor: writeConnectFileHeader has fwrite error");
    //printf("group file header tmpInt/mode_: %d\n", tmpInt);

    //printf("header size %d\n", sizeof(int)*5+sizeof(float)*1); 

    needToWriteFileHeader_ = false;
}