CbmMcbmCheckTimingAlgo.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], Andreas Redelbach, Alexandru Bercuci */
 
#ifndef CBMMCBMCHECKTIMINGALGO_H
#define CBMMCBMCHECKTIMINGALGO_H
 
#include "CbmModuleList.h"
#include "CbmTofDigi.h"
#include "CbmTrdDigi.h"
#include "CbmTsEventHeader.h"
 
#include "TString.h"
 
#include <unordered_set>
#include <vector>
 
class TH1;
class TH2;
class CbmDigiManager;
class CbmStsDigi;
class CbmMuchDigi;
class CbmTrdDigi;
class CbmTofDigi;
class CbmRichDigi;
class CbmPsdDigi;
class CbmBmonDigi;
class CheckTimingDetector {
public:
  CheckTimingDetector() { ; }
  CheckTimingDetector(ECbmModuleId detIdIn, std::string sNameIn)
  {
    detId = detIdIn;
    sName = sNameIn;
  }
 
  ECbmModuleId detId     = ECbmModuleId::kNotExist;
  std::string sName      = "Invalid";
  Double_t dTimeRangeBeg = -1000.0;
  Double_t dTimeRangeEnd = 1000.0;
  UInt_t uRangeNbBins    = 320;
  UInt_t uChargeCutMin =
    0;  
  UInt_t uChargeCutMax =
    0;  
  UInt_t uNviews                 = 1;     
  std::vector<std::string> vName = {""};  
  Double_t dPrevTime      = 0.;
  Int_t iPrevRefFirstDigi = 0;
};
 
class CbmMcbmCheckTimingAlgo {
public:
  CbmMcbmCheckTimingAlgo();
 
  CbmMcbmCheckTimingAlgo(const CbmMcbmCheckTimingAlgo&) = delete;
  CbmMcbmCheckTimingAlgo operator=(const CbmMcbmCheckTimingAlgo&) = delete;
 
  //  CbmMcbmCheckTimingAlgo(Int_t verbose);
 
 
  ~CbmMcbmCheckTimingAlgo();
 
 
  Bool_t Init();
 
  Bool_t ReInit();
 
 
  void ProcessTs();
 
  void SetParContainers();
 
  void Finish();
 
  inline void SetOutFilename(TString sNameIn) { fOutFileName = sNameIn; }
  void WriteHistos();
 
  void SetReferenceDetector(ECbmModuleId refDetIn, std::string sNameIn, Double_t dTimeRangeBegIn = -1000.0,
                            Double_t dTimeRangeEndIn = 1000.0, UInt_t uRangeNbBinsIn = 320, UInt_t uChargeCutMinIn = 0,
                            UInt_t uChargeCutMaxIn = 0);
  void AddCheckDetector(ECbmModuleId detIn, std::string sNameIn, Double_t dTimeRangeBegIn = -1000.0,
                        Double_t dTimeRangeEndIn = 1000.0, UInt_t uRangeNbBinsIn = 320, UInt_t uChargeCutMinIn = 0,
                        UInt_t uChargeCutMaxIn = 0);
  void RemoveCheckDetector(ECbmModuleId detIn);
  void SetDetectorDifferential(ECbmModuleId detIn, std::vector<std::string> vName);
 
  void SetTrdPeakWidthNs(Double_t val = 120.) { fTrdPeakWidthNs = val; }
  void SetStsPeakWidthNs(Double_t val = 30.) { fStsPeakWidthNs = val; }
  void SetMuchPeakWidthNs(Double_t val = 100.) { fMuchPeakWidthNs = val; }
  void SetTofPeakWidthNs(Double_t val = 20.) { fTofPeakWidthNs = val; }
  void SetRichPeakWidthNs(Double_t val = 40.) { fRichPeakWidthNs = val; }
  void SetPsdPeakWidthNs(Double_t val = 20.) { fPsdPeakWidthNs = val; }
 
private:
  void CheckDataPresence(CheckTimingDetector detToCheck);
  void CreateHistos();
 
  template<class DigiRef>
  void CheckInterSystemOffset();
  template<class Digi>
  void FillTimeOffsetHistos(const Double_t dRefTime, const Double_t dRefCharge, UInt_t uDetIdx);
  template<class Digi>
  UInt_t GetDigiInfo(UInt_t iDigi, std::vector<std::tuple<double, double, UInt_t>>* vec,
                     ECbmModuleId detId = ECbmModuleId::kNotExist);
  template<class Digi>
  int GetViewId(CheckTimingDetector det, std::tuple<double, double, UInt_t> info);
 
  CbmDigiManager* fDigiMan = nullptr;  
 
  const std::vector<CbmBmonDigi>* fpBmonDigiVec = nullptr;  
 
  const CbmTsEventHeader* fCbmTsEventHeader = nullptr;
 
  //
  UInt_t fuNbTs = 0;
 
  CheckTimingDetector fRefDet {CheckTimingDetector(ECbmModuleId::kBmon, "BMON")};
  std::vector<CheckTimingDetector> fvDets {
    CheckTimingDetector(ECbmModuleId::kSts, "Sts"),   CheckTimingDetector(ECbmModuleId::kMuch, "Much"),
    CheckTimingDetector(ECbmModuleId::kTrd, "Trd"),   CheckTimingDetector(ECbmModuleId::kTof, "Tof"),
    CheckTimingDetector(ECbmModuleId::kRich, "Rich"), CheckTimingDetector(ECbmModuleId::kPsd, "Psd")};
 
  std::map<ECbmModuleId, std::vector<TH1*>> fvhDetSelfDiff           = {};
  std::map<ECbmModuleId, std::vector<TH1*>> fvhDetToRefDiff          = {};
  std::map<ECbmModuleId, std::vector<TH2*>> fvhDetToRefDiffRefCharge = {};
  std::map<ECbmModuleId, std::vector<TH2*>> fvhDetToRefDiffDetCharge = {};
  std::map<ECbmModuleId, std::vector<TH2*>> fvhDetToRefDiffEvo       = {};
  std::map<ECbmModuleId, std::vector<TH2*>> fvhDetToRefDiffEvoLong   = {};
 
  TString fOutFileName = "data/HistosCheckTiming.root";
  Double_t DetPeakPosSingle;
  Double_t DetAverageSingle;
  Double_t fTrdPeakWidthNs   = 120.;
  Double_t fStsPeakWidthNs   = 30.;
  Double_t fMuchPeakWidthNs  = 100.;
  Double_t fTofPeakWidthNs   = 20.;
  Double_t fRichPeakWidthNs  = 40.;
  Double_t fPsdPeakWidthNs   = 20.;
 
  std::map<ECbmModuleId, std::unordered_set<std::string>> fUnimplementedView = {};
 
  ClassDefNV(CbmMcbmCheckTimingAlgo, 1);
};
 
#endif