FairTSBufferFunctional.h

Go to the documentation of this file.

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
#ifndef FairTSBufferFunctionalFunctional_H_
#define FairTSBufferFunctionalFunctional_H_

#include "FairTimeStamp.h"   // for FairTimeStamp

#include <Rtypes.h>     // for Int_t, Bool_t, Double_t, etc
#include <TObject.h>    // for TObject
#include <TString.h>    // for TString
#include <functional>   // for binary_function
#include <iostream>     // for operator<<, basic_ostream, etc

class TBranch;
class TClonesArray;
class TTree;

class BinaryFunctor : public std::binary_function<FairTimeStamp*, double, bool>
{
  public:
    virtual bool operator()(FairTimeStamp* a, double b) { return Call(a, b); };
    virtual bool Call(FairTimeStamp* a, double b) = 0;
    virtual bool TimeOut() { return false; }
    virtual void ResetTimeOut(){};

    virtual ~BinaryFunctor(){};
};

class StopTime : public BinaryFunctor
{
  public:
    StopTime()
        : fRequestTime(-1)
        , fOldTime(-1)
        , fSameTimeRequestCounter(0){};

    bool Call(FairTimeStamp* a, double b)
    {
        fRequestTime = b;
        // std::cout << "StopTime: " << a->GetTimeStamp() << " > " <<  b << std::endl;
        return a->GetTimeStamp() > b;
    };

    bool TimeOut()
    {
        if (fRequestTime != fOldTime) {
            fOldTime = fRequestTime;
            fSameTimeRequestCounter = 0;
            // std::cout << "RequestedTime: " << fRequestTime << std::endl;
            return false;
        } else if (fRequestTime == fOldTime) {
            std::cout << "-I- FairTSBufferFunctional StopTime has requested the same data as before: " << fRequestTime
                      << std::endl;
            fSameTimeRequestCounter++;
        } else {
            std::cout << "-E- FairTSBufferFunctional StopTime Functor has requested time " << fRequestTime
                      << " smaller than old time " << fOldTime << std::endl;
            return true;
        }
        if (fSameTimeRequestCounter > 9) {
            return true;
        } else {
            return false;
        }
    }

    void ResetTimeOut() { fSameTimeRequestCounter = 0; }

  private:
    double fRequestTime;
    double fOldTime;
    int fSameTimeRequestCounter;
};

class TimeGap : public BinaryFunctor
{
  public:
    TimeGap()
        : fOldTime(-1.){};

    bool Call(FairTimeStamp* a, double b)
    {
        double aTime = a->GetTimeStamp();

        if (fOldTime < 0) {
            fOldTime = aTime;
            return false;
        }
        if (aTime - fOldTime > b) {
            fOldTime = aTime;
            return true;
        } else {
            fOldTime = aTime;
            return false;
        }
    };

  private:
    double fOldTime;
};

class FairTSBufferFunctional : public TObject
{
  public:
    FairTSBufferFunctional(TString branchName,
                           TTree* sourceTree,
                           BinaryFunctor* stopFunction,
                           BinaryFunctor* startFunction = 0);

    virtual ~FairTSBufferFunctional(){};
    TClonesArray* GetData(Double_t stopParameter);
    TClonesArray* GetData(Double_t startParameter, Double_t stopParameter);
    Int_t GetBranchIndex() { return fBranchIndex; }

    void SetBranchIndex(const Int_t val) { fBranchIndex = val; }
    void SetStartFunction(BinaryFunctor* function) { fStartFunction = function; }
    void SetStopFunction(BinaryFunctor* function) { fStopFunction = function; }
    Bool_t AllDataProcessed();
    void Terminate() { fTerminate = kTRUE; }

    Bool_t TimeOut()
    {
        Bool_t stopTimeOut = fStopFunction->TimeOut();
        Bool_t startTimeOut = kTRUE;
        if (fStartFunction != 0) {
            startTimeOut = fStartFunction->TimeOut();
            //        if (startTimeOut == kTRUE && stopTimeOut == kFALSE){
            //          fStartFunction->ResetTimeOut();
            //        }
            //        else if (startTimeOut == kFALSE && stopTimeOut == kTRUE){
            //          fStopFunction->ResetTimeOut();
            //        }
        }
        return (stopTimeOut && startTimeOut);
    }

    Int_t FindStartIndex(Double_t startParameter);

  private:
    void ReadInNextFilledEntry();
    Int_t ReadInPreviousFilledEntry(Int_t startEntry);
    void ReadInNextEntry();   //** used only if no function is given and input data is directly passed through to the
                              // OutputArray
    void ReadInEntry(Int_t number);
    void AbsorbDataBufferArray();   //< Absorbs the complete data from fInputArray to fBufferArray

    TClonesArray* fOutputArray;
    TClonesArray* fBufferArray;
    TClonesArray* fInputArray;

    BinaryFunctor* fStartFunction;
    BinaryFunctor* fStopFunction;

    TBranch* fBranch;
    Int_t fBranchIndex;

    Bool_t fTerminate;

    Int_t fVerbose;

    FairTSBufferFunctional(const FairTSBufferFunctional&);
    FairTSBufferFunctional& operator=(const FairTSBufferFunctional&);

    ClassDef(FairTSBufferFunctional, 0);
};

#endif