CbmTrackingTrdQa.h

Go to the documentation of this file.

/* Copyright (C) 2006-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergey Gorbunov [committer] */
 
// -------------------------------------------------------------------------
// -----                  CbmTrackingTrdQa header file                 -----
// -----                  Created 15/08/22                             -----
// -------------------------------------------------------------------------
 
 
#ifndef CbmTrackingTrdQa_H
#define CbmTrackingTrdQa_H 1
 
#include "CbmLink.h"
#include "CbmQaHist.h"
#include "Riostream.h"
#include "TH2F.h"
#include "TProfile2D.h"
 
#include <FairTask.h>
 
#include <TFolder.h>
#include <TStopwatch.h>
#include <TVector3.h>
 
class TH1F;
class CbmMCDataArray;
class CbmMCDataManager;
class CbmTimeSlice;
class FairRootManager;
 
class CbmTrackingTrdQa : public FairTask {
 
 public:
  CbmTrackingTrdQa(Int_t iVerbose = 1);
 
  CbmTrackingTrdQa(Int_t minHits, Double_t quota, Int_t iVerbose);
 
  virtual ~CbmTrackingTrdQa();
 
  void SetYcm(double ycm) { fYCM = ycm; }
 
  virtual void SetParContainers();
 
  virtual InitStatus Init();
 
  virtual InitStatus ReInit();
 
  virtual void Exec(Option_t* opt);
 
 private:
  virtual void Finish();
 
  InitStatus GetGeometry();
 
  void GetTargetPosition();
 
  static const int fgkNpdg = 6;
  static const char* fgkIdxName[fgkNpdg];
  static const char* fgkIdxSymb[fgkNpdg];
  static int Pdg2Idx(int pdg);
  static int Idx2Pdg(int idx);
  static const char* Idx2Name(int idx);
  static const char* Idx2Symb(int idx);
 
  void CreateHistos();
 
  void Reset();
 
  // collect id's of MC events participating to the data
  void CollectMcEvents(TClonesArray* Matches);
 
  void FillHitMap();
 
  void FillTrackMatchMap(Int_t& nRec, Int_t& nGhosts, Int_t& nClones);
 
  void DivideHistos(TH1* histo1, TH1* histo2, TH1* histo3, Option_t* opt = "");
 
  struct McTrackInfo {
    std::map<Int_t, Int_t> fHitMap = {};  
    Int_t fGlobalTrackMatch        = -1;  
    Int_t fTrdTrackMatch           = -1;  
    Int_t fStsTrackMatch           = -1;  
    Double_t fQuali                = 0.;  
    Int_t fMatchedNHitsAll         = 0;   
    Int_t fMatchedNHitsTrue        = 0;   
    Bool_t fIsAccepted{0};
    Int_t fNtimesReconstructed{0};
    Bool_t fIsPrimary{0};
    Bool_t fIsFast{0};
    Bool_t fIsLong{0};
    Double_t fPt{0.};
    Double_t fP{0.};
    Int_t fPdg  = 0;
    Double_t fY = 0.;
  };
 
  McTrackInfo& getMcTrackInfo(const CbmLink& link)
  {
    assert(fMcTrackInfoMap.find(link) != fMcTrackInfoMap.end());
    return fMcTrackInfoMap[link];
  }
 
  std::map<CbmLink, McTrackInfo> fMcTrackInfoMap = {};  
 
  FairRootManager* fManager    = nullptr;  
  CbmMCDataManager* fMcManager = nullptr;  
  CbmTimeSlice* fTimeSlice     = nullptr;  
 
  CbmMCDataArray* fMCTracks = nullptr;  
 
  Int_t fTrdNstations         = 0;        // Number of Trd stations
  CbmMCDataArray* fTrdPoints  = nullptr;  
  TClonesArray* fTrdHits      = nullptr;  
  TClonesArray* fTrdHitMatch  = nullptr;  
  TClonesArray* fGlobalTracks = nullptr;  
  //TClonesArray* fGlobalTrackMatches = nullptr;  //! GlobalTrackMatch
  TClonesArray* fTrdTracks       = nullptr;  
  TClonesArray* fTrdTrackMatches = nullptr;  
  TClonesArray* fStsTracks       = nullptr;  
  TClonesArray* fStsTrackMatches = nullptr;  
 
  TVector3 fTargetPos = {0., 0., 0.};  // Target centre position
 
  Int_t fMinStations = 4;  // Minimal number of stations with hits for considered MCTrack
 
  Double_t fQuota = 0.7;  // True/all hits for track to be considered reconstructed
  float fYCM      = 0.;   // rapidity of CM
 
  TFolder fOutFolder = {"TrackingTrdQa", "TrackingTrdQa"};  
 
  // eff. vs. XY
  std::vector<CbmQaHist<TProfile2D>> fhStationEffXY;
  std::array<TH2F*, fgkNpdg> fhPidXY;
  // eff. vs. pT - Y
  std::map<const char*, std::array<TH2F*, fgkNpdg>> fhPidPtY;
 
  // eff. vs. pt, all
  TH1F* fhPtAccAll = nullptr;
  TH1F* fhPtRecAll = nullptr;
  TH1F* fhPtEffAll = nullptr;
 
  // eff. vs. pt, vertex
  TH1F* fhPtAccPrim = nullptr;
  TH1F* fhPtRecPrim = nullptr;
  TH1F* fhPtEffPrim = nullptr;
 
  // eff. vs. pt, non-vertex
  TH1F* fhPtAccSec = nullptr;
  TH1F* fhPtRecSec = nullptr;
  TH1F* fhPtEffSec = nullptr;
 
  // eff. vs. np, all
  TH1F* fhNpAccAll = nullptr;
  TH1F* fhNpRecAll = nullptr;
  TH1F* fhNpEffAll = nullptr;
 
  // eff. vs. np, vertex
  TH1F* fhNpAccPrim = nullptr;
  TH1F* fhNpRecPrim = nullptr;
  TH1F* fhNpEffPrim = nullptr;
 
  // eff. vs. np, non-vertex
  TH1F* fhNpAccSec = nullptr;
  TH1F* fhNpRecSec = nullptr;
  TH1F* fhNpEffSec = nullptr;
 
  // eff. vs. z, non-vertex
  TH1F* fhZAccSec = nullptr;
  TH1F* fhZRecSec = nullptr;
  TH1F* fhZEffSec = nullptr;
 
  // # hits of clones and ghosts
  TH1F* fhNhClones = nullptr;
  TH1F* fhNhGhosts = nullptr;
 
  // Pt resolution
  TH1F* fhPtResPrim = nullptr;
 
  // P resolution
  TH1F* fhPResPrim     = nullptr;
  TH1F* fhPResPrimSts0 = nullptr;
  TH1F* fhPResPrimSts1 = nullptr;
  TH1F* fhPResPrimSts2 = nullptr;
  TH1F* fhPResPrimSts3 = nullptr;
 
  TList* fHistoList = nullptr;
 
 
  Int_t fNAll          = 0;
  Int_t fNAccAll       = 0;
  Int_t fNAccPrim      = 0;
  Int_t fNAccFast      = 0;
  Int_t fNAccFastLong  = 0;
  Int_t fNAccSec       = 0;
  Int_t fNRecAll       = 0;
  Int_t fNRecPrim      = 0;
  Int_t fNRecFast      = 0;
  Int_t fNRecFastLong  = 0;
  Int_t fNRecSec       = 0;
  Int_t fNGhosts       = 0;
  Int_t fNClones       = 0;
  Int_t fNEvents       = 0;  
  Int_t fNEventsFailed = 0;  
  Double_t fTime       = 0.; 
  TStopwatch fTimer = {};
 
  CbmTrackingTrdQa(const CbmTrackingTrdQa&);
  CbmTrackingTrdQa operator=(const CbmTrackingTrdQa&);
 
  ClassDef(CbmTrackingTrdQa, 0);
};
 
 
#endif