CbmCheckTiming.h

Go to the documentation of this file.

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
#ifndef CBMCHECKTIMING_H
#define CBMCHECKTIMING_H
 
#include "FairTask.h"
 
#include "CbmModuleList.h"
#include "CbmTofDigi.h"
#include "TString.h"
#include <vector>
 
class TClonesArray;
class TH1;
class TH2;
class CbmDigiManager;
 
class CbmCheckTiming : public FairTask {
public:
  CbmCheckTiming();
 
  CbmCheckTiming(const CbmCheckTiming&) = delete;
  CbmCheckTiming operator=(const CbmCheckTiming&) = delete;
 
  //  CbmCheckTiming(Int_t verbose);
 
 
  ~CbmCheckTiming();
 
 
  virtual InitStatus Init();
 
  virtual InitStatus ReInit();
 
 
  virtual void Exec(Option_t*);
 
  virtual void SetParContainers();
 
  virtual void Finish();
 
  void SetCheckTimeOrder(Bool_t val = kFALSE) { fCheckTimeOrdering = val; }
 
  void SetCheckInterSystemOffset(Bool_t val = kTRUE) {
    fCheckInterSystemOffset = val;
  }
 
  void SetOffsetSearchRange(Int_t val = 1000) { fOffsetRange = val; }
 
  void SetStsOffsetSearchRange(Int_t val = 1000) { fStsOffsetRange = val; }
 
  void SetMuchOffsetSearchRange(Int_t val = 1000) { fMuchOffsetRange = val; }
 
  void SetTrdOffsetSearchRange(Int_t val = 1000) { fTrdOffsetRange = val; }
 
  void SetTofOffsetSearchRange(Int_t val = 1000) { fTofOffsetRange = val; }
 
  void SetRichOffsetSearchRange(Int_t val = 1000) { fRichOffsetRange = val; }
 
  void SetPsdOffsetSearchRange(Int_t val = 1000) { fPsdOffsetRange = val; }
 
  inline void SetT0PulserTotLimits(UInt_t uMin, UInt_t uMax) {
    fuMinTotPulserT0 = uMin;
    fuMaxTotPulserT0 = uMax;
  }
  inline void SetTofPulserTotLimits(UInt_t uMin, UInt_t uMax) {
    fuMinTotPulserTof = uMin;
    fuMaxTotPulserTof = uMax;
  }
 
  inline void SetOutFilename(TString sNameIn) { fOutFileName = sNameIn; }
 
private:
  void CheckTimeOrder();
  template<class Digi>
  Int_t CheckIfSorted(TH1*, Double_t&, TString);
  Int_t CheckIfSortedT0(TH1*, Double_t&, TString);
 
  void CheckInterSystemOffset();
 
  /*
    Int_t FillSystemOffsetHistos(TClonesArray* array,
                                 TH1* histo, TH2* histoCharge,
                                 TH2* histoEvo, TH2* histoEvoLong, TH2* histoAFCK,
                                 const Double_t T0Time, const Int_t offsetRange, Int_t iStartDigi,
                                 Bool_t bSts = kFALSE, Bool_t bMuch = kFALSE, Bool_t bTof = kFALSE );
    */
  template<class Digi>
  Int_t FillSystemOffsetHistos(TH1* histo,
                               TH2* histoCharge,
                               TH2* histoEvo,
                               TH2* histoEvoLong,
                               TH2* histoAFCK,
                               const Double_t T0Time,
                               const Int_t offsetRange,
                               Int_t iStartDigi,
                               Bool_t bSts  = kFALSE,
                               Bool_t bMuch = kFALSE,
                               Bool_t bTof  = kFALSE,
                               Bool_t bPsd  = kFALSE);
 
  template<class Digi>
  Int_t FillHistosSelT0(TH1* histo,
                        const Double_t T0Time,
                        const Int_t offsetRange,
                        Int_t iStartDigi,
                        Bool_t bSts  = kFALSE,
                        Bool_t bMuch = kFALSE,
                        Bool_t bTof  = kFALSE,
                        Bool_t bPsd  = kFALSE);
 
  Int_t CalcNrBins(Int_t);
  void CreateHistos();
  void WriteHistos();
 
 
  CbmDigiManager* fDigiMan = nullptr;  
 
  const std::vector<CbmTofDigi>* fT0DigiVec = nullptr;  
  TClonesArray* fT0DigiArr                  = nullptr;  
 
  Double_t fPrevTimeT0   = 0.;
  Double_t fPrevTimeSts  = 0.;
  Double_t fPrevTimeMuch = 0.;
  Double_t fPrevTimeTrd  = 0.;
  Double_t fPrevTimeTof  = 0.;
  Double_t fPrevTimeRich = 0.;
  Double_t fPrevTimePsd  = 0.;
 
  Int_t fPrevT0FirstDigiSts  = 0;
  Int_t fPrevT0FirstDigiMuch = 0;
  Int_t fPrevT0FirstDigiTrd  = 0;
  Int_t fPrevT0FirstDigiTof  = 0;
  Int_t fPrevT0FirstDigiRich = 0;
  Int_t fPrevT0FirstDigiPsd  = 0;
 
  UInt_t fuMinTotPulserT0  = 90;
  UInt_t fuMaxTotPulserT0  = 100;
  UInt_t fuMinTotPulserTof = 92;
  UInt_t fuMaxTotPulserTof = 96;
 
  //
  Int_t fNrTs = 0;
 
  Int_t fNrOfT0Errors   = 0;
  Int_t fNrOfT0Digis    = 0;
  Int_t fNrOfStsErrors  = 0;
  Int_t fNrOfStsDigis   = 0;
  Int_t fNrOfMuchErrors = 0;
  Int_t fNrOfMuchDigis  = 0;
  Int_t fNrOfTrdErrors  = 0;
  Int_t fNrOfTrdDigis   = 0;
  Int_t fNrOfTofErrors  = 0;
  Int_t fNrOfTofDigis   = 0;
  Int_t fNrOfRichErrors = 0;
  Int_t fNrOfRichDigis  = 0;
  Int_t fNrOfPsdErrors  = 0;
  Int_t fNrOfPsdDigis   = 0;
 
  Bool_t fCheckTimeOrdering      = kTRUE;
  Bool_t fCheckInterSystemOffset = kTRUE;
 
  Int_t fOffsetRange     = 1000;
  Int_t fStsOffsetRange  = 1000;
  Int_t fMuchOffsetRange = 1000;
  Int_t fTrdOffsetRange  = 1000;
  Int_t fTofOffsetRange  = 1000;
  Int_t fRichOffsetRange = 1000;
  Int_t fPsdOffsetRange  = 1000;
 
  Int_t fBinWidth = 1;
 
  TH1* fT0StsDiff  = nullptr;
  TH1* fT0MuchDiff = nullptr;
  TH1* fT0TrdDiff  = nullptr;
  TH1* fT0TofDiff  = nullptr;
  TH1* fT0RichDiff = nullptr;
  TH1* fT0PsdDiff  = nullptr;
 
  TH2* fT0StsDiffCharge  = nullptr;
  TH2* fT0MuchDiffCharge = nullptr;
  TH2* fT0TrdDiffCharge  = nullptr;
  TH2* fT0TofDiffCharge  = nullptr;
  TH2* fT0RichDiffCharge = nullptr;
  TH2* fT0PsdDiffCharge  = nullptr;
 
  TH2* fT0StsDiffEvo  = nullptr;
  TH2* fT0MuchDiffEvo = nullptr;
  TH2* fT0TrdDiffEvo  = nullptr;
  TH2* fT0TofDiffEvo  = nullptr;
  TH2* fT0RichDiffEvo = nullptr;
  TH2* fT0PsdDiffEvo  = nullptr;
 
  TH2* fT0StsDiffEvoLong  = nullptr;
  TH2* fT0MuchDiffEvoLong = nullptr;
  TH2* fT0TrdDiffEvoLong  = nullptr;
  TH2* fT0TofDiffEvoLong  = nullptr;
  TH2* fT0RichDiffEvoLong = nullptr;
  TH2* fT0PsdDiffEvoLong  = nullptr;
 
  TH1* fT0T0Diff     = nullptr;
  TH1* fStsStsDiff   = nullptr;
  TH1* fMuchMuchDiff = nullptr;
  TH1* fTrdTrdDiff   = nullptr;
  TH1* fTofTofDiff   = nullptr;
  TH1* fRichRichDiff = nullptr;
  TH1* fPsdPsdDiff   = nullptr;
 
  TH1* fT0Address = nullptr;
  TH1* fT0Channel = nullptr;
 
  TH2* fT0StsDpbDiff                 = nullptr;
  static const UInt_t kuMaxNbStsDpbs = 2;
  TH2* fT0StsDpbDiffEvo[kuMaxNbStsDpbs];
  TH1* fStsDpbCntsEvo[kuMaxNbStsDpbs];
 
  static const UInt_t kuMaxNbMuchDpbs  = 6;
  TH2* fT0MuchRocDiff                  = nullptr;
  static const UInt_t kuMaxNbMuchAsics = 36;
  TH2* fT0MuchAsicDiff                 = nullptr;
  TH2* fT0MuchAsicDiffEvo[kuMaxNbMuchAsics];
 
  UInt_t fuNbTofDigisSel   = 6;
  UInt_t fuNbTofDigiInSync = 0;
  std::vector<Double_t> fvdTimeSelectedT0;
  TH1* fSelT0StsDiff  = nullptr;
  TH1* fSelT0MuchDiff = nullptr;
  TH1* fSelT0TrdDiff  = nullptr;
  TH1* fSelT0TofDiff  = nullptr;
  TH1* fSelT0RichDiff = nullptr;
  TH1* fSelT0PsdDiff  = nullptr;
 
  TString fOutFileName {"test.root"};
 
  ClassDef(CbmCheckTiming, 2);
};
 
#endif