CbmMcbm2018EventBuilder.h

Go to the documentation of this file.

/* Copyright (C) 2019-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Florian Uhlig [committer] */
 
#ifndef CBMMCBM2018EVENTBUILDER_H
#define CBMMCBM2018EVENTBUILDER_H
 
#include "CbmDefs.h"
#include "CbmEvent.h"
#include "CbmTofDigi.h"
 
#include "FairTask.h"
 
#include <tuple>
 
#include <array>
#include <map>
#include <set>
#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 SetTriggerMinNumberBmon(Int_t val) { fTriggerMinBmonDigis = 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 SetTriggerMaxNumberBmon(Int_t val) { fTriggerMaxBmonDigis = 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>* fBmonDigiVec = nullptr;  
  TClonesArray* fBmonDigiArr                  = 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* fhNbDigiPerEvtTimeBmon {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 fTriggerMinBmonDigis {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 fTriggerMaxBmonDigis = -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