CbmTofSimpClusterizer.h

Go to the documentation of this file.

/* Copyright (C) 2013-2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer], Norbert Herrmann */
 
#ifndef CBMTOFSIMPCLUSTERIZER_H
#define CBMTOFSIMPCLUSTERIZER_H 1
 
// TOF Classes and includes
// Input/Output
//class CbmTofPoint;
class CbmTofDigi;
class CbmMatch;
// Geometry
class CbmTofGeoHandler;
class CbmTofDetectorId;
class CbmTofDigiPar;
class CbmTofDigiBdfPar;
class CbmTofCell;
class CbmDigiManager;
class CbmEvent;
 
// FAIR classes and includes
#include "FairTask.h"
 
// ROOT Classes and includes
class TClonesArray;
class TFile;
class TH1;
class TH2;
class TString;
#include "TStopwatch.h"
#include "TTimeStamp.h"
 
// C++ Classes and includes
#include <vector>
 
class CbmTofSimpClusterizer : public FairTask {
 public:
  CbmTofSimpClusterizer();
 
  CbmTofSimpClusterizer(const char* name, Int_t verbose = 1);
  virtual ~CbmTofSimpClusterizer();
 
  virtual InitStatus Init();
 
  virtual void SetParContainers();
 
  virtual void Exec(Option_t* option);
 
  virtual void Finish();
 
  inline void SetCalMode(Int_t iMode) { fCalMode = iMode; }
  inline void SetCalTrg(Int_t iTrg) { fCalTrg = iTrg; }
  inline void SetCalSmType(Int_t iCalSmType) { fCalSmType = iCalSmType; }
  inline void SetCaldXdYMax(Double_t dCaldXdYMax) { fdCaldXdYMax = dCaldXdYMax; }
  inline void SetTRefId(Int_t Id) { fTRefMode = Id; }
  inline void SetTRefDifMax(Double_t TRefMax) { fTRefDifMax = TRefMax; }
  inline void SetdTRefMax(Double_t dTRefMax) { fdTRefMax = dTRefMax; }
  inline void PosYMaxScal(Double_t PosYmaxScal) { fPosYMaxScal = PosYmaxScal; }
  inline void SetTotMax(Double_t TOTMax) { fTotMax = TOTMax; }
  inline void SetTotMin(Double_t TOTMin) { fTotMin = TOTMin; }
  inline void SetOutTimeFactor(Double_t val) { fOutTimeFactor = val; }
 
  inline void SetCalParFileName(TString CalParFileName) { fCalParFileName = CalParFileName; }
  Bool_t SetHistoFileName(TString sFilenameIn = "./tofSimpClust.hst.root");
 
  void UseMcTrackMonitoring(Bool_t bMcTrkMonitor = kTRUE) { fbMcTrkMonitor = bMcTrkMonitor; }
 
 protected:
 private:
  CbmTofSimpClusterizer(const CbmTofSimpClusterizer&);
  CbmTofSimpClusterizer& operator=(const CbmTofSimpClusterizer&);
 
  // Functions common for all clusters approximations
  Bool_t RegisterInputs();
  Bool_t RegisterOutputs();
  Bool_t InitParameters();
  Bool_t InitCalibParameter();
  Bool_t LoadGeometry();
  Bool_t DeleteGeometry();
 
  // Histogramming functions
  Bool_t CreateHistos();
  Bool_t FillHistos();
  Bool_t WriteHistos();
  Bool_t DeleteHistos();
 
  std::pair<Int_t, Int_t> BuildClusters(CbmEvent* event);
 
  void GetEventInfo(Int_t& inputNr, Int_t& eventNr, Double_t& eventTime);
 
  // ToF geometry variables
  CbmTofGeoHandler* fGeoHandler;
  CbmTofDetectorId* fTofId;
  CbmTofDigiPar* fDigiPar;
  CbmTofCell* fChannelInfo;
  CbmTofDigiBdfPar* fDigiBdfPar;
  Double_t fdParFeeTimeRes;
  Double_t fdParSystTimeRes;
 
  // Input variables
  TClonesArray* fTofPointsColl;  // TOF MC points
  TClonesArray* fMcTracksColl;   // MC tracks
  CbmDigiManager* fDigiMan;
  TClonesArray* fEvents = nullptr;
 
  // Output variables
  TClonesArray* fTofHitsColl;       // TOF hits
  TClonesArray* fTofDigiMatchColl;  // TOF Digis
  Int_t fiNbHits;                   // Index of the CbmTofHit TClonesArray
 
  // Generic
  Int_t fVerbose;
 
  // Intermediate storage variables
  std::vector<std::vector<std::vector<std::vector<CbmTofDigi*>>>> fStorDigiExp;  //[nbType][nbSm*nbRpc][nbCh][nDigis]
  std::vector<std::vector<std::vector<std::vector<Int_t>>>> fStorDigiInd;        //[nbType][nbSm*nbRpc][nbCh][nDigis]
  /*
      std::vector< std::vector< std::vector< std::vector< std::vector< CbmTofDigi* > > > > >
               fStorDigi; //[nbType][nbSm][nbRpc][nbCh][nDigis]
      std::vector< std::vector< std::vector< std::vector< std::vector< CbmTofDigiExp* > > > > >
               fStorDigiExp; //[nbType][nbSm][nbRpc][nbCh][nDigis]
      */
  std::vector<std::vector<std::vector<Int_t>>> fviClusterMul;   //[nbType][nbSm][nbRpc]
  std::vector<std::vector<std::vector<Int_t>>> fviClusterSize;  //[nbType][nbRpc][nClusters]
  std::vector<std::vector<std::vector<Int_t>>> fviTrkMul;       //[nbType][nbRpc][nClusters]
  std::vector<std::vector<std::vector<Double_t>>> fvdX;         //[nbType][nbRpc][nClusters]
  std::vector<std::vector<std::vector<Double_t>>> fvdY;         //[nbType][nbRpc][nClusters]
  std::vector<std::vector<std::vector<Double_t>>> fvdDifX;      //[nbType][nbRpc][nClusters]
  std::vector<std::vector<std::vector<Double_t>>> fvdDifY;      //[nbType][nbRpc][nClusters]
  std::vector<std::vector<std::vector<Double_t>>> fvdDifCh;     //[nbType][nbRpc][nClusters]
 
  // Output file name and path
  TString fsHistoOutFilename;
  // Histograms
  TH1* fhClustBuildTime;
  TH1* fhHitsPerTracks;
  TH1* fhPtsPerHit;
  TH1* fhTimeResSingHits;
  TH2* fhTimeResSingHitsB;
  TH2* fhTimePtVsHits;
  TH1* fhClusterSize;
  TH2* fhClusterSizeType;
  TH1* fhTrackMul;
  TH2* fhClusterSizeMulti;
  TH2* fhTrk1MulPos;
  TH2* fhHiTrkMulPos;
  TH2* fhAllTrkMulPos;
  TH2* fhMultiTrkProbPos;
  TH1* fhDigSpacDifClust;
  TH1* fhDigTimeDifClust;
  TH2* fhDigDistClust;
  TH2* fhClustSizeDifX;
  TH2* fhClustSizeDifY;
  TH2* fhChDifDifX;
  TH2* fhChDifDifY;
 
  std::vector<TH2*> fhRpcDigiCor;                            //[nbDet]
  std::vector<TH1*> fhRpcCluMul;                             //[nbDet]
  std::vector<TH1*> fhRpcSigPropSpeed;                       //[nbDet]
  std::vector<TH2*> fhRpcCluPosition;                        //[nbDet]
  std::vector<TH2*> fhRpcCluTOff;                            //[nbDet]
  std::vector<TH2*> fhRpcCluTrms;                            //[nbDet]
  std::vector<TH2*> fhRpcCluTot;                             // [nbDet]
  std::vector<TH2*> fhRpcCluSize;                            // [nbDet]
  std::vector<TH2*> fhRpcCluAvWalk;                          // [nbDet]
  std::vector<std::vector<std::vector<TH2*>>> fhRpcCluWalk;  // [nbDet][nbCh][nSide]
 
  std::vector<std::vector<TH1*>> fhTRpcCluMul;                             // [nbDet][nbTrg]
  std::vector<std::vector<TH2*>> fhTRpcCluPosition;                        // [nbDet][nbTrg]
  std::vector<std::vector<TH2*>> fhTRpcCluTOff;                            // [nbDet][nbTrg]
  std::vector<std::vector<TH2*>> fhTRpcCluTot;                             // [nbDet][nbTrg]
  std::vector<std::vector<TH2*>> fhTRpcCluSize;                            // [nbDet][nbTrg]
  std::vector<std::vector<TH2*>> fhTRpcCluAvWalk;                          // [nbDet][nbTrg]
  std::vector<std::vector<TH2*>> fhTRpcCluDelTof;                          // [nbDet][nbTrg]
  std::vector<std::vector<TH2*>> fhTRpcCludXdY;                            // [nbDet][nbTrg]
  std::vector<std::vector<std::vector<std::vector<TH2*>>>> fhTRpcCluWalk;  // [nbDet][nbTrg][nbCh][nSide]
 
  std::vector<TH1*> fhTrgdT;  //[nbTrg]
 
  std::vector<std::vector<Double_t>> fvCPSigPropSpeed;                       //[nSMT][nRpc]
  std::vector<std::vector<std::vector<std::vector<Double_t>>>> fvCPDelTof;   //[nSMT][nRpc][nbClDelTofBinX][nbTrg]
  std::vector<std::vector<std::vector<std::vector<Double_t>>>> fvCPTOff;     //[nSMT][nRpc][nCh][nbSide]
  std::vector<std::vector<std::vector<std::vector<Double_t>>>> fvCPTotGain;  //[nSMT][nRpc][nCh][nbSide]
  std::vector<std::vector<std::vector<std::vector<std::vector<Double_t>>>>>
    fvCPWalk;  //[nSMT][nRpc][nCh][nbSide][nbWalkBins]
 
  // Digis quality
  Int_t fiNbSameSide;
  TH1* fhNbSameSide;
  TH1* fhNbDigiPerChan;
 
  // Control
  TTimeStamp fStart;
  TTimeStamp fStop;
 
  // --- Run counters
  TStopwatch fTimer;           
  Int_t fiNofTs = 0;           
  Int_t fiNofEvents;           
  Double_t fNofDigisAll  = 0;  
  Double_t fNofDigisUsed = 0;  
  Double_t fdNofHitsTot;       
  Double_t fdTimeTot;          
 
  // Calib
  Double_t dTRef;
  Double_t fdTRefMax;
  Int_t fCalMode;
  Int_t fCalTrg;
  Int_t fCalSmType;
  Double_t fdCaldXdYMax;
  Int_t fTRefMode;
  Int_t fTRefHits;
  Double_t fPosYMaxScal;
  Double_t fTRefDifMax;
  Double_t fTotMax;
  Double_t fTotMin;
  Double_t fOutTimeFactor;
 
  TString fCalParFileName;  // name of the file name with Calibration Parameters
  TFile* fCalParFile;       // pointer to Calibration Parameter file
 
  Bool_t fbMcTrkMonitor;
 
  ClassDef(CbmTofSimpClusterizer, 2);
};
 
#endif  // CBMTOFSIMPCLUSTERIZER_H