CbmAlgoBuildRawEvents.h

Go to the documentation of this file.

/* Copyright (C) 2020-2024 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer], Dominik Smith, Alexandru Bercuci*/
 
#ifndef CBMALGOBUILDRAWEVENTS_H
#define CBMALGOBUILDRAWEVENTS_H

#include "CbmDefs.h"


#include "TFolder.h"

#include "CbmMvdDigi.h"
 
#include <boost/any.hpp>
 
#include <array>
#include <map>
#include <set>
#include <tuple>
#include <vector>
 
class TimesliceMetaData;
class CbmEvent;
class CbmMuchDigi;
class CbmMuchBeamTimeDigi;
class CbmPsdDigi;
class CbmFsdDigi;
class CbmRichDigi;
class CbmStsDigi;
class CbmTofDigi;
class CbmTrdDigi;
class CbmBmonDigi;
class TClonesArray;
class TH1;
class TH2;
class TProfile;
class TNamed;
class TStopwatch;
class TCanvas;
class TDirectoryFile;
 
enum class EOverlapModeRaw
{
  NoOverlap,
  MergeOverlap,
  AllowOverlap,
  Undefined
};
 
class RawEventBuilderDetector {
 public:
  RawEventBuilderDetector() = default;
 
  RawEventBuilderDetector(ECbmModuleId detIdIn, ECbmDataType dataTypeIn, std::string sNameIn)
    : detId{detIdIn}
    , dataType{dataTypeIn}
    , sName{sNameIn}
  {
  }
 
  RawEventBuilderDetector(ECbmModuleId detIdIn, ECbmDataType dataTypeIn, std::string sNameIn, UInt_t uTriggerMinDigisIn,
                          Int_t iTriggerMaxDigisIn, Double_t fdTimeWinBegIn, Double_t fdTimeWinEndIn,
                          UInt_t uTriggerMinLayersIn = 0, Double_t fdHistMaxDigiNbIn = 1000)
    : RawEventBuilderDetector(detIdIn, dataTypeIn, sNameIn)
  {
    fuTriggerMinDigis  = uTriggerMinDigisIn;
    fiTriggerMaxDigis  = iTriggerMaxDigisIn;
    fuTriggerMinLayers = uTriggerMinLayersIn;
    fdTimeWinBeg       = fdTimeWinBegIn;
    fdTimeWinEnd       = fdTimeWinEndIn;
    fdHistMaxDigiNb    = fdHistMaxDigiNbIn;
  }
 
  bool operator==(const RawEventBuilderDetector& other) const { return (other.detId == this->detId); }
  bool operator!=(const RawEventBuilderDetector& 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;
  UInt_t fuTriggerMinLayers = 0;
  Double_t fdTimeWinBeg = -100;
  Double_t fdTimeWinEnd = 100;
  Double_t fdHistMaxDigiNb = 1000;
  UInt_t fuStartIndex = 0;
  UInt_t fuEndIndex   = 0;
};

static const RawEventBuilderDetector kRawEventBuilderDetMvd =
  RawEventBuilderDetector(ECbmModuleId::kMvd, ECbmDataType::kMvdDigi, "Mvd");
static const RawEventBuilderDetector kRawEventBuilderDetSts =
  RawEventBuilderDetector(ECbmModuleId::kSts, ECbmDataType::kStsDigi, "Sts");
static const RawEventBuilderDetector kRawEventBuilderDetMuch =
  RawEventBuilderDetector(ECbmModuleId::kMuch, ECbmDataType::kMuchDigi, "Much");
static const RawEventBuilderDetector kRawEventBuilderDetTrd =
  RawEventBuilderDetector(ECbmModuleId::kTrd, ECbmDataType::kTrdDigi, "Trd1D");
static const RawEventBuilderDetector kRawEventBuilderDetTrd2D =
  RawEventBuilderDetector(ECbmModuleId::kTrd2d, ECbmDataType::kTrdDigi, "Trd2D");
static const RawEventBuilderDetector kRawEventBuilderDetTof =
  RawEventBuilderDetector(ECbmModuleId::kTof, ECbmDataType::kTofDigi, "Tof");
static const RawEventBuilderDetector kRawEventBuilderDetRich =
  RawEventBuilderDetector(ECbmModuleId::kRich, ECbmDataType::kRichDigi, "Rich");
static const RawEventBuilderDetector kRawEventBuilderDetPsd =
  RawEventBuilderDetector(ECbmModuleId::kPsd, ECbmDataType::kPsdDigi, "Psd");
static const RawEventBuilderDetector kRawEventBuilderDetFsd =
  RawEventBuilderDetector(ECbmModuleId::kFsd, ECbmDataType::kFsdDigi, "Fsd");
static const RawEventBuilderDetector kRawEventBuilderDetBmon =
  RawEventBuilderDetector(ECbmModuleId::kBmon, ECbmDataType::kBmonDigi, "Bmon");
static const RawEventBuilderDetector kRawEventBuilderDetUndef = RawEventBuilderDetector();
 
class CbmAlgoBuildRawEvents {
 public:
  CbmAlgoBuildRawEvents() = default;
 
  CbmAlgoBuildRawEvents(const CbmAlgoBuildRawEvents&) = delete;
  CbmAlgoBuildRawEvents operator=(const CbmAlgoBuildRawEvents&) = delete;

  ~CbmAlgoBuildRawEvents(){};

  Bool_t InitAlgo();

  void ProcessTs();

  void Finish();
 
  void SetFillHistos(Bool_t var) { fbFillHistos = var; }
  void ResetHistograms(Bool_t bResetTime = kTRUE);

  void SetTimings(Bool_t var) { fbGetTimings = var; }
  void PrintTimings();
 
  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(RawEventBuilderDetector refDetIn, std::vector<bool> select = {});
  void AddDetector(RawEventBuilderDetector selDet);
  void RemoveDetector(RawEventBuilderDetector selDet);
 
  void SetTriggerMinNumber(ECbmModuleId selDet, UInt_t uVal);
  void SetTriggerMaxNumber(ECbmModuleId selDet, Int_t iVal);
  void SetTriggerMinLayersNumber(ECbmModuleId selDet, UInt_t uVal);
  void SetTriggerWindow(ECbmModuleId selDet, Double_t dWinBeg, Double_t dWinEnd);
  void SetHistogramMaxDigiNb(ECbmModuleId selDet, Double_t dDigiNbMax);
  void SetTsParameters(Double_t dTsStartTime, Double_t dTsLength, Double_t dTsOverLength)
  {
    fdTsStartTime   = dTsStartTime;
    fdTsLength      = dTsLength;
    fdTsOverLength  = dTsOverLength;
    fbUseTsMetaData = kFALSE;
  }
 
  void SetSeedTimeWindow(Double_t timeWinBeg, Double_t timeWinEnd)
  {
    fdSeedTimeWinBeg = timeWinBeg;
    fdSeedTimeWinEnd = timeWinEnd;
    UpdateTimeWinBoundariesExtrema();
    UpdateWidestTimeWinRange();
  }

  void SetEventOverlapMode(EOverlapModeRaw 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; }

  void SetDigis(std::vector<CbmBmonDigi>* BmonDigis) { fBmonDigis = BmonDigis; }
  void SetDigis(std::vector<CbmMvdDigi>* MvdDigis) { fMvdDigis = MvdDigis; }
  void SetDigis(std::vector<CbmStsDigi>* StsDigis) { fStsDigis = StsDigis; }
  void SetDigis(std::vector<CbmMuchDigi>* MuchDigis)
  {
    fMuchDigis            = MuchDigis;
    fbUseMuchBeamtimeDigi = kFALSE;
  }
  void SetDigis(std::vector<CbmTrdDigi>* TrdDigis) { fTrdDigis = TrdDigis; }
  void SetDigis(std::vector<CbmTofDigi>* TofDigis) { fTofDigis = TofDigis; }
  void SetDigis(std::vector<CbmRichDigi>* RichDigis) { fRichDigis = RichDigis; }
  void SetDigis(std::vector<CbmPsdDigi>* PsdDigis) { fPsdDigis = PsdDigis; }
  void SetDigis(std::vector<CbmFsdDigi>* FsdDigis) { fFsdDigis = FsdDigis; }
  void SetDigis(std::vector<CbmMuchBeamTimeDigi>* MuchBeamTimeDigis)
  {
    fMuchBeamTimeDigis    = MuchBeamTimeDigis;
    fbUseMuchBeamtimeDigi = kTRUE;
  }
 
  void SetSeedTimes(std::vector<Double_t>* SeedTimes) { fSeedTimes = SeedTimes; }
 
  // TS metadata
  void SetTimeSliceMetaDataArray(TClonesArray* TimeSliceMetaDataArray)
  {
    fTimeSliceMetaDataArray = TimeSliceMetaDataArray;
  }
 
  // Output folder for histograms
  TDirectoryFile* GetOutFolder() { return outFolder; }

  std::vector<CbmEvent*>& GetEventVector() { return fEventVector; }
  void ClearEventVector();
 
 private:
  Bool_t CheckDataAvailable(const RawEventBuilderDetector& det);
  void InitTs();
  void InitSeedWindow();
  void BuildEvents();
 
  void CreateHistograms();
  void FillHistos();
 
  template<class DigiSeed>
  void LoopOnSeeds();
 
  void CheckSeed(Double_t dSeedTime, UInt_t uSeedDigiIdx);
  void CheckTriggerCondition(Double_t dSeedTime);
 
  template<class DigiCheck>
  void SearchMatches(Double_t dSeedTime, RawEventBuilderDetector& detMatch);
  void SearchMatches(Double_t dSeedTime, RawEventBuilderDetector& detMatch);
  void AddDigiToEvent(const RawEventBuilderDetector& det, Int_t uIdx);
  Bool_t HasTrigger(CbmEvent*);
  Bool_t CheckTriggerConditions(CbmEvent* event, const RawEventBuilderDetector& det);
 
  void UpdateTimeWinBoundariesExtrema();
  void UpdateWidestTimeWinRange();
 
  void SwitchBmonStation(int id, bool on = true);
  bool SetBmonEventTime(CbmEvent* event);
 
  void CheckBmonInUse();

  bool filterBmon(int32_t add);
  int32_t getNofFilteredBmonDigis(CbmEvent* ev);
 
  TDirectoryFile* outFolder;  // oputput folder to store histograms

  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;   
  Bool_t fbGetTimings           = kFALSE;  
  Bool_t fbUseTsMetaData        = kTRUE;   
  std::vector<bool> fUseBmonMap = {};      

  EOverlapModeRaw fOverMode{EOverlapModeRaw::AllowOverlap};
 
  TStopwatch* fTimer = nullptr;  
 
  RawEventBuilderDetector fRefDet             = kRawEventBuilderDetBmon;
  std::vector<RawEventBuilderDetector> fvDets = {
    kRawEventBuilderDetSts, kRawEventBuilderDetMuch, kRawEventBuilderDetTrd, kRawEventBuilderDetTrd2D,
    kRawEventBuilderDetTof, kRawEventBuilderDetRich, kRawEventBuilderDetPsd, kRawEventBuilderDetFsd};
  bool fbBmonInUse = false;
 
  Double_t fdEarliestTimeWinBeg = kdDefaultTimeWinBeg;
  Double_t fdLatestTimeWinEnd   = kdDefaultTimeWinEnd;
  Double_t fdWidestTimeWinRange = kdDefaultTimeWinEnd - kdDefaultTimeWinBeg;
  Double_t fdSeedWindowBeg = 0;
  Double_t fdSeedWindowEnd = 0;
 
  Double_t fdTsStartTime  = -1;
  Double_t fdTsLength     = -1;
  Double_t fdTsOverLength = -1;

  TClonesArray* fTimeSliceMetaDataArray = nullptr;  
 
  const std::vector<CbmBmonDigi>* fBmonDigis                 = nullptr;
  const std::vector<CbmMuchDigi>* fMuchDigis                 = nullptr;
  const std::vector<CbmMuchBeamTimeDigi>* fMuchBeamTimeDigis = nullptr;
  const std::vector<CbmMvdDigi>* fMvdDigis                   = nullptr;
  const std::vector<CbmStsDigi>* fStsDigis                   = nullptr;
  const std::vector<CbmTrdDigi>* fTrdDigis                   = nullptr;
  const std::vector<CbmTofDigi>* fTofDigis                   = nullptr;
  const std::vector<CbmRichDigi>* fRichDigis                 = nullptr;
  const std::vector<CbmPsdDigi>* fPsdDigis                   = nullptr;
  const std::vector<CbmFsdDigi>* fFsdDigis                   = nullptr;
 
  // If explicit seed times are supplied.
  const std::vector<Double_t>* fSeedTimes = nullptr;
  Double_t fdSeedTimeWinBeg               = -100.0;
  Double_t fdSeedTimeWinEnd               = 100.0;
 
  bool CheckDataAvailable(ECbmModuleId detId);
  UInt_t GetNofDigis(ECbmModuleId detId);
  template<class Digi>
  const Digi* GetDigi(UInt_t uDigi);
  uint64_t GetSizeFromDigisNb(ECbmModuleId detId, uint64_t ulNbDigis);
 
  Double_t GetSeedTimeWinRange();

  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;  
  TH1* fhCpuTimePerTs     = nullptr;  
  TH1* fhRealTimePerTs    = nullptr;  
 
  TH1* fhCpuTimePerTsHist  = nullptr;  
  TH1* fhRealTimePerTsHist = nullptr;  
 
  std::vector<TH2*> fvhNbDigiPerEvtTimeDet =
    {};  
  std::vector<TH1*> fvhNbDigiPerEvtDet = {};  
  std::vector<TH1*> fvhTDiff           = {};  // digi time difference to seed
 
  std::vector<TH1*> fvhSelRatioPerTsNb = {};       
  std::vector<TH1*> fvhInpRatioPerTsSz = {};       
  std::vector<TH1*> fvhOutRatioPerTsSz = {};       
  TH1* fhSizeReductionPerTs            = nullptr;  
 
  TH1* fhOverEventShare        = nullptr;  
  TProfile* fhOverEventShareTs = nullptr;  
  TH2* fhOverEventSizeTs       = nullptr;  

  UInt_t fuCurEv            = 0;   
  UInt_t fuNrTs             = 0;   
  Double_t fdPrevEvtTime    = 0.;  
  Double_t fdPrevEvtEndTime = 0.;  
 
  ClassDefNV(CbmAlgoBuildRawEvents, 2);
};
 
#endif  // CBMALGOBUILDRAWEVENTS_H