FairWriteoutBuffer.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 FairWriteoutBuffer_H_
#define FairWriteoutBuffer_H_

#include "FairLogger.h"        // for FairLogger
#include "FairRootManager.h"   // for FairRootManager
#include "FairTimeStamp.h"     // for FairTimeStamp

#include <Rtypes.h>         // for Bool_t, Int_t, etc
#include <TClonesArray.h>   // for TClonesArray
#include <TObject.h>        // for TObject
#include <TString.h>        // for TString
#include <iostream>         // for cout, ostream
#include <map>              // for multimap
#include <utility>          // for pair
#include <vector>           // for vector

class FairWriteoutBuffer : public TObject
{
  public:
    FairWriteoutBuffer()
        : TObject()
        , fStartTime_map()
        , fDeadTime_map()
        , fBranchName()
        , fClassName()
        , fTreeSave(false)
        , fActivateBuffering(kFALSE)
        , fVerbose(0)
        , fLogger(FairLogger::GetLogger()){};
    FairWriteoutBuffer(TString branchName, TString className, TString folderName, Bool_t persistance);
    virtual ~FairWriteoutBuffer(){};

    virtual void SaveDataToTree(Bool_t val = kTRUE)
    {
        fTreeSave = val;   
    }
    virtual void ActivateBuffering(Bool_t val = kTRUE)
    {
        fActivateBuffering = val;   
    }

    Bool_t IsBufferingActivated() { return fActivateBuffering; }

    virtual void FillNewData(FairTimeStamp* data, double startTime, double activeTime);

    virtual Int_t GetNData() { return fDeadTime_map.size(); }
    virtual std::vector<FairTimeStamp*> GetRemoveOldData(double time);
    virtual std::vector<FairTimeStamp*> GetAllData();

    virtual void SetVerbose(Int_t val) { fVerbose = val; }

    virtual void DeleteOldData()
    {
        if (fBranchName.Length() > 0) {
            TClonesArray* myArray = FairRootManager::Instance()->GetTClonesArray(fBranchName);
            myArray->Delete();
        }
    }

    virtual void WriteOutData(double time);
    virtual void WriteOutAllData();

  protected:
    virtual void AddNewDataToTClonesArray(
        FairTimeStamp* data) = 0;   
    virtual double FindTimeForData(
        FairTimeStamp* data) = 0;   
    virtual void FillDataMap(FairTimeStamp* data, double activeTime) = 0;   
    virtual void EraseDataFromDataMap(
        FairTimeStamp* data) = 0;   

    virtual std::vector<std::pair<double, FairTimeStamp*>> Modify(std::pair<double, FairTimeStamp*> oldData,
                                                                  std::pair<double, FairTimeStamp*>)
    {
        std::vector<std::pair<double, FairTimeStamp*>> result;
        result.push_back(oldData);
        return result;
    }

    virtual void WriteOutDataDeadTimeMap(double time);
    virtual void MoveDataFromStartTimeMapToDeadTimeMap(double time);
    virtual void FillDataToDeadTimeMap(FairTimeStamp* data, double activeTime, double startTime);

    virtual void PrintData(FairTimeStamp* data)
    {
        std::cout << data->GetTimeStamp();
    };   
    virtual void PrintDeadTimeMap();
    virtual void PrintStartTimeMap();

    std::multimap<double, std::pair<double, FairTimeStamp*>> fStartTime_map;
    std::multimap<double, FairTimeStamp*> fDeadTime_map;

    TString fBranchName;
    TString fClassName;
    Bool_t fTreeSave;
    Bool_t fActivateBuffering;
    Int_t fVerbose;
    FairLogger* fLogger;   

  private:
    FairWriteoutBuffer(const FairWriteoutBuffer&);
    FairWriteoutBuffer& operator=(const FairWriteoutBuffer&);

    ClassDef(FairWriteoutBuffer, 1);
};

#endif /* FairWriteoutBuffer_H_ */