CbmTrdCalibTracker.h

Go to the documentation of this file.

/* Copyright (C) 2022 Horia Hulubei National Institute of Physics and Nuclear Engineering, Bucharest
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Alexandru Bercuci[committer]*/
 
 
#ifndef CBMTRDCALIBTRACKER_H
#define CBMTRDCALIBTRACKER_H
 
#include "CbmQaCanvas.h"
#include "CbmQaHist.h"
 
#include <FairTask.h>
 
#include <TFolder.h>
#include <TH1D.h>
#include <TH1F.h>
#include <TH1I.h>
#include <TH2F.h>
#include <TParameter.h>
#include <TProfile.h>
#include <TProfile2D.h>
 
class CbmDigiManager;
class CbmMCDataManager;
class CbmMCEventList;
class CbmMCDataArray;
class CbmTimeSlice;
class CbmTrdParSetGeo;
class CbmTrdParSetDigi;
 
class TClonesArray;
 
class CbmTrdCalibTracker : public FairTask {
 
 public:
  CbmTrdCalibTracker(const char* name = "TrdQaTracker", Int_t verbose = 1);
 
  ~CbmTrdCalibTracker();
 
  InitStatus Init() { return ReInit(); }
 
  InitStatus ReInit();
 
  void SetParContainers();
 
  void Finish();
 
  void Clear(Option_t* /*option*/ = "") {}
 
  void Exec(Option_t*);
 
  TFolder& GetQa();
 
 private:
  InitStatus GeometryQa();
 
  void ResolutionQa();
 
  void DeInit();
 
 
  // Setup
 
  Bool_t fIsTrdInSetup{false};
  Bool_t fIsMcPresent{false};
 
  Int_t fNtrackingStations{0};
 
  CbmTimeSlice* fTimeSlice{nullptr};
  CbmTrdParSetGeo* fTrdGeoPar{nullptr};
  CbmTrdParSetDigi* fTrdDigiPar{nullptr};
  CbmDigiManager* fDigiManager{nullptr};
 
  CbmMCEventList* fMcEventList{nullptr};  // list of MC events connected to the current time slice
  CbmMCDataManager* fMcManager{nullptr};
  CbmMCDataArray* fMcTracks{nullptr};
  CbmMCDataArray* fMcPoints{nullptr};
 
  TClonesArray* fClusters{nullptr};
  TClonesArray* fHits{nullptr};
  TClonesArray* fHitMatches{nullptr};
 
  TClonesArray* fHitsMc{nullptr};
 
 
  TFolder fOutFolder{"TrdQaTracker", "TrdQaTracker"};  
  TFolder* fHistFolder{nullptr};                       
 
  TParameter<int> fNevents{"nEvents", 0};  
 
  CbmQaHist<TH1D> fh1DresidualU{"h1DresidualU", "Trd1D: Residual U;(U_{reco} - U_{MC})(cm)", 100, -.5, .5};
  CbmQaHist<TH1D> fh1DresidualV{"h1DresidualV", "Trd1D: Residual V;(V_{reco} - V_{MC})(cm)", 100, -10, 10};
  CbmQaHist<TH1D> fh1DresidualT{"h1DresidualT", "Trd1D: Residual T;(T_{reco} - T_{MC})(ns)", 100, -50, 50};
 
  CbmQaHist<TH1D> fh2DresidualX{"h2DresidualX", "Trd2D: Residual X;(X_{reco} - X_{MC})(cm)", 100, -0.05, 0.05};
  CbmQaHist<TH1D> fh2DresidualY{"h2DresidualY", "Trd2D: Residual Y;(Y_{reco} - Y_{MC})(cm)", 1000, -2, 2};
  CbmQaHist<TH1D> fh2DresidualT{"h2DresidualT", "Trd2D: Residual T;(T_{reco} - T_{MC})(ns)", 100, -100, 100};
 
  CbmQaHist<TH1D> fh1DpullU{"h1DpullU", "Trd1D: Pull U;(U_{reco} - U_{MC}) / #sigmaU_{reco}", 100, -5, 5};
  CbmQaHist<TH1D> fh1DpullV{"h1DpullV", "Trd1D: Pull V;(V_{reco} - V_{MC}) / #sigmaV_{reco}", 100, -5, 5};
  CbmQaHist<TH1D> fh1DpullT{"h1DpullT", "Trd1D: Pull T;(T_{reco} - T_{MC}) / #sigmaT_{reco}", 100, -5, 5};
 
  CbmQaHist<TH1D> fh2DpullX{"h2DpullX", "Trd2D: Pull X;(X_{reco} - X_{MC}) / #sigmaX_{reco}", 100, -5, 5};
  CbmQaHist<TH1D> fh2DpullY{"h2DpullY", "Trd2D: Pull Y;(Y_{reco} - Y_{MC}) / #sigmaY_{reco}", 100, -5, 5};
  CbmQaHist<TH1D> fh2DpullT{"h2DpullT", "Trd2D: Pull T;(T_{reco} - T_{MC}) / #sigmaT_{reco}", 100, -5, 5};
 
  std::vector<CbmQaHist<TH1D>*> fHistList;
 
  std::vector<CbmQaHist<TH1I>> fhPointsPerHit;
 
  std::vector<CbmQaHist<TH1I>> fhHitsPerPoint;
 
  std::vector<CbmQaHist<TProfile2D>> fhEfficiencyXY;
  std::vector<CbmQaHist<TProfile>> fhEfficiencyR;
 
 
  CbmQaCanvas fCanvResidual{"cResidual", "Residual Distribution", 3 * 500, 2 * 500};
  CbmQaCanvas fCanvPull{"cPull", "Pull Distribution", 3 * 500, 2 * 500};
  CbmQaCanvas fCanvEfficiencyXY{"cEfficiencyXY", "Efficiency XY: % reconstructed McPoint", 2 * 500, 2 * 500};
  CbmQaCanvas fCanvEfficiencyR{"cEfficiencyR", "Efficiency R: % reconstructed McPoint", 2 * 500, 2 * 500};
  CbmQaCanvas fCanvHitsPerPoint{"cHitsPerMcPoint", "Efficiency: Hits Per McPoint", 2 * 500, 2 * 500};
  CbmQaCanvas fCanvPointsPerHit{"cMcPointsPerHit", "Purity: McPoints per Hit", 2 * 500, 2 * 500};
 
 private:
  CbmTrdCalibTracker(const CbmTrdCalibTracker&) = delete;
 
  CbmTrdCalibTracker& operator=(const CbmTrdCalibTracker&) = delete;
 
  ClassDef(CbmTrdCalibTracker, 0);
};
 
#endif