PndTrackingQA.h

Go to the documentation of this file.

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

#ifndef PndTrackingQA_H_
#define PndTrackingQA_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 "PndTrackFunctor.h"


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,
                kMcAllTracksWithHits = -12, // sum of -7 - -10
                kMcAllTracks = -13, // sum of -11 and -12

                // 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

          static std::string QualityNumberToString(int qNumber)
          {
                  if (qNumber == kPossiblePrim)                 return "PossiblePrimary";
                  if (qNumber == kPossibleSec)                  return "PossibleSec";
                  if (qNumber == kAtLeastThreeSec)              return "AtLeastThreeSec";
                  if (qNumber == kAtLeastThreePrim)     return "AtLeastThreePrim";
                  if (qNumber == kLessThanThreePrim)    return "LessThanThreePrim";
                  if (qNumber == kMcPossibleSec)                return "McPossibleSec";
                  if (qNumber == kMcAtLeastThreeSec)    return "McAtLeastThreeSec";
                  if (qNumber == kMcAtLeastThreePrim)   return "McAtLeastThreePrim";
                  if (qNumber == kMcLessThanThreePrim)  return "McLessThanThreePrim";
                  if (qNumber == kMcAllTracksWithHits)  return "McAllTracksWithHits";
                  if (qNumber == kMcAllTracks)                  return "McAllTracks";
                  if (qNumber == kSpuriousFound)                return "SpuriousFound";
                  if (qNumber == kPartiallyFound)               return "PartiallyFound";
                  if (qNumber == kFullyFound)                   return "FullyFound";
                  if (qNumber == kGhost)                                return "Ghost";
                  if (qNumber == kNotFound)                     return "NotFound";
                  if (qNumber == kFound)                                return "Found";
                  return std::to_string(qNumber);
          };
};

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

        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> GetPlResolution()                                             {return fMapPlResolution;}
        std::map<Int_t, Double_t> GetPl()                                                               {return fMapPl;}
        std::map<Int_t, Double_t> GetPResolutionRel()                                   {return fMapPResolutionRel;}
        std::map<Int_t, Double_t> GetPtResolutionRel()                                  {return fMapPtResolutionRel;}
        std::map<Int_t, Double_t> GetPlResolutionRel()                                  {return fMapPlResolutionRel;}
        std::map<Int_t, Int_t> GetTrackIdMCId()                                                 {return fTrackIdMCId;}
        Int_t GetNGhosts()                                                                                              {return fNGhosts;}



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

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

        Int_t GetIdealTrackIdFromMCTrackId(int mctrackid) {
                if (fMCIdIdealTrackId.count(mctrackid) == 0) return -1;
                return fMCIdIdealTrackId[mctrackid];
        }
        Int_t GetIdealTrackIdFromRecoTrackId(int trackid) { 
          int mctrackid = fTrackIdMCId[trackid];
          if (fMCIdIdealTrackId.count(mctrackid) == 0) return -1;
          return fMCIdIdealTrackId[mctrackid];
        }
        
        PndTrackingQualityRecoInfo GetRecoInfoFromRecoTrack(Int_t trackId, Int_t mctrackId);

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);

        FairRootManager* ioman;

        TString fTrackBranchName;
        TString fIdealTrackName;
        Bool_t fPndTrackOrTrackCand; //kTRUE if track and kFALSE if track cand
        std::string fPossibleTrackName;
        PndTrackFunctor* fPossibleTrack;
        Bool_t fCleanFunctor;
        Int_t fNGhosts;

        Bool_t fUseCorrectedSkewedHits;
        Int_t fVerbose;

        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;                  
        std::map<Int_t, Double_t> fMapPlResolution;                     
        std::map<Int_t, Double_t> fMapPl;                               
        std::map<Int_t, Double_t> fMapPlResolutionRel;                  

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


        ClassDef(PndTrackingQA, 1)
};

#endif /* PNDTRACKINGQUALITY_H_ */