FairTSBufferFunctional.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file FairTSBufferFunctional.h

#ifndef FairTSBufferFunctionalFunctional_H_
#define FairTSBufferFunctionalFunctional_H_

#include "FairTimeStamp.h"

#include "TObject.h"
#include "TTree.h"
#include "TBranch.h"
#include "TClonesArray.h"

#include <functional>

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() {};

};

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 SetStartFunction(BinaryFunctor* function) {fStartFunction=function;}
    void SetStopFunction(BinaryFunctor* function) {fStopFunction = function;}
    Bool_t AllDataProcessed();

    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;
    Int_t fStartIndex;

    Int_t fVerbose;

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

    ClassDef(FairTSBufferFunctional,0);

};


#endif