PndTrackingQualityBarrelAnalysisNewLinks.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

/*
 * PndTrackingQualityBarrelAnalysisNewLinks.h
 *
 *  Created on: Aug 23, 2013
 *      Author: stockman
 */

#ifndef PndTrackingQualityBarrelAnalysisNewLinks_H_
#define PndTrackingQualityBarrelAnalysisNewLinks_H_

#include "FairMultiLinkedData.h"
#include "FairRootManager.h"

#include "PndTrackCand.h"
#include "PndTrackingQualityRecoInfo.h"

#include <TObject.h>
#include <TString.h>
#include <TClonesArray.h>

#include <vector>
#include <map>

#include <functional>
#include "PndTrackingQualityAnalysis.h"

/*class PossibleTrackFunctor : public std::binary_function<FairMultiLinkedData* , Bool_t, Bool_t>
{
  public :
    virtual Bool_t operator() (FairMultiLinkedData* a, Bool_t primary) {return Call(a, primary);};
    virtual Bool_t Call(FairMultiLinkedData* a, Bool_t primary) = 0;
    virtual void Print() = 0;

    virtual ~PossibleTrackFunctor() {};

};

class StandardTrackFunctor : public PossibleTrackFunctor
{
  Bool_t Call(FairMultiLinkedData* a, Bool_t primary){
    FairRootManager* ioman = FairRootManager::Instance();
    Bool_t possibleTrack = kFALSE;
    possibleTrack = possibleTrack | (a->GetLinksWithType(ioman->GetBranchId("MVDHitsPixel")).GetNLinks() +
                     a->GetLinksWithType(ioman->GetBranchId("MVDHitsStrip")).GetNLinks() > 3);

    possibleTrack = possibleTrack | (a->GetLinksWithType(ioman->GetBranchId("MVDHitsPixel")).GetNLinks() +
                     a->GetLinksWithType(ioman->GetBranchId("MVDHitsStrip")).GetNLinks() +
                     a->GetLinksWithType(ioman->GetBranchId("STTHit")).GetNLinks() ) > 5;

    return possibleTrack;
  }

  void Print(){
    std::cout << "StandardTrackFunctor: > 3 Hits in MVD or > 5 Hits in (MVD+Stt)" << std::endl;
  }
};

class OnlySttFunctor : public PossibleTrackFunctor
{
  Bool_t Call(FairMultiLinkedData* a, Bool_t primary){
    FairRootManager* ioman = FairRootManager::Instance();
    Bool_t possibleTrack = kFALSE;

    possibleTrack = possibleTrack | a->GetLinksWithType(ioman->GetBranchId("STTHit")).GetNLinks() > 5;

    return possibleTrack;
  }
  void Print(){
    std::cout << "OnlySttFunctor: > 5 Hits in Stt" << std::endl;
  }
};

class RiemannMvdSttGemFunctor : public PossibleTrackFunctor
{
  Bool_t Call(FairMultiLinkedData* a, Bool_t primary){
    FairRootManager* ioman = FairRootManager::Instance();
    Bool_t possibleTrack = kFALSE;
    Bool_t mvdHits =  ((a->GetLinksWithType(ioman->GetBranchId("MVDHitsPixel")).GetNLinks() +
              a->GetLinksWithType(ioman->GetBranchId("MVDHitsStrip")).GetNLinks()) > 2);

    if (mvdHits){
      possibleTrack = a->GetLinksWithType(ioman->GetBranchId("STTHit")).GetNLinks() > 1 | a->GetLinksWithType(ioman->GetBranchId("GEMHit")).GetNLinks() > 1;
    }
    return possibleTrack;
  }
  void Print(){
    std::cout << "RiemannMvdSttGemFunctor: > 2 Hits in MVD and >0 Hits in (Stt+Gem)" << std::endl;
  }

};

class CircleHoughTrackFunctor : public PossibleTrackFunctor
{
  Bool_t Call(FairMultiLinkedData* a, Bool_t primary){
    if (primary == kFALSE) return kFALSE;
    FairRootManager* ioman = FairRootManager::Instance();
    Bool_t possibleTrack = kFALSE;

    Int_t nHitsMvdPixel = a->GetLinksWithType(ioman->GetBranchId("MVDHitsPixel")).GetNLinks();
    Int_t nHitsMvdStrip = a->GetLinksWithType(ioman->GetBranchId("MVDHitsStrip")).GetNLinks();
    if (nHitsMvdPixel + nHitsMvdStrip > 2) {  // First requirement: more than two MVD hits
      Int_t nHitsStt = a->GetLinksWithType(ioman->GetBranchId("STTHit")).GetNLinks();
      Int_t nHitsGem = a->GetLinksWithType(ioman->GetBranchId("GEMHit")).GetNLinks();
      possibleTrack = (nHitsMvdPixel + nHitsMvdStrip + nHitsStt + nHitsGem > 6);  // Second requirement: More than six hits total
    }
    return possibleTrack;
  }
  void Print(){
    std::cout << "CircleHoughTrackFunctor: > 3 Hits in MVD and primary track" << std::endl;
  }

};
*/

/*
struct qualityNumbers {
  static const int
    // Following: Default statuses.
    // Are the 'not found' tracks in the quality histogram of PndTrackingQualityTask.
    kPossibleSec = -1,  // possible: As defined through the possibleFunctor; secondary: a non-primary particle
    kPossiblePrim = -2,  // possible: As defined through the possibleFunctor; primary: coming directly from particle generator (e.g. EvtGen)
    kAtLeastThreeSec = -3,  // atLeastThree: min. 3 hit points in central tracking detectors (MVD, STT, GEM); secondary: a non-primary particle
    kAtLeastThreePrim = -4,  // atLeastThree: min. 3 hit points in central tracking detectors (MVD, STT, GEM); primary: coming directly from particle generator (e.g. EvtGen)
    kLessThanThreePrim = -5,  // LessThanThree: fewer than 3 hit points in central tracking detectors (MVD, STT, GEM); primar: coming directly from particle generator (e.g. EvtGen)

    // Following: MC statuses of all (found+notfound) tracks
    kMcPossibleSec = -7,  // see above
    kMcPossiblePrim = -8,
    kMcAtLeastThreeSec = -9,
    kMcAtLeastThreePrim = -10,
    kMcLessThanThreePrim = -11,

    // Following: Status of reconstructed tracks (= created PndTracks)
    kSpuriousFound = 1,  // spuriousFound: at least 70% of hits of reco'd track come from one MC track ('mostProbableTrack')
    kPartiallyFound = 2,  // partiallyFound: all hits of reco'd track come from one single MC track; at least 70% of hits of MC track have been found in reco'd track
    kFullyFound = 3,  // fullyFound: all hits of reco'd track come from one single MC track; all hits of MC track have been found in reco'd track

    kGhost = 5,  // ghost: less than 70% of hits of reco'd track come from one MC track ('mostProbableTrack')

    kNotFound = 7,  // notFound: total number of not reco'd tracks
    kFound = 8;  // found: total number of reco'd tracks; the sum of fullyFound, partiallyFound, spuriousFound
};

*/

class PndTrackingQualityBarrelAnalysisNewLinks : public TObject {
 public:
  PndTrackingQualityBarrelAnalysisNewLinks(TString trackBranchName, TString idealTrackName, Bool_t pndTrackData = kTRUE);
  PndTrackingQualityBarrelAnalysisNewLinks(TString trackBranchName, TString idealTrackName, PossibleTrackFunctor *posTrack, Bool_t pndTrackData = kTRUE);
  virtual ~PndTrackingQualityBarrelAnalysisNewLinks();

  virtual void Init();
  void SetVerbose(Int_t val) { fVerbose = val; }

  void AddHitsBranchName(TString name) { fBranchNames.push_back(name); }
  void SetHitsBranchNames(std::vector<TString> names) { fBranchNames = names; }

  void AnalyseEvent(TClonesArray *recoTrackInfo);

  //    Int_t GetNIdealHits(Int_t trackId, TString branchName);
  Int_t GetNIdealHits(FairMultiLinkedData &track, TString branchName);
  std::map<Int_t, Int_t> GetMCTrackFound() { return fMCTrackFound; }
  std::map<Int_t, Int_t> GetTrackQualification() { return fMapTrackQualification; }
  std::map<Int_t, Int_t> GetTrackMCStatus() { return fMapTrackMCStatus; }
  std::map<Int_t, std::map<TString, std::pair<Double_t, Int_t>>> GetEfficiencies() { return fMapEfficiencies; }
  std::map<Int_t, Double_t> GetPResolution() { return fMapPResolution; }
  std::map<Int_t, TVector3> GetP() { return fMapP; }
  std::map<Int_t, Double_t> GetPtResolution() { return fMapPtResolution; }
  std::map<Int_t, Double_t> GetPt() { return fMapPt; }
  std::map<Int_t, Double_t> GetPResolutionRel() { return fMapPResolutionRel; }
  std::map<Int_t, Double_t> GetPtResolutionRel() { return fMapPtResolutionRel; }
  std::map<Int_t, Int_t> GetTrackIdMCId() { return fTrackIdMCId; }
  Int_t GetNGhosts() { return fNGhosts; }

  void PrintTrackDataSummary(FairMultiLinkedData &trackData, Bool_t detailedInfo = kFALSE);

  void PrintTrackQualityMap(Bool_t detailedInfo = kFALSE);
  void PrintTrackMCStatusMap();
  void PrintTrackInfo(std::map<TString, FairMultiLinkedData> info);

  Int_t GetIdealTrackIdFromMCTrackId(int mctrackid) { return fMCIdIdealTrackId[mctrackid]; }
  Int_t GetIdealTrackIdFromRecoTrackId(int trackid)
  {
    int mctrackid = fTrackIdMCId[trackid];
    return fMCIdIdealTrackId[mctrackid];
  }

  PndTrackingQualityRecoInfo GetRecoInfoFromRecoTrack(Int_t trackId, Int_t mctrackId);

  static Bool_t IsBarrelMVD(FairMultiLinkedData &links, int iHit);
  static Int_t NBarrelMVD(FairMultiLinkedData &links);

 private:
  virtual void FillMapTrackQualifikation();
  Bool_t IsBetterTrackExisting(Int_t &mcIndex, int quality);
  //    virtual Bool_t PossibleTrack(FairMultiLinkedData& mcForward);
  Int_t GetSumOfAllValidMCHits(FairMultiLinkedData *trackData);
  virtual Int_t AnalyseTrackInfo(std::map<TString, FairMultiLinkedData> &trackInfo, Int_t trackId);
  virtual void CalcEfficiencies(Int_t mostProbableTrack, std::map<TString, FairMultiLinkedData> &trackInfo);
  FairMultiLinkedData GetMCInfoForBranch(TString branchName, PndTrackCand *trackCand);
  std::map<TString, FairMultiLinkedData> AnalyseTrackCand(PndTrackCand *trackCand);

  //    virtual Bool_t IsCorrectGemHit(FairLink& gemLink);

  Int_t fVerbose;
  FairRootManager *ioman;
  Int_t fNGhosts;

  TString fTrackBranchName;
  TString fIdealTrackName;
  Bool_t fPndTrackOrTrackCand; // kTRUE if track and kFALSE if track cand
  PossibleTrackFunctor *fPossibleTrack;

  Bool_t fUseCorrectedSkewedHits;

  std::vector<TString> fBranchNames;        
  std::map<Int_t, Int_t> fTrackIdMCId;      
  std::map<Int_t, Int_t> fMCIdTrackId;      
  std::map<Int_t, Int_t> fMCIdIdealTrackId; 

  std::map<Int_t, Int_t> fMCTrackFound; 

  std::map<Int_t, Int_t> fMapTrackMCStatus;                                        
  std::map<Int_t, Int_t> fMapTrackQualification;                                   
  std::map<Int_t, std::map<TString, std::pair<Double_t, Int_t>>> fMapEfficiencies; 
  std::map<Int_t, Double_t> fMapPResolution;                                       
  std::map<Int_t, TVector3> fMapP;                                                 
  std::map<Int_t, Double_t> fMapPtResolution;                                      
  std::map<Int_t, Double_t> fMapPt;                                                
  std::map<Int_t, Double_t> fMapPResolutionRel;                                    
  std::map<Int_t, Double_t> fMapPtResolutionRel;                                   

  TClonesArray *fTrack;
  TClonesArray *fMCTrack;
  TClonesArray *fIdealTrack;
  TClonesArray *fIdealTrackCand;

  ClassDef(PndTrackingQualityBarrelAnalysisNewLinks, 1)
};

#endif /* PNDTRACKINGQUALITY_H_ */