CbmLitTrackingQa.h

Go to the documentation of this file.

/* Copyright (C) 2007-2018 GSI/JINR-LIT, Darmstadt/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Andrey Lebedev [committer] */
 
#ifndef CBMLITTRACKINGQA_H_
#define CBMLITTRACKINGQA_H_
 
#include "CbmDefs.h"
#include "FairTask.h"
#include "cbm/base/CbmLitDetectorSetup.h"
 
class CbmHistManager;
class CbmTrackMatchNew;
class CbmLitMCTrackCreator;
class CbmMCDataArray;
class TClonesArray;
 
using std::multimap;
using std::pair;
using std::string;
using std::vector;
 
 
class CbmLitTrackingQa : public FairTask {
 public:
  CbmLitTrackingQa();
 
  virtual ~CbmLitTrackingQa();
 
  virtual InitStatus Init();
 
  virtual void Exec(Option_t* opt);
 
  virtual void Finish();
 
  void SetMinNofPointsSts(Int_t minNofPointsSts) { fMinNofPointsSts = minNofPointsSts; }
  void SetMinNofPointsTrd(Int_t minNofPointsTrd) { fMinNofPointsTrd = minNofPointsTrd; }
  void SetMinNofPointsMuch(Int_t minNofPointsMuch) { fMinNofPointsMuch = minNofPointsMuch; }
  void SetMinNofPointsTof(Int_t minNofPointsTof) { fMinNofPointsTof = minNofPointsTof; }
  void SetMinNofHitsRich(Int_t minNofHitsRich) { fMinNofHitsRich = minNofHitsRich; }
  void SetQuota(Double_t quota) { fQuota = quota; }
  void SetQuotaRich(Double_t quotaRich) { fQuotaRich = quotaRich; }
  void SetMinNofHitsTrd(Int_t minNofHitsTrd) { fMinNofHitsTrd = minNofHitsTrd; }
  void SetMinNofHitsMuch(Int_t minNofHitsMuch) { fMinNofHitsMuch = minNofHitsMuch; }
  void SetUseConsecutivePointsInSts(Bool_t useConsecutivePointsInSts)
  {
    fUseConsecutivePointsInSts = useConsecutivePointsInSts;
  }
  void SetOutputDir(const std::string& dir) { fOutputDir = dir; }
  void SetPRange(Int_t bins, Int_t min, Int_t max)
  {
    fPRangeBins = bins;
    fPRangeMin  = min;
    fPRangeMax  = max;
  }
  void SetYRange(Int_t bins, Int_t min, Int_t max)
  {
    fYRangeBins = bins;
    fYRangeMin  = min;
    fYRangeMax  = max;
  }
  void SetPtRange(Int_t bins, Int_t min, Int_t max)
  {
    fPtRangeBins = bins;
    fPtRangeMin  = min;
    fPtRangeMax  = max;
  }
  void SetAngleRange(Double_t min, Double_t max, Int_t nofBins)
  {
    fAngleRangeMin  = min;
    fAngleRangeMax  = max;
    fAngleRangeBins = nofBins;
  }
  void SetTrackCategories(const vector<string>& trackCategories) { fTrackCategories = trackCategories; }
  void SetRingCategories(const vector<string>& ringCategories) { fRingCategories = ringCategories; }
 
  void SetRichAnnCut(Double_t par) { fRichAnnCut = par; }
  void SetTrdAnnCut(Double_t par) { fTrdAnnCut = par; }
 
 private:
  void ReadDataBranches();
 
  void FillDefaultTrackCategories();
 
  void FillDefaultRingCategories();
 
  void FillDefaultTrackPIDCategories();
 
  void FillDefaultPiSuppCategories();
 
  void FillDefaultRingPIDCategories();
 
  void FillTrackAndRingAcceptanceFunctions();
 
 
  void CreateH1Efficiency(const string& name, const string& parameter, const string& xTitle, Int_t nofBins,
                          Double_t minBin, Double_t maxBin, const string& opt);
 
  void CreateH2Efficiency(const string& name, const string& parameter, const string& xTitle, const string& yTitle,
                          Int_t nofBinsX, Double_t minBinX, Double_t maxBinX, Int_t nofBinsY, Double_t minBinY,
                          Double_t maxBinY, const string& opt);
 
  void CreateH1PionSuppression(const string& name, const string& parameter, const string& xTitle, Int_t nofBins,
                               Double_t minBin, Double_t maxBin);
 
  void CreateH1(const string& name, const string& xTitle, const string& yTitle, Int_t nofBins, Double_t minBin,
                Double_t maxBin);
 
  void CreateH2(const string& name, const string& xTitle, const string& yTitle, const string& zTitle, Int_t nofBinsX,
                Double_t minBinX, Double_t maxBinX, Int_t nofBinsY, Double_t minBinY, Double_t maxBinY);
 
  void CreateTrackHitsHistogram(const string& detName);
 
  vector<string> CreateGlobalTrackingHistogramNames(const vector<string>& detectors);
 
  vector<string> CreateGlobalTrackingHistogramNames();
 
  string LocalEfficiencyNormalization(const string& detName);
 
  vector<string> GlobalTrackVariants();
 
  vector<string> PionSuppressionVariants();
 
  void CreateHistograms();
 
  void ProcessGlobalTracks();
 
  void ProcessRichRings();
 
  void ProcessMvd(Int_t stsId);
 
  void FillTrackQualityHistograms(const CbmTrackMatchNew* trackMatch, ECbmModuleId detId);
 
  void ProcessMcTracks(Int_t iEvent);
 
  //   /**
  //    * \brief Calculate efficiency histograms.
  //    */
  //   void CalculateEfficiencyHistos();
 
  void FillGlobalReconstructionHistos(Int_t mcEventId, Int_t mcId, const multimap<pair<Int_t, Int_t>, Int_t>& mcMap,
                                      const string& histName, const string& histTypeName, const string& effName,
                                      const string& catName, const vector<Double_t>& par);
 
  void FillGlobalReconstructionHistosRich(Int_t mcEventId, Int_t mcId, const multimap<pair<Int_t, Int_t>, Int_t>& mcMap,
                                          const string& histName, const string& histTypeName, const string& effName,
                                          const string& catName, const vector<Double_t>& par);
 
  Bool_t ElectronId(Int_t mcEventId, Int_t mcId, const multimap<pair<Int_t, Int_t>, Int_t>& mcMap,
                    const string& effName);
 
  void PionSuppression();
 
  void IncreaseCounters();
 
  CbmHistManager* fHM;                    // Histogram manager
  string fOutputDir;                      // Output directory for results
  CbmLitDetectorSetup fDet;               // Detector presence information
  CbmLitMCTrackCreator* fMCTrackCreator;  // MC track creator tool
 
  // Acceptance defined by MC points
  Int_t fMinNofPointsSts;   // Minimal number of MCPoints in STS
  Int_t fMinNofPointsTrd;   // Minimal number of MCPoints in TRD
  Int_t fMinNofPointsMuch;  // Minimal number of MCPoints in MUCH
  Int_t fMinNofPointsTof;   // Minimal number of MCPoints in TOF
  Double_t fQuota;          // True/all hits for track to be considered correctly reconstructed
 
  Bool_t fUseConsecutivePointsInSts;  // Use consecutive MC points for STS normalization
 
  // Acceptance in RICH
  Int_t fMinNofHitsRich;  // Minimal number of hits in MC RICH ring
  Double_t fQuotaRich;    // True/all hits for ring to be considered correctly reconstructed
 
  // Minimal number of hits in track to be considered as accepted.
  // This is needed because the definition of the correctly reconstructed track
  // is 70% of hits in the reconstructed track are from the same MC track.
  // But this can lead to the situation when a reconstructed track has 4 hits,
  // all of them from the same MC track, which means that the track is correctly
  // reconstructed. BUT the real MC track has 12 points(hits). This is especially
  // important for the MUCH detector. To avoid such situations one has to put
  // such cut.
  Int_t fMinNofHitsTrd;   // for TRD track
  Int_t fMinNofHitsMuch;  // for MUCH track
 
  Double_t fPRangeMin;      // Minimum momentum for tracks for efficiency calculation [GeV/c]
  Double_t fPRangeMax;      // Maximum momentum for tracks for efficiency calculation [GeV/c]
  Int_t fPRangeBins;        // Number of bins for efficiency vs. momentum histogram
  Double_t fPtRangeMin;     // Minimum Pt for tracks for efficiency calculation [GeV/c]
  Double_t fPtRangeMax;     // Maximum Pt for tracks for efficiency calculation [GeV/c]
  Int_t fPtRangeBins;       // Number of bins for efficiency vs. Pt histogram
  Double_t fYRangeMin;      // Minimum rapidity for tracks for efficiency calculation [GeV/c]
  Double_t fYRangeMax;      // Maximum rapidity for tracks for efficiency calculation [GeV/c]
  Int_t fYRangeBins;        // Number of bins for efficiency vs. rapidity histogram
  Double_t fAngleRangeMin;  // Minimum polar angle [grad]
  Double_t fAngleRangeMax;  // Maximum polar angle [grad]
  Int_t fAngleRangeBins;    // Number of bins for efficiency vs. polar angle histogram
 
  // Pointers to data arrays
  CbmMCDataArray* fMCTracks;       // CbmMCTrack array
  TClonesArray* fGlobalTracks;     // CbmGlobalTrack array
  CbmMCDataArray* fMvdPoints;      // CbmMvdPoint array
  TClonesArray* fMvdHitMatches;    // CbmMatch array
  TClonesArray* fStsTracks;        // CbmStsTrack array
  TClonesArray* fStsMatches;       // CbmStsTrackMatch array
  TClonesArray* fRichRings;        // CbmRichRing array
  TClonesArray* fRichProjections;  // CbmRichProjection array
  TClonesArray* fRichRingMatches;  // CbmRichMatchesn array
  TClonesArray* fMuchMatches;      // CbmTrackMatchNew array
  TClonesArray* fTrdMatches;       // CbmTrackMatchNew array
  CbmMCDataArray* fTofPoints;      // CbmTofPoint array
  TClonesArray* fTofMatches;       // CbmMatch array
 
  // Global track segment name maps to multimap <MC track index, reconstructed track index>
  map<string, multimap<pair<Int_t, Int_t>, Int_t>> fMcToRecoMap;
 
  vector<string> fTrackCategories;     // Vector of track category names
  vector<string> fRingCategories;      // Vector of ring category names
  vector<string> fTrackCategoriesPID;  // Vector of track category names
  vector<string> fRingCategoriesPID;   // Vector of ring category names for REC+PID
  vector<string> fPiSuppCategories;
  ;  // Vector of categories for pion suppression
 
  //#ifndef  __ROOTCLING__
  typedef Bool_t (*LitTrackAcceptanceFunction)(CbmMCDataArray* mcTracks, Int_t eventNo, Int_t index);
  typedef Bool_t (*LitRingAcceptanceFunction)(CbmMCDataArray* mcTracks, Int_t eventNo, Int_t index,
                                              Int_t nofHitsInRing);
  typedef Bool_t (*LitPiSuppAcceptanceFunction)(const TClonesArray* globalTracks, const TClonesArray* stsMatches,
                                                const TClonesArray* richMatches, Int_t index);
  map<string, LitTrackAcceptanceFunction>
    fTrackAcceptanceFunctions;  // maps track category name to track acceptance function
  map<string, LitRingAcceptanceFunction>
    fRingAcceptanceFunctions;  // maps ring category name to ring acceptance function
  map<string, LitPiSuppAcceptanceFunction>
    fPiSuppAcceptanceFunctions;  // maps pion supp. category name to piSupp acceptance function
                                 //#endif
  Double_t fRichAnnCut;
  Double_t fTrdAnnCut;
 
  CbmLitTrackingQa(const CbmLitTrackingQa&);
  CbmLitTrackingQa& operator=(const CbmLitTrackingQa&);
 
  ClassDef(CbmLitTrackingQa, 1);
};
 
#endif /* CBMLITTRACKINGQA_H_ */