CbmMcbm2019CheckTimingPairs.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 CBMMCBM2019CHECKTIMINGPAIRS_H
#define CBMMCBM2019CHECKTIMINGPAIRS_H
 
#include "CbmDefs.h"
#include "CbmMuchBeamTimeDigi.h"
#include "CbmPsdDigi.h"
#include "CbmRichDigi.h"
#include "CbmStsDigi.h"
#include "CbmTofDigi.h"
#include "CbmTrdDigi.h"
 
#include "TimesliceMetaData.h"
 
#include "FairTask.h"
 
#include "TString.h"
 
#include <vector>
 
class TClonesArray;
class TH1;
class TH2;
class TProfile;
class CbmDigiManager;
 
class CbmMcbm2019CheckTimingPairs : public FairTask {
public:
  CbmMcbm2019CheckTimingPairs();
 
  CbmMcbm2019CheckTimingPairs(const CbmMcbm2019CheckTimingPairs&) = delete;
  CbmMcbm2019CheckTimingPairs operator=(const CbmMcbm2019CheckTimingPairs&) = delete;
 
  //  CbmMcbm2019CheckTimingPairs(Int_t verbose);
 
 
  ~CbmMcbm2019CheckTimingPairs();
 
 
  virtual InitStatus Init();
 
  virtual InitStatus ReInit();
 
 
  virtual void Exec(Option_t*);
 
  virtual void SetParContainers();
 
  virtual void Finish();
 
  void SetStsOffsetSearchRange(Double_t val = 1000) { fdStsTimeWin = val; }
 
  void SetMuchOffsetSearchRange(Double_t val = 1000) { fdMuchTimeWin = val; }
 
  void SetTrdOffsetSearchRange(Double_t val = 1000) { fdTrdTimeWin = val; }
 
  void SetTofOffsetSearchRange(Double_t val = 1000) { fdTofTimeWin = val; }
 
  void SetRichOffsetSearchRange(Double_t val = 1000) { fdRichTimeWin = val; }
 
  void SetPsdOffsetSearchRange(Double_t val = 1000) { fdPsdTimeWin = val; }
 
  inline void SetBmonPulserTotLimits(UInt_t uMin, UInt_t uMax)
  {
    fuMinTotPulserBmon = uMin;
    fuMaxTotPulserBmon = uMax;
  }
  inline void SetStsPulserAdcLimits(UInt_t uMin, UInt_t uMax)
  {
    fuMinAdcPulserSts = uMin;
    fuMaxAdcPulserSts = uMax;
  }
  inline void SetMuchPulserAdcLimits(UInt_t uMin, UInt_t uMax)
  {
    fuMinAdcPulserMuch = uMin;
    fuMaxAdcPulserMuch = uMax;
  }
  inline void SetTrdPulserChargeLimits(UInt_t uMin, UInt_t uMax)
  {
    fuMinChargePulserTrd = uMin;
    fuMaxChargePulserTrd = uMax;
  }
  inline void SetTofPulserTotLimits(UInt_t uMin, UInt_t uMax)
  {
    fuMinTotPulserTof = uMin;
    fuMaxTotPulserTof = uMax;
  }
  inline void SetRichPulserTotLimits(UInt_t uMin, UInt_t uMax)
  {
    fuMinTotPulserRich = uMin;
    fuMaxTotPulserRich = uMax;
  }
  inline void SetPsdPulserAdcLimits(UInt_t uMin, UInt_t uMax)
  {
    fuMinAdcPulserPsd = uMin;
    fuMaxAdcPulserPsd = uMax;
  }
 
  inline void SetOutFilename(TString sNameIn) { fOutFileName = sNameIn; }
 
  inline void SetStsAddress(UInt_t uAddress) { fuStsAddress = uAddress; }
  inline void SetMuchAsic(UInt_t uAsic) { fuMuchAsic = uAsic; }
  inline void SetMuchChanRange(UInt_t uFirstChan, UInt_t uLastChan = kuNbChanSMX)
  {
    fuMuchFirstCha = uFirstChan;
    fuMuchLastChan = uLastChan;
  }
  inline void SetTrdAddress(UInt_t uAddress) { fuTrdAddress = uAddress; }
  inline void SetPsdAddress(UInt_t uAddress) { fuPsdAddress = uAddress; }
 
private:
  void CreateHistos();
  void WriteHistos();
 
  template<class Digi>
  UInt_t FillCorrBuffer(Double_t dTimeBmon, UInt_t uIndexStart, Double_t dWinStartTime, Double_t dWinStopTime,
                        std::vector<std::vector<Digi>>& vDigi, ECbmModuleId iDetId = ECbmModuleId::kLastModule);
  template<class DigiA>
  void FillHistosInter(UInt_t uIndexBmon, UInt_t uIndexA, UInt_t uIndexB, std::vector<DigiA>& vCorrDigA,
                       UInt_t uHistoIdx);
  template<class DigiA, class DigiB>
  void FillHistos(UInt_t uIndexBmon, UInt_t uIndexA, UInt_t uIndexB, std::vector<DigiA>& vCorrDigA,
                  std::vector<DigiB>& vCorrDigB, UInt_t uHistoIdx);
 
  CbmDigiManager* fDigiMan                     = nullptr;  
  const std::vector<CbmTofDigi>* fBmonDigiVector = nullptr;  
  TClonesArray* fBmonDigiArray                   = nullptr;  
  TClonesArray* fTimeSliceMetaDataArray        = nullptr;  
  const TimesliceMetaData* pTsMetaData         = nullptr;
 
  static const UInt_t kuNbChanSMX            = 128;
  static const UInt_t kuMaxNbStsDpbs         = 2;
  static const UInt_t kuMaxNbMuchDpbs        = 6;
  static const UInt_t kuMaxNbMuchAsics       = 36;
  static const UInt_t kuDefaultAddress       = 0xFFFFFFFF;
  static const UInt_t kuMaxChannelSts        = 3000;
  static const UInt_t kuNbBinsDefault        = 2000;
  static constexpr Double_t kdClockCycle     = 3.125;
  static constexpr Double_t kdDefaultTimeWin = kdClockCycle * kuNbBinsDefault / 2;
 
  std::vector<std::string> fvsDetectors = {"STS", "MUCH", "TRD", "TOF", "RICH", "PSD"};  
  UInt_t fuNbDetectors                  = fvsDetectors.size();
 
  Double_t fPrevTimeBmon              = 0.;
  std::vector<Double_t> fvPrevTimeDet = std::vector<Double_t>(fuNbDetectors, 0.0);  
 
  std::vector<UInt_t> fvuPrevBmonFirstDigiDet = std::vector<UInt_t>(fuNbDetectors, 0);  
 
  std::vector<CbmTofDigi> fvDigisBmon                       = {};  
  std::vector<std::vector<CbmStsDigi>> fvDigisSts           = {};  
  std::vector<std::vector<CbmMuchBeamTimeDigi>> fvDigisMuch = {};  
  std::vector<std::vector<CbmTrdDigi>> fvDigisTrd           = {};  
  std::vector<std::vector<CbmTofDigi>> fvDigisTof           = {};  
  std::vector<std::vector<CbmRichDigi>> fvDigisRich         = {};  
  std::vector<std::vector<CbmPsdDigi>> fvDigisPsd           = {};  
 
  UInt_t fuNbDigisWithCoincBmon = 0;
  UInt_t fuNbCoincDigisSts  = 0;
  UInt_t fuNbCoincDigisMuch = 0;
  UInt_t fuNbCoincDigisTrd  = 0;
  UInt_t fuNbCoincDigisTof  = 0;
  UInt_t fuNbCoincDigisRich = 0;
  UInt_t fuNbCoincDigisPsd  = 0;
 
  UInt_t fuMinTotPulserBmon   = 182;
  UInt_t fuMaxTotPulserBmon   = 190;
  UInt_t fuMinAdcPulserSts    = 90;
  UInt_t fuMaxAdcPulserSts    = 100;
  UInt_t fuMinAdcPulserMuch   = 5;
  UInt_t fuMaxAdcPulserMuch   = 15;
  UInt_t fuMinChargePulserTrd = 700000;  
  UInt_t fuMaxChargePulserTrd = 0;       
  UInt_t fuMinTotPulserTof    = 182;
  UInt_t fuMaxTotPulserTof    = 190;
  UInt_t fuMinTotPulserRich   = 700000;  
  UInt_t fuMaxTotPulserRich   = 0;       
  UInt_t fuMinAdcPulserPsd    = 700000;  
  UInt_t fuMaxAdcPulserPsd    = 0;       
  UInt_t fuStsAddress   = kuDefaultAddress;
  UInt_t fuStsFirstCha  = kuMaxChannelSts;
  UInt_t fuStsLastChan  = kuMaxChannelSts;
  UInt_t fuMuchAsic     = kuMaxNbMuchAsics;
  UInt_t fuMuchFirstCha = kuNbChanSMX;
  UInt_t fuMuchLastChan = kuNbChanSMX;
  UInt_t fuTrdAddress   = kuDefaultAddress;
  UInt_t fuPsdAddress   = kuDefaultAddress;
 
  //
  Int_t fNrTs = 0;
 
  Double_t fdStsTimeWin  = kdDefaultTimeWin;
  Double_t fdMuchTimeWin = kdDefaultTimeWin;
  Double_t fdTrdTimeWin  = kdDefaultTimeWin;
  Double_t fdTofTimeWin  = kdDefaultTimeWin;
  Double_t fdRichTimeWin = kdDefaultTimeWin;
  Double_t fdPsdTimeWin  = kdDefaultTimeWin;
 
  Int_t fBinWidth = 1;
 
  std::vector<TH1*> fhDtADtB = {};  
 
  TString fOutFileName {"data/HistosTimingPairs.root"};
 
  ClassDef(CbmMcbm2019CheckTimingPairs, 1);
};
 
#endif  // CBMMCBM2019CHECKTIMINGPAIRS_H