CbmMcbm2018EventBuilder.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 CBMMCBM2018EVENTBUILDER_H
#define CBMMCBM2018EVENTBUILDER_H
 
#include "FairTask.h"
 
#include "CbmDefs.h"
#include "CbmEvent.h"
 
#include "CbmTofDigi.h"
#include <array>
#include <map>
#include <set>
#include <tuple>
#include <vector>
 
class TClonesArray;
class TH1;
class TH2;
class CbmDigiManager;
 
 
enum class EventBuilderAlgo { FixedTimeWindow, MaximumTimeGap };
 
//typedef std::tuple<ECbmModuleId, Int_t> digituple;
 
typedef std::pair<ECbmModuleId, Int_t> digituple;
 
/*
struct classcomp {
  bool operator() (const digituple& lhs, const digituple& rhs) const
  {
//    CbmDigi* digi_lhs = std::get<0>(lhs);
//    CbmDigi* digi_rhs = std::get<0>(rhs);
//    Double_t time_lhs = std::get<0>(lhs)->GetTime();
//    Double_t time_rhs = std::get<0>(rhs)->GetTime();
    return std::get<0>(lhs)->GetTime() < std::get<0>(rhs)->GetTime();
  }
};
*/
 
class CbmMcbm2018EventBuilder : public FairTask {
public:
  CbmMcbm2018EventBuilder();
 
  CbmMcbm2018EventBuilder(const CbmMcbm2018EventBuilder&) = delete;
  CbmMcbm2018EventBuilder operator=(const CbmMcbm2018EventBuilder&) = delete;
 
  //  CbmMcbm2018EventBuilder(Int_t verbose);
 
 
  ~CbmMcbm2018EventBuilder();
 
 
  virtual InitStatus Init();
 
  virtual InitStatus ReInit();
 
 
  virtual void Exec(Option_t*);
 
  virtual void SetParContainers();
 
  virtual void Finish();
 
  void SetFillHistos(Bool_t var) { fFillHistos = var; }
  void SetOutFilename(TString sNameIn) { fOutFileName = sNameIn; }
 
  void SetEventBuilderAlgo(
    EventBuilderAlgo algo = EventBuilderAlgo::FixedTimeWindow) {
    fEventBuilderAlgo = algo;
  }
  void SetFixedTimeWindow(Double_t val) { fFixedTimeWindow = val; }
  void SetMaximumTimeGap(Double_t val) { fMaximumTimeGap = val; }
 
  void SetTriggerMinNumberT0(Int_t val) { fTriggerMinT0Digis = val; }
  void SetTriggerMinNumberSts(Int_t val) { fTriggerMinStsDigis = val; }
  void SetTriggerMinNumberMuch(Int_t val) { fTriggerMinMuchDigis = val; }
  void SetTriggerMinNumberTrd(Int_t val) { fTriggerMinTrdDigis = val; }
  void SetTriggerMinNumberTof(Int_t val) { fTriggerMinTofDigis = val; }
  void SetTriggerMinNumberRich(Int_t val) { fTriggerMinRichDigis = val; }
  void SetTriggerMinNumberPsd(Int_t val) { fTriggerMinPsdDigis = val; }
 
  void SetTriggerMaxNumberT0(Int_t val) { fTriggerMaxT0Digis = val; }
  void SetTriggerMaxNumberSts(Int_t val) { fTriggerMaxStsDigis = val; }
  void SetTriggerMaxNumberMuch(Int_t val) { fTriggerMaxMuchDigis = val; }
  void SetTriggerMaxNumberTrd(Int_t val) { fTriggerMaxTrdDigis = val; }
  void SetTriggerMaxNumberTof(Int_t val) { fTriggerMaxTofDigis = val; }
  void SetTriggerMaxNumberRich(Int_t val) { fTriggerMaxRichDigis = val; }
  void SetTriggerMaxNumberPsd(Int_t val) { fTriggerMaxPsdDigis = val; }
 
  void SetUseBaseMuchDigi(Bool_t bFlag = kTRUE) { fbUseBaseMuchDigi = bFlag; }
 
private:
  void InitSorter();
  void BuildEvents();
  void FillHisto();
  void DefineGoodEvents();
  void FillOutput();
  template<class Digi>
  void AddDigiToSorter(ECbmModuleId, Int_t);
  void AddDigiToEvent(ECbmModuleId, Int_t);
 
  Bool_t IsDigiInEvent(Double_t);
  Bool_t HasTrigger(CbmEvent*);
 
 
  Int_t fCurEv {0};         
  Int_t fErrors {0};        
  Int_t fNrTs {0};          
  Double_t fPrevTime {0.};  
 
  Bool_t fbUseBaseMuchDigi                  = kFALSE;
  CbmDigiManager* fDigiMan                  = nullptr;  
  const std::vector<CbmTofDigi>* fT0DigiVec = nullptr;  
  TClonesArray* fT0DigiArr = nullptr;  
  TClonesArray* fEvents    = nullptr;  
 
  std::array<TClonesArray*, ToIntegralType(ECbmModuleId::kNofSystems)>
    fLinkArray;  
 
  //std::multiset<digituple, classcomp> fSorter; //! std::set to sort the digis time wise
  std::multimap<Double_t, digituple> fSorter;  
 
  std::vector<std::pair<ECbmModuleId, Int_t>> fVect;  
 
  CbmEvent* fCurrentEvent {
    nullptr};  
  std::vector<CbmEvent*> fEventVector;  
 
  TH1* fDiffTime {
    nullptr};  
  TH1* fhEventTime {nullptr};  
  TH1* fhEventDt {
    nullptr};  
  TH1* fhEventSize {
    nullptr};  
  TH2* fhNbDigiPerEvtTime {
    nullptr};  
  TH2* fhNbDigiPerEvtTimeT0 {
    nullptr};  
  TH2* fhNbDigiPerEvtTimeSts {
    nullptr};  
  TH2* fhNbDigiPerEvtTimeMuch {
    nullptr};  
  TH2* fhNbDigiPerEvtTimeTrd {
    nullptr};  
  TH2* fhNbDigiPerEvtTimeTof {
    nullptr};  
  TH2* fhNbDigiPerEvtTimeRich {
    nullptr};  
  TH2* fhNbDigiPerEvtTimePsd {
    nullptr};  
  Bool_t fFillHistos {kTRUE};  
 
  EventBuilderAlgo fEventBuilderAlgo {EventBuilderAlgo::FixedTimeWindow};
  Double_t fFixedTimeWindow {100.};
  Double_t fStartTimeEvent {0.};
  Double_t fMaximumTimeGap {100.};
 
  Int_t fTriggerMinT0Digis {0};
  Int_t fTriggerMinStsDigis {0};
  Int_t fTriggerMinMuchDigis {0};
  Int_t fTriggerMinTrdDigis {0};
  Int_t fTriggerMinTofDigis {0};
  Int_t fTriggerMinRichDigis {0};
  Int_t fTriggerMinPsdDigis {0};
  Int_t fTriggerMaxT0Digis = -1;
  Int_t fTriggerMaxStsDigis = -1;
  Int_t fTriggerMaxMuchDigis = -1;
  Int_t fTriggerMaxTrdDigis = -1;
  Int_t fTriggerMaxTofDigis = -1;
  Int_t fTriggerMaxRichDigis = -1;
  Int_t fTriggerMaxPsdDigis = -1;
 
  TString fOutFileName {"HistosEventBuilder.root"};
 
  ClassDef(CbmMcbm2018EventBuilder, 2);
};
 
#endif