CbmMcbm2019TimeWinEventBuilderAlgo.h

Go to the documentation of this file.

/* Copyright (C) 2020-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer] */
 
#ifndef CBMMCBM2019TIMEWINEVENTBUILDERALGO_H
#define CBMMCBM2019TIMEWINEVENTBUILDERALGO_H
 
#include "CbmTofDigi.h"
 
#include "FairTask.h"
 
 
#include <tuple>
 
#include <array>
#include <map>
#include <set>
#include <vector>
 
class TimesliceMetaData;
class CbmEvent;
class CbmDigiManager;
class TClonesArray;
class TH1;
class TH2;
class TNamed;
class TCanvas;
 
enum class EOverlapMode
{
  NoOverlap,
  MergeOverlap,
  AllowOverlap
};
 
class EventBuilderDetector {
public:
  EventBuilderDetector() { ; }
  EventBuilderDetector(ECbmModuleId detIdIn, ECbmDataType dataTypeIn, std::string sNameIn)
  {
    detId    = detIdIn;
    dataType = dataTypeIn;
    sName    = sNameIn;
  }
  EventBuilderDetector(ECbmModuleId detIdIn, ECbmDataType dataTypeIn, std::string sNameIn, UInt_t uTriggerMinDigisIn,
                       Int_t iTriggerMaxDigisIn, Double_t fdTimeWinBegIn, Double_t fdTimeWinEndIn)
    : EventBuilderDetector(detIdIn, dataTypeIn, sNameIn)
  {
    fuTriggerMinDigis = uTriggerMinDigisIn;
    fiTriggerMaxDigis = iTriggerMaxDigisIn;
 
    fdTimeWinBeg = fdTimeWinBegIn;
    fdTimeWinEnd = fdTimeWinEndIn;
  }
 
  bool operator==(const EventBuilderDetector& other) const { return (other.detId == this->detId); }
  bool operator!=(const EventBuilderDetector& other) const { return (other.detId != this->detId); }
 
  Double_t GetTimeWinRange() { return fdTimeWinEnd - fdTimeWinBeg; }
 
  ECbmModuleId detId    = ECbmModuleId::kNotExist;
  ECbmDataType dataType = ECbmDataType::kUnknown;
  std::string sName     = "Invalid";
  UInt_t fuTriggerMinDigis = 0;
  Int_t fiTriggerMaxDigis = -1;
  Double_t fdTimeWinBeg = -100;
  Double_t fdTimeWinEnd = 100;
 
  UInt_t fuStartIndex = 0;
  UInt_t fuEndIndex   = 0;
};
 
static const EventBuilderDetector kEventBuilderDetSts =
  EventBuilderDetector(ECbmModuleId::kSts, ECbmDataType::kStsDigi, "Sts");
static const EventBuilderDetector kEventBuilderDetMuch =
  EventBuilderDetector(ECbmModuleId::kMuch, ECbmDataType::kMuchDigi, "Much");
static const EventBuilderDetector kEventBuilderDetTrd =
  EventBuilderDetector(ECbmModuleId::kTrd, ECbmDataType::kTrdDigi, "Trd");
static const EventBuilderDetector kEventBuilderDetTof =
  EventBuilderDetector(ECbmModuleId::kTof, ECbmDataType::kTofDigi, "Tof");
static const EventBuilderDetector kEventBuilderDetRich =
  EventBuilderDetector(ECbmModuleId::kRich, ECbmDataType::kRichDigi, "Rich");
static const EventBuilderDetector kEventBuilderDetPsd =
  EventBuilderDetector(ECbmModuleId::kPsd, ECbmDataType::kPsdDigi, "Psd");
static const EventBuilderDetector kEventBuilderDetBmon =
  EventBuilderDetector(ECbmModuleId::kBmon, ECbmDataType::kBmonDigi, "Bmon");
static const EventBuilderDetector kEventBuilderDetUndef = EventBuilderDetector();
 
class CbmMcbm2019TimeWinEventBuilderAlgo {
public:
  CbmMcbm2019TimeWinEventBuilderAlgo();
 
  CbmMcbm2019TimeWinEventBuilderAlgo(const CbmMcbm2019TimeWinEventBuilderAlgo&) = delete;
  CbmMcbm2019TimeWinEventBuilderAlgo operator=(const CbmMcbm2019TimeWinEventBuilderAlgo&) = delete;
 
  ~CbmMcbm2019TimeWinEventBuilderAlgo();
 
  Bool_t InitAlgo();
 
  void ProcessTs();
 
  void Finish();
 
  void SetFillHistos(Bool_t var) { fbFillHistos = var; }
  void ResetHistograms(Bool_t bResetTime = kTRUE);
 
  void SetReferenceDetector(ECbmModuleId refDet, ECbmDataType dataTypeIn, std::string sNameIn,
                            UInt_t uTriggerMinDigisIn = 0, Int_t iTriggerMaxDigisIn = -1,
                            Double_t fdTimeWinBegIn = -100, Double_t fdTimeWinEndIn = 100);
  void AddDetector(ECbmModuleId selDet, ECbmDataType dataTypeIn, std::string sNameIn, UInt_t uTriggerMinDigisIn = 0,
                   Int_t iTriggerMaxDigisIn = -1, Double_t fdTimeWinBegIn = -100, Double_t fdTimeWinEndIn = 100);
 
  void SetReferenceDetector(EventBuilderDetector refDetIn);
  void AddDetector(EventBuilderDetector selDet);
  void RemoveDetector(EventBuilderDetector selDet);
 
  void SetTriggerMinNumber(ECbmModuleId selDet, UInt_t uVal);
  void SetTriggerMaxNumber(ECbmModuleId selDet, Int_t iVal);
 
  void SetTriggerWindow(ECbmModuleId selDet, Double_t dWinBeg, Double_t dWinEnd);
 
  void SetTsParameters(Double_t dTsStartTime, Double_t dTsLength, Double_t dTsOverLength)
  {
    fdTsStartTime  = dTsStartTime;
    fdTsLength     = dTsLength;
    fdTsOverLength = dTsOverLength;
  }
 
  void SetEventOverlapMode(EOverlapMode mode) { fOverMode = mode; }
  void SetIgnoreTsOverlap(Bool_t bFlagIn = kTRUE) { fbIgnoreTsOverlap = bFlagIn; }
 
  void ChangeMuchBeamtimeDigiFlag(Bool_t bFlagIn = kFALSE) { fbUseMuchBeamtimeDigi = bFlagIn; }
 
  void AddHistoToVector(TNamed* pointer, std::string sFolder = "")
  {
    fvpAllHistoPointers.push_back(std::pair<TNamed*, std::string>(pointer, sFolder));
  }
  std::vector<std::pair<TNamed*, std::string>> GetHistoVector() { return fvpAllHistoPointers; }
  void AddCanvasToVector(TCanvas* pointer, std::string sFolder = "")
  {
    fvpAllCanvasPointers.push_back(std::pair<TCanvas*, std::string>(pointer, sFolder));
  }
  std::vector<std::pair<TCanvas*, std::string>> GetCanvasVector() { return fvpAllCanvasPointers; }
 
  std::vector<CbmEvent*>& GetEventVector() { return fEventVector; }
  void ClearEventVector();
 
private:
  Bool_t CheckDataAvailable(EventBuilderDetector& det);
  void InitTs();
  void BuildEvents();
 
  void CreateHistograms();
  void FillHistos();
 
  template<class DigiSeed>
  void LoopOnSeeds();
  void CheckSeed(Double_t dSeedTime, UInt_t uSeedDigiIdx);
  template<class DigiCheck>
  void SearchMatches(Double_t dSeedTime, EventBuilderDetector& detMatch);
  void AddDigiToEvent(EventBuilderDetector& det, Int_t uIdx);
  Bool_t HasTrigger(CbmEvent*);
  Bool_t CheckTriggerConditions(CbmEvent* event, EventBuilderDetector& det);
 
  void UpdateTimeWinBoundariesExtrema();
  void UpdateWidestTimeWinRange();
 
  static constexpr Double_t kdDefaultTimeWinBeg = -100.0;
  static constexpr Double_t kdDefaultTimeWinEnd = 100.0;
 
  Bool_t fbIgnoreTsOverlap = kFALSE;     
  Bool_t fbFillHistos {kTRUE};           
  Bool_t fbUseMuchBeamtimeDigi = kTRUE;  
  EOverlapMode fOverMode {EOverlapMode::AllowOverlap};
 
  EventBuilderDetector fRefDet             = EventBuilderDetector(ECbmModuleId::kBmon, ECbmDataType::kBmonDigi, "Bmon");
  std::vector<EventBuilderDetector> fvDets = {
    EventBuilderDetector(ECbmModuleId::kSts, ECbmDataType::kStsDigi, "kSts"),
    EventBuilderDetector(ECbmModuleId::kMuch, ECbmDataType::kMuchDigi, "kMuch"),
    EventBuilderDetector(ECbmModuleId::kTrd, ECbmDataType::kTrdDigi, "kTrd"),
    EventBuilderDetector(ECbmModuleId::kTof, ECbmDataType::kTofDigi, "kTof"),
    EventBuilderDetector(ECbmModuleId::kRich, ECbmDataType::kRichDigi, "kRich"),
    EventBuilderDetector(ECbmModuleId::kPsd, ECbmDataType::kPsdDigi, "kPsd")};
 
  Double_t fdEarliestTimeWinBeg = kdDefaultTimeWinBeg;
  Double_t fdLatestTimeWinEnd   = kdDefaultTimeWinEnd;
  Double_t fdWidestTimeWinRange = kdDefaultTimeWinEnd - kdDefaultTimeWinBeg;
 
  Double_t fdTsStartTime  = -1;
  Double_t fdTsLength     = -1;
  Double_t fdTsOverLength = -1;
 
  CbmDigiManager* fDigiMan                  = nullptr;  
  const std::vector<CbmTofDigi>* fBmonDigiVec = nullptr;  
  TClonesArray* fTimeSliceMetaDataArray     = nullptr;  
  const TimesliceMetaData* pTsMetaData      = nullptr;
 
  CbmEvent* fCurrentEvent             = nullptr;  
  std::vector<CbmEvent*> fEventVector = {};       
 
  std::vector<std::pair<TNamed*, std::string>>
    fvpAllHistoPointers;  
  std::vector<std::pair<TCanvas*, std::string>>
    fvpAllCanvasPointers;  
 
  TH1* fhEventTime        = nullptr;  
  TH1* fhEventDt          = nullptr;  
  TH1* fhEventSize        = nullptr;  
  TH2* fhNbDigiPerEvtTime = nullptr;  
  std::vector<TH2*> fvhNbDigiPerEvtTimeDet =
    {};  
 
  UInt_t fuCurEv            = 0;   
  UInt_t fuErrors           = 0;   
  UInt_t fuNrTs             = 0;   
  Double_t fdPrevEvtTime    = 0.;  
  Double_t fdPrevEvtEndTime = 0.;  
 
  ClassDefNV(CbmMcbm2019TimeWinEventBuilderAlgo, 1);
};
 
#endif  // CBMMCBM2019TIMEWINEVENTBUILDERALGO_H