clizDectector.h

Go to the documentation of this file.

// clizDetector.h   -   ClusterLizard header file - Module: Detector

// Copyright (C) 2013, 2014 Simeon Knieling, M.Sc.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//

//Detector Class

#pragma once
#ifndef _INCLUDE_CLIZDETECTOR
#define _INCLUDE_CLIZDETECTOR

#include "clizSave.h"

namespace cliz
{

    struct DetectorHandle
    {
        unsigned int    filterCutOffBack;
        unsigned int    procChunkSize;
        unsigned int    detection;
        unsigned int    ref;
        unsigned int    stdmax;
        unsigned int    stdmin;
        unsigned int    w_pre;
        unsigned int    w_post;
        unsigned int    valuesperspike;
        unsigned int    maxNoiseTraces;
        bool            externalDetection;
    };

    class Detector
    {
    private:
        DetectorHandle                              handle;                 //Parameter handle
        std::vector<IndicesStruct>                  indicesOut;             //Which Modules that receive output from this module need which output?
        std::vector<Save*>                          inputSaveVec;           //Input Saves
        std::vector<Save*>                          outputSaveVec;          //Output Saves


        unsigned int                                numNoiseTraces;         //Current number of noise traces in buffer  

        float                                       *spikes;                //Spike buffer
        float                                       *noise;                 //Noise buffer
        float                                       *tempDataDetect;        //Temporary data buffer
        float                                       *tempData;              //Temporary data buffer

        float                                       thr, thrMax;            //Detection thresholds
        float                                       chunkRatio;
        unsigned int                                nspk;                   //Number of spikes detected in internal data chunk
        unsigned int                                gNspk;                  //Number of all spikes detected so far (only relevant for test datasets)
        uint64_t                                    *timestamps;            //Timestamp buffer
        uint64_t                                    *externalTimestamps;    //external timestamp buffer (only relevant for test datasets)
        uint64_t                                    lastChunkTimestamp;     //Timestamp of first data point in last chunk
        uint64_t                                    lastSpikeTimestamp;     //Timestamp of last spike
        uint64_t                                    lastNoiseTimestamp;     //Timestamp of last noise trace
        arma::Mat<float>                            whiteningMat;           //Whitening matrix

        uint64_t                                    currentTime;            //Current time
        MemoryManager                               memMan;

    public:
        Detector(DetectorHandle iHandle, std::vector<Save*> &iInputSaveVec, std::vector<Save*> &iOutputSaveVec, std::vector<IndicesStruct> &iIndicesOut);

        Detector(DetectorHandle iHandle, std::vector<Save*> &iInputSaveVec, std::vector<Save*> &iOutputSaveVec, std::vector<IndicesStruct> &iIndicesOut, uint64_t initialTimeStamp);

        Detector(DetectorHandle iHandle, std::vector<Save*> &iInputSaveVec, std::vector<Save*> &iOutputSaveVec, std::vector<IndicesStruct> &iIndicesOut, uint64_t initialTimeStamp, uint64_t *externallyDetectedTS, unsigned int spikeCount);
        
        void    detection(float *data, float *dataDetect);

        void    externalDetection(float *data, float *dataDetect);
        
        void    makeWhiteningMat();

        void    threadFunc();

        ~Detector()
        {
            memMan.free(tempDataDetect);
            memMan.free(tempData);
            memMan.free(noise);
            memMan.free(timestamps);
            memMan.free(spikes);
        };
    };
}

#endif