PndTrackingQA Class Reference

#include <PndTrackingQA.h>

Inheritance diagram for PndTrackingQA:

Public Member Functions
	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)
void	AddHitsBranchName (TString name)
	Adds branch names of detector data which should be taken into account in the analysis. More...
void	SetHitsBranchNames (std::vector< TString > names)
void	AnalyseEvent (TClonesArray *recoTrackInfo)
Int_t	GetNIdealHits (FairMultiLinkedData &track, TString branchName)
std::map< Int_t, Int_t >	GetMCTrackFound ()
std::map< Int_t, Int_t >	GetTrackQualification ()
std::map< Int_t, Int_t >	GetTrackMCStatus ()
std::map< Int_t, std::map < TString, std::pair< Double_t, Int_t > > >	GetEfficiencies ()
std::map< Int_t, Double_t >	GetPResolution ()
std::map< Int_t, TVector3 >	GetP ()
std::map< Int_t, Double_t >	GetPtResolution ()
std::map< Int_t, Double_t >	GetPt ()
std::map< Int_t, Double_t >	GetPlResolution ()
std::map< Int_t, Double_t >	GetPl ()
std::map< Int_t, Double_t >	GetPResolutionRel ()
std::map< Int_t, Double_t >	GetPtResolutionRel ()
std::map< Int_t, Double_t >	GetPlResolutionRel ()
std::map< Int_t, Int_t >	GetTrackIdMCId ()
Int_t	GetNGhosts ()
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)
Int_t	GetIdealTrackIdFromRecoTrackId (int trackid)
PndTrackingQualityRecoInfo	GetRecoInfoFromRecoTrack (Int_t trackId, Int_t mctrackId)

Private Member Functions
virtual void	FillMapTrackQualifikation ()
Bool_t	IsBetterTrackExisting (Int_t &mcIndex, int quality)
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)
	returns which MCTracks and how often (marked by a FairLink) they were seen by the hits of a PndTrackCand More...
std::map< TString, FairMultiLinkedData >	AnalyseTrackCand (PndTrackCand *trackCand)
	returns a map<BranchNameOfHits, MCTrackLinks> which returns the FairLinks to MCTracks grouped by hit branches and all More...

Private Attributes
FairRootManager *	ioman
TString	fTrackBranchName
TString	fIdealTrackName
Bool_t	fPndTrackOrTrackCand
std::string	fPossibleTrackName
PndTrackFunctor *	fPossibleTrack
Bool_t	fCleanFunctor
Int_t	fNGhosts
Bool_t	fUseCorrectedSkewedHits
Int_t	fVerbose
std::vector< TString >	fBranchNames
	! branch names of hits taken into account in the analysis (e.g. MVDHitsPixel, STTHit, ...) More...
std::map< Int_t, Int_t >	fTrackIdMCId
	! map between track id and most probable MC track id More...
std::map< Int_t, Int_t >	fMCIdTrackId
	! map between MC id and track id More...
std::map< Int_t, Int_t >	fMCIdIdealTrackId
	! map between MC id and ideal track id More...
std::map< Int_t, Int_t >	fMCTrackFound
	! How often was a MC Track (key) found More...
std::map< Int_t, Int_t >	fMapTrackMCStatus
	! TrackId vs TrackStatus from MC More...
std::map< Int_t, Int_t >	fMapTrackQualification
	! TrackId vs TrackStatus after analysis of track finding More...
std::map< Int_t, std::map < TString, std::pair< Double_t, Int_t > > >	fMapEfficiencies
	! MostProbable TrackId, BranchName, Efficiency (#FoundHits / #MCHits), #MCHits More...
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

Detailed Description

Definition at line 91 of file PndTrackingQA.h.

Constructor & Destructor Documentation

PndTrackingQA::PndTrackingQA	(	TString	trackBranchName,
		TString	idealTrackName,
		Bool_t	pndTrackData = kTRUE
	)

Definition at line 15 of file PndTrackingQA.cxx.

References fCleanFunctor, and fPossibleTrack.

                                                                                                 :
       fTrackBranchName(trackBranchName), fIdealTrackName(idealTrackName), fPndTrackOrTrackCand(pndTrackData), fPossibleTrack(0), fCleanFunctor(kFALSE), fNGhosts(0), fUseCorrectedSkewedHits(kFALSE), fVerbose(0)
{
        if(fPossibleTrack == 0){
                std::cout << "-I- PndTrackingQA::PndTrackingQA no PossibleTrackFunctor given. Taking Standard!" << std::endl;
                if (trackBranchName == "MVDTrack" ){
                        fPossibleTrack = new RiemannMvdSttGemFunctor();
                } else if (trackBranchName == "CombiTrackCand" ) {
                        fPossibleTrack = new OnlySttFunctor();
                } else {
                        fPossibleTrack = new StandardTrackFunctor();
                }
                fCleanFunctor = kTRUE;
        }
}

PndTrackingQA::PndTrackingQA	(	TString	trackBranchName,
		TString	idealTrackName,
		PndTrackFunctor *	posTrack,
		Bool_t	pndTrackData = kTRUE
	)

Definition at line 31 of file PndTrackingQA.cxx.

References fCleanFunctor, and fPossibleTrack.

                                                                                                                            :
        fTrackBranchName(trackBranchName), fIdealTrackName(idealTrackName), fPndTrackOrTrackCand(pndTrackData), fPossibleTrack(posTrack), fCleanFunctor(kFALSE), fNGhosts(0), fUseCorrectedSkewedHits(kFALSE), fVerbose(0)
{
        if(fPossibleTrack == 0){
                std::cout << "-I- PndTrackingQA::PndTrackingQA no PossibleTrackFunctor given. Taking Standard!" << std::endl;
                if (trackBranchName == "MVDTrack" ){
                        fPossibleTrack = new RiemannMvdSttGemFunctor();
                } else if (trackBranchName == "CombiTrackCand" ) {
                        fPossibleTrack = new OnlySttFunctor();
                } else {
                        fPossibleTrack = new StandardTrackFunctor();
                }
                fCleanFunctor = kTRUE;
        }
}

PndTrackingQA::~PndTrackingQA ( )

virtual

Definition at line 47 of file PndTrackingQA.cxx.

References fCleanFunctor, and fPossibleTrack.

{
        if (fCleanFunctor)
                delete (fPossibleTrack);
}

Member Function Documentation

void PndTrackingQA::AddHitsBranchName ( TString  name )

inline

Adds branch names of detector data which should be taken into account in the analysis.

Definition at line 102 of file PndTrackingQA.h.

References fBranchNames.

Referenced by Init().

{ fBranchNames.push_back(name);}

void PndTrackingQA::AnalyseEvent

(

TClonesArray *

recoTrackInfo

)

Definition at line 84 of file PndTrackingQA.cxx.

References AnalyseTrackCand(), AnalyseTrackInfo(), CalcEfficiencies(), FillMapTrackQualifikation(), fMapP, fMapPl, fMapPlResolution, fMapPlResolutionRel, fMapPResolution, fMapPResolutionRel, fMapPt, fMapPtResolution, fMapPtResolutionRel, fMapTrackQualification, fMCIdTrackId, fMCTrack, fMCTrackFound, fPndTrackOrTrackCand, fTrack, fTrackIdMCId, fVerbose, PndMCTrack::GetMomentum(), PndTrack::GetParamFirst(), GetRecoInfoFromRecoTrack(), PndTrack::GetTrackCandPtr(), i, mom, PrintTrackQualityMap(), and PndTrackingQualityRecoInfo::SetNofMCTracks().

Referenced by PndTrackingQATask::Exec().

{
        FillMapTrackQualifikation();
        if (fVerbose > 2){
                std::cout << "PndTrackingQA::AnalyseEvent() Track quality map before analysis: " << std::endl << std::endl;
                PrintTrackQualityMap(kTRUE);
        }

        for (Int_t i = 0; i < fTrack->GetEntriesFast(); i++){
                if (fVerbose > 2){
                        std::cout << "----------------------------------" << std::endl;
                        std::cout << "Analyse Track: " << i << std::endl;
                }
                std::map<TString, FairMultiLinkedData> trackInfo;

                if (fPndTrackOrTrackCand){
                        PndTrack* myTrack = (PndTrack*)fTrack->At(i);
                        trackInfo = AnalyseTrackCand(myTrack->GetTrackCandPtr());
                } else {
                        PndTrackCand* myTrack = (PndTrackCand*)fTrack->At(i);
                        trackInfo = AnalyseTrackCand(myTrack);
                }
                Int_t mostProbableTrack = AnalyseTrackInfo(trackInfo, i);

                if (fVerbose > 1){
                        std::cout << "PndTrackingQA::AnalyseEvent Analyse track: " << i << std::endl;
                        std::cout << "mostProbableTrack " << mostProbableTrack << std::endl;
                }

                if (mostProbableTrack == -1) continue;

                fTrackIdMCId[i] = mostProbableTrack;
                CalcEfficiencies(mostProbableTrack, trackInfo);

                if (fMapTrackQualification.count(mostProbableTrack) > 0)
                        fMCTrackFound[mostProbableTrack]++;

                PndTrackingQualityRecoInfo recoinfo = GetRecoInfoFromRecoTrack(i, mostProbableTrack);
                int nof_asso_mctracks = trackInfo["AllHits"].GetNLinks();
                recoinfo.SetNofMCTracks(nof_asso_mctracks);
                int size = recoTrackInfo->GetEntriesFast();
                new((*recoTrackInfo)[size]) PndTrackingQualityRecoInfo(recoinfo);
        }

        for (std::map<Int_t, Int_t>::iterator iter = fMapTrackQualification.begin(); iter != fMapTrackQualification.end(); iter++) {

                if (iter->first > -1 && iter->second > 0) {
                        PndMCTrack* mcTrack = (PndMCTrack*) fMCTrack->At(iter->first);

                        if (fPndTrackOrTrackCand) {
                                PndTrack* myTrack = (PndTrack*) fTrack->At(fMCIdTrackId[iter->first]);
                                TVector3 mom(myTrack->GetParamFirst().GetPx(),
                                                myTrack->GetParamFirst().GetPy(),
                                                myTrack->GetParamFirst().GetPz());
                                TVector3 McMom(mcTrack->GetMomentum());

                                fMapPResolution[iter->first] = (mom.Mag() - McMom.Mag());
                                fMapP[iter->first] = mom;
                                fMapPtResolution[iter->first] = (mom.Pt() - McMom.Pt());
                                fMapPt[iter->first] = mom.Pt();
                                fMapPlResolution[iter->first] = (mom.Pz() - McMom.Pz());
                                fMapPl[iter->first] = mom.Pz();
                                fMapPResolutionRel[iter->first] = (mom.Mag() - McMom.Mag())
                                                / McMom.Mag();
                                fMapPtResolutionRel[iter->first] = (mom.Pt() - McMom.Pt())
                                                / McMom.Pt();
                                fMapPlResolutionRel[iter->first] = (mom.Pz() - McMom.Pz())
                                                / McMom.Pz();
                        }
                }

        }
        if (fVerbose > 2)
                std::cout << "AnalyseEvent End" << std::endl;
}

std::map< TString, FairMultiLinkedData > PndTrackingQA::AnalyseTrackCand ( PndTrackCand *  trackCand )

private

returns a map<BranchNameOfHits, MCTrackLinks> which returns the FairLinks to MCTracks grouped by hit branches and all

Definition at line 181 of file PndTrackingQA.cxx.

References fBranchNames, fVerbose, GetMCInfoForBranch(), and PrintTrackInfo().

Referenced by AnalyseEvent().

{
        std::map<TString, FairMultiLinkedData> trackInfo;

        if (fVerbose > 2) {
                std::cout << "PndTrackingQualityData::AnalyseTrackCand: TrackInfo" << std::endl;
                std::cout << *trackCand << std::endl;
        }
        for (size_t branchIndex = 0; branchIndex < fBranchNames.size(); branchIndex++){
//              std::cout << "BranchName: " << fBranchNames[branchIndex] << std::endl;
                trackInfo[fBranchNames[branchIndex]] = GetMCInfoForBranch(fBranchNames[branchIndex], trackCand);
                trackInfo["AllHits"].AddLinks(trackInfo[fBranchNames[branchIndex]]);
        }
        if (fVerbose > 2)
                PrintTrackInfo(trackInfo);
        return trackInfo;
}

Int_t PndTrackingQA::AnalyseTrackInfo ( std::map< TString, FairMultiLinkedData > &  trackInfo, Int_t  trackId  )

privatevirtual

Definition at line 199 of file PndTrackingQA.cxx.

References Double_t, fIdealTrack, fMapTrackQualification, fMCIdIdealTrackId, fMCIdTrackId, fNGhosts, fVerbose, GetSumOfAllValidMCHits(), i, qualityNumbers::kFullyFound, qualityNumbers::kPartiallyFound, qualityNumbers::kSpuriousFound, and PrintTrackDataSummary().

Referenced by AnalyseEvent().

{

        Int_t mostProbableTrack = -1;   //the MCTrack most FairLinks of a TrackCand are pointing to
        if (fVerbose > 2){
                std::cout << "PndTrackingQA::AnalyseTrackInfo: NMCLinks: " << trackInfo["AllHits"].GetNLinks() << std::endl;
                PrintTrackDataSummary(trackInfo["AllHits"]);
                std::cout << "PndTrackingQA::AnalyseTrackInfo " << trackInfo["AllHits"] << std::endl;
        }

        std::vector<FairLink> sortedMCTracks = trackInfo["AllHits"].GetSortedMCTracks();

        if (sortedMCTracks.size() == 0) return mostProbableTrack; //returns -1; no MCTracks

        if (sortedMCTracks.size() == 1){
                mostProbableTrack = sortedMCTracks[0].GetIndex();
                if (fMCIdIdealTrackId.count(mostProbableTrack) == 0){
                        std::cout << "-W- PndTrackingQA::AnalyseTrackInfo fMCIdIdealTrackId does not contain mostProbableTrack" << mostProbableTrack << std::endl;
                        return -1;
                }
                if (!(fMCIdIdealTrackId[mostProbableTrack] < fIdealTrack->GetEntriesFast())){
                        std::cout << "-W- PndTrackingQA::AnalyseTrackInfo fMCIdIdealTrackId the ideal track is not in fIdealTrack. mostProbableTrack:" << mostProbableTrack << " idealTrack " << fMCIdIdealTrackId[mostProbableTrack] << std::endl;
                        return -1;
                }
                PndTrackCand* myIdealTrack = ((PndTrack*)fIdealTrack->At(fMCIdIdealTrackId[mostProbableTrack]))->GetTrackCandPtr();
                Int_t nMCHits = GetSumOfAllValidMCHits(myIdealTrack->GetPointerToLinks());              //get the number of hits which should be found

                if (nMCHits == sortedMCTracks[0].GetWeight()){
                        fMapTrackQualification[sortedMCTracks[0].GetIndex()] = qualityNumbers::kFullyFound;
                        fMCIdTrackId[mostProbableTrack] = trackId;
                } else {
                        if (fMapTrackQualification[sortedMCTracks[0].GetIndex()] != qualityNumbers::kFullyFound){
                                fMapTrackQualification[sortedMCTracks[0].GetIndex()] = qualityNumbers::kPartiallyFound;
                                fMCIdTrackId[mostProbableTrack] = trackId;
                        }
                }
        } else {
                Int_t highestCount = sortedMCTracks[0].GetWeight();
                mostProbableTrack = sortedMCTracks[0].GetIndex();
                Int_t allCounts = 0;
                for (size_t i = 0; i < sortedMCTracks.size(); i++){
                        allCounts += sortedMCTracks[i].GetWeight();
//                      if (trackInfo["AllHits"].GetLink(i).GetWeight() > highestCount){
//                              highestCount = trackInfo["AllHits"].GetLink(i).GetWeight();
//                              mostProbableTrack = trackInfo["AllHits"].GetLink(i).GetIndex();
//                      }
                }


                if ((Double_t)highestCount/(Double_t)allCounts > 0.7){
                        if (fMapTrackQualification[mostProbableTrack] != qualityNumbers::kFullyFound
                                        && fMapTrackQualification[mostProbableTrack] != qualityNumbers::kPartiallyFound){
                                fMapTrackQualification[mostProbableTrack] = qualityNumbers::kSpuriousFound;
                                fMCIdTrackId[mostProbableTrack] = trackId;
                        }
                }
                else {
                        fNGhosts++;
                }
        }
        if (fVerbose > 0){
                for (size_t j = 0; j < sortedMCTracks.size(); j++){
                        FairLink myLink = sortedMCTracks[j];
            if (fMCIdIdealTrackId.count(myLink.GetIndex()) > 0){
                PndTrackCand* myIdealTrack = ((PndTrack*)fIdealTrack->At(fMCIdIdealTrackId[myLink.GetIndex()]))->GetTrackCandPtr();
                if (fVerbose > 1) std::cout << "Ideal Tracking: Track " << myLink.GetIndex() << ": ";
                if (fVerbose > 1) PrintTrackDataSummary(*myIdealTrack->GetPointerToLinks());
            } else {
                std::cout << "Ideal Tracking: Track " << myLink.GetIndex() << " not available" << std::endl;
            }

                }
//              std::cout << "MostProbableTrack: " << mostProbableTrack << " Quality: " << fMapTrackQualification[mostProbableTrack] << std::endl;
//              std::cout << std::endl;
        }

        return mostProbableTrack;
}

void PndTrackingQA::CalcEfficiencies ( Int_t  mostProbableTrack, std::map< TString, FairMultiLinkedData > &  trackInfo  )

privatevirtual

Definition at line 371 of file PndTrackingQA.cxx.

References Double_t, fBranchNames, fIdealTrack, fMapEfficiencies, fMCIdIdealTrackId, fVerbose, GetNIdealHits(), and i.

Referenced by AnalyseEvent().

{
        if (mostProbableTrack < 0) return;
        if (fVerbose > 2)
                std::cout << "PndTrackingQA::CalcEfficiencies() for mostProbableTrack " << mostProbableTrack
                                        <<  " count " << fMCIdIdealTrackId.count(mostProbableTrack) << std::endl;
        for (size_t branchIndex = 0; branchIndex < fBranchNames.size(); branchIndex++){
                if (fMCIdIdealTrackId.count(mostProbableTrack) > 0){
                        PndTrackCand* trackCand = ((PndTrack*)fIdealTrack->At(fMCIdIdealTrackId[mostProbableTrack]))->GetTrackCandPtr();
                        if (trackCand == 0) return;
                        Int_t nMcHits = GetNIdealHits(*trackCand->GetPointerToLinks(), fBranchNames[branchIndex]);
                        FairMultiLinkedData foundHits = trackInfo[fBranchNames[branchIndex]];
                        for (int i = 0; i < foundHits.GetNLinks(); i++){
                                if (foundHits.GetLink(i).GetIndex() == mostProbableTrack){
                                        Double_t nFoundHits = foundHits.GetLink(i).GetWeight();
                                        if ((nFoundHits/nMcHits) > fMapEfficiencies[mostProbableTrack][fBranchNames[branchIndex]].first){
                                                std::pair<Double_t, Int_t> result(nFoundHits/nMcHits, nMcHits);
                                                fMapEfficiencies[mostProbableTrack][fBranchNames[branchIndex]]=result;
                                        }
                                }
                        }
                }
        }
}

void PndTrackingQA::FillMapTrackQualifikation ( )

privatevirtual

Definition at line 278 of file PndTrackingQA.cxx.

References Bool_t, fIdealTrack, fMapTrackMCStatus, fMapTrackQualification, fMCIdIdealTrackId, fMCTrack, fPossibleTrack, fVerbose, PndTrackCand::getMcTrackId(), PndMCTrack::GetMotherID(), GetNIdealHits(), i, qualityNumbers::kAtLeastThreePrim, qualityNumbers::kAtLeastThreeSec, qualityNumbers::kLessThanThreePrim, qualityNumbers::kPossiblePrim, qualityNumbers::kPossibleSec, and nHits.

Referenced by AnalyseEvent().

{
        fMapTrackQualification.clear();
        fMapTrackMCStatus.clear();
        fMCIdIdealTrackId.clear();
//      std::cout << " fIdealTrack.size() " << fIdealTrack->GetEntriesFast() << std::endl;
        for (int i = 0; i < fIdealTrack->GetEntriesFast(); i++){
                PndTrackCand* idealTrackCand = ((PndTrack*)fIdealTrack->At(i))->GetTrackCandPtr();
//              std::cout << i << " : PndTrackingQA::FillMapTrackQualifikation: " << *idealTrackCand << std::endl;

                PndMCTrack* mcTrack = (PndMCTrack*)fMCTrack->At(idealTrackCand->getMcTrackId());


                fMCIdIdealTrackId[idealTrackCand->getMcTrackId()] = i;
                Bool_t primaryTrack = (mcTrack->GetMotherID() < 0);
                Bool_t atLeastThreeHits = kFALSE;
                Int_t nHits = 0;
//                      for (int branchIndex = 0; branchIndex < fBranchNames.size(); branchIndex++){
//                              TString branchName = fBranchNames[branchIndex];
//                              nHits += GetNIdealHits(i, branchName);
//                      }
                nHits += GetNIdealHits(*(idealTrackCand->GetPointerToLinks()), "MVDHitsPixel");
                nHits += GetNIdealHits(*(idealTrackCand->GetPointerToLinks()), "MVDHitsStrip");
                nHits += GetNIdealHits(*(idealTrackCand->GetPointerToLinks()), "STTHit");
                nHits += GetNIdealHits(*(idealTrackCand->GetPointerToLinks()), "GEMHit");
                nHits += GetNIdealHits(*(idealTrackCand->GetPointerToLinks()), "FTSHit");
                //std::cout << "FillMapTrackQualifikation: NHits: " << nHits << std::endl;

                if (nHits > 2) atLeastThreeHits = kTRUE;

                if (atLeastThreeHits) {
                        if (primaryTrack) {
                                fMapTrackQualification[idealTrackCand->getMcTrackId()] = qualityNumbers::kAtLeastThreePrim;
                        } else {
                                fMapTrackQualification[idealTrackCand->getMcTrackId()] = qualityNumbers::kAtLeastThreeSec;
                        }
                //      std::cout << "AtLeastThreeHits: Track "<< i << " status: " << fMapTrackQualification[i] << std::endl;
                }

                else if (primaryTrack){  //No hits for primary track in tracking detectors
                        fMapTrackQualification[idealTrackCand->getMcTrackId()] = qualityNumbers::kLessThanThreePrim;
                }

                PndTrackCand* entry = ((PndTrack*)fIdealTrack->At(i))->GetTrackCandPtr();
                if ((*fPossibleTrack)((FairMultiLinkedData*)entry->GetPointerToLinks(), primaryTrack))
                {
                        if (primaryTrack) {
                                fMapTrackQualification[idealTrackCand->getMcTrackId()] = qualityNumbers::kPossiblePrim;
                        } else {
                                fMapTrackQualification[idealTrackCand->getMcTrackId()] = qualityNumbers::kPossibleSec;
                        }
                }
        }
        if (fVerbose > 1){
                std::cout << "-I- PndMCTestPatternRecoQuality::FillMapTrackQualifikation:" << std::endl;
//              PrintTrackQualityMap();
        }
        fMapTrackMCStatus = fMapTrackQualification;
}

std::map<Int_t, std::map<TString, std::pair<Double_t, Int_t > > > PndTrackingQA::GetEfficiencies ( )

inline

Definition at line 112 of file PndTrackingQA.h.

References fMapEfficiencies.

Referenced by PndTrackingQATask::Exec().

{return fMapEfficiencies;}

Int_t PndTrackingQA::GetIdealTrackIdFromMCTrackId ( int  mctrackid )

inline

Definition at line 137 of file PndTrackingQA.h.

References fMCIdIdealTrackId.

Referenced by PndTrackingQATask::Exec().

                                                          {
                if (fMCIdIdealTrackId.count(mctrackid) == 0) return -1;
                return fMCIdIdealTrackId[mctrackid];
        }

Int_t PndTrackingQA::GetIdealTrackIdFromRecoTrackId ( int  trackid )

inline

Definition at line 141 of file PndTrackingQA.h.

References fMCIdIdealTrackId, and fTrackIdMCId.

Referenced by PndTrackingQATask::Exec().

                                                          { 
          int mctrackid = fTrackIdMCId[trackid];
          if (fMCIdIdealTrackId.count(mctrackid) == 0) return -1;
          return fMCIdIdealTrackId[mctrackid];
        }

FairMultiLinkedData PndTrackingQA::GetMCInfoForBranch ( TString  branchName, PndTrackCand *  trackCand  )

private

returns which MCTracks and how often (marked by a FairLink) they were seen by the hits of a PndTrackCand

Definition at line 160 of file PndTrackingQA.cxx.

References ioman.

Referenced by AnalyseTrackCand().

{
        FairMultiLinkedData result;
        result.SetInsertHistory(kFALSE);
        //std::cout << "GetMCInforForBranch: " << branchName << std::endl;
        FairMultiLinkedData linksOfType = trackCand->GetLinksWithType(ioman->GetBranchId(branchName));
//      std::cout << "GetMCInforForBranch: LinksOfType " << branchName << " : " << linksOfType << std::endl;

        for (int j = 0; j < linksOfType.GetNLinks(); j++){
                FairMultiLinkedData_Interface* linkData = (FairMultiLinkedData_Interface*)FairRootManager::Instance()->GetCloneOfLinkData(linksOfType.GetLink(j));
                //std::cout << "CloneOfLinkData: " << *linkData << std::endl;
                if (linkData != 0){
                        FairMultiLinkedData linkDataType = linkData->GetLinksWithType(FairRootManager::Instance()->GetBranchId("MCTrack"));
                        linkDataType.SetAllWeights(1.);
                        result.AddLinks(linkDataType);
                        linkData->Delete();
                }
        }
        return result;
}

std::map<Int_t, Int_t> PndTrackingQA::GetMCTrackFound ( )

inline

Definition at line 109 of file PndTrackingQA.h.

References fMCTrackFound.

Referenced by PndTrackingQATask::Exec().

{return fMCTrackFound;}

Int_t PndTrackingQA::GetNGhosts ( )

inline

Definition at line 123 of file PndTrackingQA.h.

References fNGhosts.

Referenced by PndTrackingQATask::Exec().

{return fNGhosts;}

Int_t PndTrackingQA::GetNIdealHits	(	FairMultiLinkedData &	track,
		TString	branchName
	)

Definition at line 404 of file PndTrackingQA.cxx.

References ioman.

Referenced by CalcEfficiencies(), FillMapTrackQualifikation(), GetRecoInfoFromRecoTrack(), PrintTrackDataSummary(), and PrintTrackDataSummaryCompare().

{
        Int_t numberGemHits = 0;
        if (branchName == "GEMHit"){
                numberGemHits = track.GetLinksWithType(ioman->GetBranchId("GEMPoint")).GetNLinks();
                return numberGemHits;
        }
        return track.GetLinksWithType(ioman->GetBranchId(branchName)).GetNLinks();
}

std::map<Int_t, TVector3> PndTrackingQA::GetP ( )

inline

Definition at line 114 of file PndTrackingQA.h.

References fMapP.

Referenced by PndTrackingQATask::Exec().

{return fMapP;}

std::map<Int_t, Double_t> PndTrackingQA::GetPl ( )

inline

Definition at line 118 of file PndTrackingQA.h.

References fMapPl.

{return fMapPl;}

std::map<Int_t, Double_t> PndTrackingQA::GetPlResolution ( )

inline

Definition at line 117 of file PndTrackingQA.h.

References fMapPlResolution.

Referenced by PndTrackingQATask::Exec().

{return fMapPlResolution;}

std::map<Int_t, Double_t> PndTrackingQA::GetPlResolutionRel ( )

inline

Definition at line 121 of file PndTrackingQA.h.

References fMapPlResolutionRel.

Referenced by PndTrackingQATask::Exec().

{return fMapPlResolutionRel;}

std::map<Int_t, Double_t> PndTrackingQA::GetPResolution ( )

inline

Definition at line 113 of file PndTrackingQA.h.

References fMapPResolution.

Referenced by PndTrackingQATask::Exec().

{return fMapPResolution;}

std::map<Int_t, Double_t> PndTrackingQA::GetPResolutionRel ( )

inline

Definition at line 119 of file PndTrackingQA.h.

References fMapPResolutionRel.

Referenced by PndTrackingQATask::Exec().

{return fMapPResolutionRel;}

std::map<Int_t, Double_t> PndTrackingQA::GetPt ( )

inline

Definition at line 116 of file PndTrackingQA.h.

References fMapPt.

{return fMapPt;}

std::map<Int_t, Double_t> PndTrackingQA::GetPtResolution ( )

inline

Definition at line 115 of file PndTrackingQA.h.

References fMapPtResolution.

Referenced by PndTrackingQATask::Exec().

{return fMapPtResolution;}

std::map<Int_t, Double_t> PndTrackingQA::GetPtResolutionRel ( )

inline

Definition at line 120 of file PndTrackingQA.h.

References fMapPtResolutionRel.

Referenced by PndTrackingQATask::Exec().

{return fMapPtResolutionRel;}

PndTrackingQualityRecoInfo PndTrackingQA::GetRecoInfoFromRecoTrack	(	Int_t	trackId,
		Int_t	mctrackId
	)

Definition at line 503 of file PndTrackingQA.cxx.

References Bool_t, fBranchNames, fIdealTrack, fMCIdIdealTrackId, fTrack, fVerbose, PndTrack::GetFlag(), GetNIdealHits(), PndTrack::GetParamFirst(), PndTrack::GetParamLast(), PndTrack::GetTrackCandPtr(), hit(), ioman, nHits, PndTrackingQualityRecoInfo::SetCharge(), PndTrackingQualityRecoInfo::SetFlag(), PndTrackingQualityRecoInfo::SetMCTrackID(), PndTrackingQualityRecoInfo::SetMomentumFirst(), PndTrackingQualityRecoInfo::SetMomentumLast(), PndTrackingQualityRecoInfo::SetNofFtsFakeHits(), PndTrackingQualityRecoInfo::SetNofFtsMissingHits(), PndTrackingQualityRecoInfo::SetNofFtsTrueHits(), PndTrackingQualityRecoInfo::SetNofGemFakeHits(), PndTrackingQualityRecoInfo::SetNofGemMissingHits(), PndTrackingQualityRecoInfo::SetNofGemTrueHits(), PndTrackingQualityRecoInfo::SetNofMvdPixelFakeHits(), PndTrackingQualityRecoInfo::SetNofMvdPixelMissingHits(), PndTrackingQualityRecoInfo::SetNofMvdPixelTrueHits(), PndTrackingQualityRecoInfo::SetNofMvdStripFakeHits(), PndTrackingQualityRecoInfo::SetNofMvdStripMissingHits(), PndTrackingQualityRecoInfo::SetNofMvdStripTrueHits(), PndTrackingQualityRecoInfo::SetNofSttFakeHits(), PndTrackingQualityRecoInfo::SetNofSttMissingHits(), PndTrackingQualityRecoInfo::SetNofSttTrueHits(), PndTrackingQualityRecoInfo::SetPositionFirst(), PndTrackingQualityRecoInfo::SetPositionLast(), and track.

Referenced by AnalyseEvent().

{
  PndTrackingQualityRecoInfo recoinfo(trackId);

  // CHECK this can be modified in the future, for now it is ok
  // mvd pix / mvd str / stt paral / stt skew / gem

  if (fVerbose > 2)
          std::cout << "PndTrackingQA::GetRecoInfoFromRecoTrack()" << std::endl;

    std::map<int, int> noftruehits;
        std::map<int, int> noffakehits;
        std::map<int, int> nofmissinghits;

        for (size_t branchIndex = 0; branchIndex < fBranchNames.size();
                        branchIndex++) {
                noftruehits.clear();
                noffakehits.clear();
                nofmissinghits.clear();

                // get the reco track...
                PndTrack *track = (PndTrack*) fTrack->At(trackId);
                // .. and the track cand
                PndTrackCand* trackcand = track->GetTrackCandPtr();

                recoinfo.SetPositionFirst(track->GetParamFirst().GetPosition());
                recoinfo.SetMomentumFirst(track->GetParamFirst().GetMomentum());

                recoinfo.SetPositionLast(track->GetParamLast().GetPosition());
                recoinfo.SetMomentumLast(track->GetParamLast().GetMomentum());

                recoinfo.SetCharge(track->GetParamFirst().GetQ());
                recoinfo.SetFlag(track->GetFlag());

                // get links associated to the reco track
                FairMultiLinkedData ptrlink = *trackcand->GetPointerToLinks();
                // get links corresponding to the hits of the specific detector
                FairMultiLinkedData links = ptrlink.GetLinksWithType(
                                ioman->GetBranchId(fBranchNames[branchIndex]));
                // get their number
                Int_t nHits = links.GetNLinks();
                if (fVerbose > 2){
                        if (nHits > 0)
                                std::cout << "----- reco track " << trackId << " (mc track " << mctrackId<< ") has " << nHits << " from " << fBranchNames[branchIndex] << std::endl;
                }
                // get mc track info from each hit
                for (int ihit = 0; ihit < nHits; ihit++) {
                        FairLink link = links.GetLink(ihit);
                        int assomctrack = -1;
                        // std::cout << "ihit " << ihit << " " << link.GetIndex() << " " << link.GetType() << " " << link.GetWeight() << std::endl;
                        FairHit * hit = (FairHit*) links.GetData(link);
                        if (!hit) {
                                std::cout << "ihit " << ihit << " " << link
                                                << " is FAKE" << std::endl;
                                //    std::cout << "No Obj Hit" << std::endl;

                                //
                                if (noffakehits.count(branchIndex) > 0)
                                        noffakehits[branchIndex]++;
                                else
                                        noffakehits[branchIndex] = 1; // if not there
                                continue;
                        }

                        // get links of the hit
                        FairMultiLinkedData hitlink = *hit->GetPointerToLinks();
                        // get the links corresponding to the mc track associated to the hit
                        FairMultiLinkedData mclinks = hitlink.GetLinksWithType(
                                        ioman->GetBranchId("MCTrack"));
                        //        std::cout << "hit " << ihit  << " belongs to " << mclinks.GetNLinks() << " mc tracks" << std::endl;
                        Bool_t isgood = kFALSE;
                        FairMultiLinkedData mvdstrhits = links.GetLinksWithType(
                                        FairRootManager::Instance()->GetBranchId("MVDHitsStrip"));
                        FairMultiLinkedData gemhits = links.GetLinksWithType(
                                        FairRootManager::Instance()->GetBranchId("GEMHit"));
                        if ((gemhits.GetNLinks() > 0 || mvdstrhits.GetNLinks() > 0) && mclinks.GetNLinks() > 1) {
                                isgood = kFALSE;
                        } else {
                                for (int imctrk = 0; imctrk < mclinks.GetNLinks(); imctrk++) {
                                        FairLink mclink = mclinks.GetLink(imctrk);
                                        assomctrack = mclink.GetIndex();
                                        //           std::cout << "imctrk " << imctrk << " " << mclink.GetIndex() << " " << mclink.GetType() << " " << mclink.GetWeight() << std::endl;
//        std::cout << "ihit " << ihit << " (hitid " << link.GetIndex() << ") belongs to MC track " << assomctrack << std::endl;
                                        if (assomctrack == mctrackId)
                                                isgood = kTRUE;
                                }
                        }

                        // if true
                        if (isgood == kTRUE) {
                                // if true and already there
                                if (noftruehits.count(branchIndex) > 0)
                                        noftruehits[branchIndex]++;
                                else
                                        noftruehits[branchIndex] = 1; // if not there
                        } else { // if not
                                if (noffakehits.count(branchIndex) > 0)
                                        noffakehits[branchIndex]++;
                                else
                                        noffakehits[branchIndex] = 1; // if not there
                        }

                }

                // retrieve the ideal track cand associated
                if (fMCIdIdealTrackId.count(mctrackId) > 0) {
                        int idealtrackid = fMCIdIdealTrackId[mctrackId];
                        PndTrack *idealtrack = (PndTrack*) fIdealTrack->At(idealtrackid);
                        PndTrackCand* idealtrackcand = idealtrack->GetTrackCandPtr();

                        Int_t nMcHits = GetNIdealHits(*idealtrackcand->GetPointerToLinks(),
                                        fBranchNames[branchIndex]);

                        nofmissinghits[branchIndex] = nMcHits - noftruehits[branchIndex];

//      std::cout << "**** ideal track " << idealtrackid << " has " << nMcHits << " from " << fBranchNames[branchIndex] << std::endl;

                }

//    std::cout << "===> BRANCH " << fBranchNames[branchIndex] << " of track " << trackId << " (mc track " << mctrackId << ") has " << noftruehits[branchIndex] << " true, " << noffakehits[branchIndex] << " fake and " << nofmissinghits[branchIndex] << " missing hits" << std::endl;

                if (fBranchNames[branchIndex] == "MVDHitsPixel") {
                        recoinfo.SetNofMvdPixelTrueHits(noftruehits[branchIndex]);
                        recoinfo.SetNofMvdPixelFakeHits(noffakehits[branchIndex]);
                        recoinfo.SetNofMvdPixelMissingHits(nofmissinghits[branchIndex]);
                } else if (fBranchNames[branchIndex] == "MVDHitsStrip") {
                        recoinfo.SetNofMvdStripTrueHits(noftruehits[branchIndex]);
                        recoinfo.SetNofMvdStripFakeHits(noffakehits[branchIndex]);
                        recoinfo.SetNofMvdStripMissingHits(nofmissinghits[branchIndex]);
                } else if (fBranchNames[branchIndex] == "STTHit") {
                        recoinfo.SetNofSttTrueHits(noftruehits[branchIndex]);
                        recoinfo.SetNofSttFakeHits(noffakehits[branchIndex]);
                        recoinfo.SetNofSttMissingHits(nofmissinghits[branchIndex]);
                } else if (fBranchNames[branchIndex] == "GEMHit") {
                        recoinfo.SetNofGemTrueHits(noftruehits[branchIndex]);
                        recoinfo.SetNofGemFakeHits(noffakehits[branchIndex]);
                        recoinfo.SetNofGemMissingHits(nofmissinghits[branchIndex]);
                } else if (fBranchNames[branchIndex] == "FTSHit") {
                        recoinfo.SetNofFtsTrueHits(noftruehits[branchIndex]);
                        recoinfo.SetNofFtsFakeHits(noffakehits[branchIndex]);
                        recoinfo.SetNofFtsMissingHits(nofmissinghits[branchIndex]);
                }

  }

  recoinfo.SetMCTrackID(mctrackId);
  return recoinfo;
}

Int_t PndTrackingQA::GetSumOfAllValidMCHits ( FairMultiLinkedData *  trackData )

private

Definition at line 356 of file PndTrackingQA.cxx.

References fBranchNames, and ioman.

Referenced by AnalyseTrackInfo().

{
        Int_t result = 0;
        for (size_t branchIndex = 0; branchIndex < fBranchNames.size(); branchIndex++){
                if (fBranchNames[branchIndex] == "GEMHit"){
                        FairMultiLinkedData gemHits = trackData->GetLinksWithType(ioman->GetBranchId("GEMPoint"));
                        result += gemHits.GetNLinks();
                } else {
                        result += trackData->GetLinksWithType(ioman->GetBranchId(fBranchNames[branchIndex])).GetNLinks();
                }
        }
        return result;
}

std::map<Int_t, Int_t> PndTrackingQA::GetTrackIdMCId ( )

inline

Definition at line 122 of file PndTrackingQA.h.

References fTrackIdMCId.

{return fTrackIdMCId;}

std::map<Int_t, Int_t> PndTrackingQA::GetTrackMCStatus ( )

inline

Definition at line 111 of file PndTrackingQA.h.

References fMapTrackMCStatus.

Referenced by PndTrackingQATask::Exec().

{return fMapTrackMCStatus;}

std::map<Int_t, Int_t> PndTrackingQA::GetTrackQualification ( )

inline

Definition at line 110 of file PndTrackingQA.h.

References fMapTrackQualification.

Referenced by PndTrackingQATask::Exec().

{return fMapTrackQualification;}

void PndTrackingQA::Init ( )

virtual

Definition at line 53 of file PndTrackingQA.cxx.

References AddHitsBranchName(), fBranchNames, fIdealTrack, fIdealTrackName, fMCTrack, fPossibleTrack, fTrack, fTrackBranchName, fVerbose, ioman, and PndTrackFunctor::Print().

Referenced by PndTrackingQATask::Exec().

{
        ioman = FairRootManager::Instance();
        if (!ioman) {
                std::cout << "-E- PndTrackingQualityTask::Init: "
                                << "RootManager not instantiated!" << std::endl;
                return;
        }

        fTrack = (TClonesArray*) ioman->GetObject(fTrackBranchName);
        fMCTrack = (TClonesArray*) ioman->GetObject("MCTrack");
        fIdealTrack = (TClonesArray*) ioman->GetObject(fIdealTrackName);


        if (fBranchNames.size() == 0){
                AddHitsBranchName("MVDHitsPixel");
                AddHitsBranchName("MVDHitsStrip");
                AddHitsBranchName("STTHit");
                AddHitsBranchName("GEMHit");
                AddHitsBranchName("FTSHit");

        //      if (FairRootManager::Instance()->GetBranchId("CorrectedSkewedHits")  > 0){
        //              AddHitsBranchName("CorrectedSkewedHits");
        //      }
        }
        if (fVerbose > 0){
                std::cout << "-I- PndTrackingQA::Init: PossibleTrackFunctor: ";
                fPossibleTrack->Print();
        }
}

Bool_t PndTrackingQA::IsBetterTrackExisting ( Int_t &  mcIndex, int  quality  )

private

Definition at line 495 of file PndTrackingQA.cxx.

References fMapTrackQualification.

{
        if (fMapTrackQualification.count(mcIndex) == 1){
                if (fMapTrackQualification[mcIndex] > 0 && fMapTrackQualification[mcIndex] > quality) return true;
        }
        return false;
}

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

Definition at line 414 of file PndTrackingQA.cxx.

References fBranchNames, GetNIdealHits(), ioman, and TString.

Referenced by AnalyseTrackInfo(), and PrintTrackQualityMap().

{
        if (detailedInfo == kTRUE) std::cout << std::endl;
        for (size_t branchIndex = 0; branchIndex < fBranchNames.size(); branchIndex++){
                TString branchName = fBranchNames[branchIndex];
                if (GetNIdealHits(trackData, branchName) > 0){
                        std::cout << branchName << " " << GetNIdealHits(trackData, branchName);
                        if (detailedInfo == kTRUE){
                                std::cout << " : ";
                                if (trackData.GetLinksWithType(ioman->GetBranchId(branchName)).GetNLinks() > 0)
                                         std::cout << trackData.GetLinksWithType(ioman->GetBranchId(branchName));
                                std::cout << std::endl;
                        } else {
                                std::cout << " | ";
                        }
                }
        }
        std::cout << std::endl;
}

void PndTrackingQA::PrintTrackDataSummaryCompare	(	FairMultiLinkedData &	recoTrackData,
		FairMultiLinkedData &	idealTrackData
	)

Definition at line 434 of file PndTrackingQA.cxx.

References fBranchNames, GetNIdealHits(), and TString.

Referenced by PrintTrackQualityMap().

{
        for (size_t branchIndex = 0; branchIndex < fBranchNames.size(); branchIndex++){
                TString branchName = fBranchNames[branchIndex];
                std::cout << branchName << " " << GetNIdealHits(recoTrackData, branchName);
                std::cout << "/" << GetNIdealHits(idealTrackData, branchName);
                        std::cout << " | ";
        }
        std::cout << std::endl;
}

void PndTrackingQA::PrintTrackInfo

(

std::map< TString, FairMultiLinkedData >

info

)

Definition at line 481 of file PndTrackingQA.cxx.

References i.

Referenced by AnalyseTrackCand().

{
        std::cout << "TrackInfo: (MC-ID/NHits) : ";
        for (std::map<TString, FairMultiLinkedData>::iterator iter = info.begin(); iter != info.end(); iter++){
                std::cout << iter->first;
                for (int i = 0; i < iter->second.GetNLinks(); i++){
                        std::cout << " : (" << iter->second.GetLink(i).GetIndex() << "/" << iter->second.GetLink(i).GetWeight() << ")";
                }
                std::cout << " || ";
        }
        std::cout << std::endl;
}

void PndTrackingQA::PrintTrackMCStatusMap

(

)

Definition at line 470 of file PndTrackingQA.cxx.

References fMapTrackMCStatus, fMCTrackFound, and qualityNumbers::QualityNumberToString().

{
        std::cout << "PrintTrackMCStatusMap: " << std::endl;
        for (std::map<Int_t, Int_t>::iterator iter = fMapTrackMCStatus.begin(); iter != fMapTrackMCStatus.end(); iter++){
                std::cout << "TrackID: " << iter->first << " Quality: "  << qualityNumbers::QualityNumberToString(iter->second) << " Found: " << fMCTrackFound[iter->first];
                std::cout << std::endl;
        }
        std::cout << std::endl;
}

void PndTrackingQA::PrintTrackQualityMap

(

Bool_t

detailedInfo = kFALSE

)

The description of the quality map IDs is now located a but further up, at struct qualityNumbers

Definition at line 446 of file PndTrackingQA.cxx.

References fIdealTrack, fMapTrackMCStatus, fMapTrackQualification, fMCIdIdealTrackId, fMCIdTrackId, fMCTrackFound, fTrack, PrintTrackDataSummary(), PrintTrackDataSummaryCompare(), and qualityNumbers::QualityNumberToString().

Referenced by AnalyseEvent(), and PndTrackingQATask::Exec().

{
        for (std::map<Int_t, Int_t>::iterator iter = fMapTrackQualification.begin(); iter != fMapTrackQualification.end(); iter++){
                std::cout << "TrackID: " << iter->first << " MCQuality: "  << qualityNumbers::QualityNumberToString(fMapTrackMCStatus[iter->first]) << " Quality: ";
                if (iter->second < 0)
                        std::cout << " NOT FOUND ";
                else
                        std::cout << qualityNumbers::QualityNumberToString(iter->second);
                std::cout << " NFound: " << fMCTrackFound[iter->first];
                std::cout << " MCData: ";
                if (fMCIdIdealTrackId.count(iter->first) > 0){
                        PndTrackCand* idealTrackCand = ((PndTrack*)fIdealTrack->At(fMCIdIdealTrackId[iter->first]))->GetTrackCandPtr();
                        if (iter->second < 0)
                                PrintTrackDataSummary(*idealTrackCand->GetPointerToLinks(), detailedInfo);
                        else {
                                PndTrackCand* recoTrackCand = ((PndTrack*)fTrack->At(fMCIdTrackId[iter->first]))->GetTrackCandPtr();
                                if (recoTrackCand != 0 && idealTrackCand != 0)
                                        PrintTrackDataSummaryCompare(*recoTrackCand->GetPointerToLinks(), *idealTrackCand->GetPointerToLinks());
                        }
                }
        }
        std::cout << std::endl;
}

void PndTrackingQA::SetHitsBranchNames ( std::vector< TString >  names )

inline

Definition at line 103 of file PndTrackingQA.h.

References fBranchNames.

Referenced by PndTrackingQATask::Exec().

{ fBranchNames = names;}

void PndTrackingQA::SetVerbose ( Int_t  val )

inline

Definition at line 99 of file PndTrackingQA.h.

References fVerbose, and val.

Referenced by PndTrackingQATask::Exec().

{fVerbose = val;}

Member Data Documentation

std::vector<TString> PndTrackingQA::fBranchNames

private

! branch names of hits taken into account in the analysis (e.g. MVDHitsPixel, STTHit, ...)

Definition at line 176 of file PndTrackingQA.h.

Referenced by AddHitsBranchName(), AnalyseTrackCand(), CalcEfficiencies(), GetRecoInfoFromRecoTrack(), GetSumOfAllValidMCHits(), Init(), PrintTrackDataSummary(), PrintTrackDataSummaryCompare(), and SetHitsBranchNames().

Bool_t PndTrackingQA::fCleanFunctor

private

Definition at line 170 of file PndTrackingQA.h.

Referenced by PndTrackingQA(), and ~PndTrackingQA().

TClonesArray* PndTrackingQA::fIdealTrack

private

Definition at line 200 of file PndTrackingQA.h.

Referenced by AnalyseTrackInfo(), CalcEfficiencies(), FillMapTrackQualifikation(), GetRecoInfoFromRecoTrack(), Init(), and PrintTrackQualityMap().

TClonesArray* PndTrackingQA::fIdealTrackCand

private

Definition at line 201 of file PndTrackingQA.h.

TString PndTrackingQA::fIdealTrackName

private

Definition at line 166 of file PndTrackingQA.h.

Referenced by Init().

std::map<Int_t, std::map<TString, std::pair<Double_t, Int_t> > > PndTrackingQA::fMapEfficiencies

private

! MostProbable TrackId, BranchName, Efficiency (#FoundHits / #MCHits), #MCHits

Definition at line 187 of file PndTrackingQA.h.

Referenced by CalcEfficiencies(), and GetEfficiencies().

std::map<Int_t, TVector3> PndTrackingQA::fMapP

private

Definition at line 189 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), and GetP().

std::map<Int_t, Double_t> PndTrackingQA::fMapPl

private

Definition at line 195 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), and GetPl().

std::map<Int_t, Double_t> PndTrackingQA::fMapPlResolution

private

Definition at line 194 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), and GetPlResolution().

std::map<Int_t, Double_t> PndTrackingQA::fMapPlResolutionRel

private

Definition at line 196 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), and GetPlResolutionRel().

std::map<Int_t, Double_t> PndTrackingQA::fMapPResolution

private

Definition at line 188 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), and GetPResolution().

std::map<Int_t, Double_t> PndTrackingQA::fMapPResolutionRel

private

Definition at line 192 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), and GetPResolutionRel().

std::map<Int_t, Double_t> PndTrackingQA::fMapPt

private

Definition at line 191 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), and GetPt().

std::map<Int_t, Double_t> PndTrackingQA::fMapPtResolution

private

Definition at line 190 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), and GetPtResolution().

std::map<Int_t, Double_t> PndTrackingQA::fMapPtResolutionRel

private

Definition at line 193 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), and GetPtResolutionRel().

std::map<Int_t, Int_t> PndTrackingQA::fMapTrackMCStatus

private

! TrackId vs TrackStatus from MC

Definition at line 185 of file PndTrackingQA.h.

Referenced by FillMapTrackQualifikation(), GetTrackMCStatus(), PrintTrackMCStatusMap(), and PrintTrackQualityMap().

std::map<Int_t, Int_t> PndTrackingQA::fMapTrackQualification

private

! TrackId vs TrackStatus after analysis of track finding

Definition at line 186 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), AnalyseTrackInfo(), FillMapTrackQualifikation(), GetTrackQualification(), IsBetterTrackExisting(), and PrintTrackQualityMap().

std::map<Int_t, Int_t> PndTrackingQA::fMCIdIdealTrackId

private

! map between MC id and ideal track id

Definition at line 179 of file PndTrackingQA.h.

Referenced by AnalyseTrackInfo(), CalcEfficiencies(), FillMapTrackQualifikation(), GetIdealTrackIdFromMCTrackId(), GetIdealTrackIdFromRecoTrackId(), GetRecoInfoFromRecoTrack(), and PrintTrackQualityMap().

std::map<Int_t, Int_t> PndTrackingQA::fMCIdTrackId

private

! map between MC id and track id

Definition at line 178 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), AnalyseTrackInfo(), and PrintTrackQualityMap().

TClonesArray* PndTrackingQA::fMCTrack

private

Definition at line 199 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), FillMapTrackQualifikation(), and Init().

std::map<Int_t, Int_t> PndTrackingQA::fMCTrackFound

private

! How often was a MC Track (key) found

Definition at line 181 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), GetMCTrackFound(), PrintTrackMCStatusMap(), and PrintTrackQualityMap().

Int_t PndTrackingQA::fNGhosts

private

Definition at line 171 of file PndTrackingQA.h.

Referenced by AnalyseTrackInfo(), and GetNGhosts().

Bool_t PndTrackingQA::fPndTrackOrTrackCand

private

Definition at line 167 of file PndTrackingQA.h.

Referenced by AnalyseEvent().

PndTrackFunctor* PndTrackingQA::fPossibleTrack

private

Definition at line 169 of file PndTrackingQA.h.

Referenced by FillMapTrackQualifikation(), Init(), PndTrackingQA(), and ~PndTrackingQA().

std::string PndTrackingQA::fPossibleTrackName

private

Definition at line 168 of file PndTrackingQA.h.

TClonesArray* PndTrackingQA::fTrack

private

Definition at line 198 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), GetRecoInfoFromRecoTrack(), Init(), and PrintTrackQualityMap().

TString PndTrackingQA::fTrackBranchName

private

Definition at line 165 of file PndTrackingQA.h.

Referenced by Init().

std::map<Int_t, Int_t> PndTrackingQA::fTrackIdMCId

private

! map between track id and most probable MC track id

Definition at line 177 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), GetIdealTrackIdFromRecoTrackId(), and GetTrackIdMCId().

Bool_t PndTrackingQA::fUseCorrectedSkewedHits

private

Definition at line 173 of file PndTrackingQA.h.

Int_t PndTrackingQA::fVerbose

private

Definition at line 174 of file PndTrackingQA.h.

Referenced by AnalyseEvent(), AnalyseTrackCand(), AnalyseTrackInfo(), CalcEfficiencies(), FillMapTrackQualifikation(), GetRecoInfoFromRecoTrack(), Init(), and SetVerbose().

FairRootManager* PndTrackingQA::ioman

private

Definition at line 163 of file PndTrackingQA.h.

Referenced by GetMCInfoForBranch(), GetNIdealHits(), GetRecoInfoFromRecoTrack(), GetSumOfAllValidMCHits(), Init(), and PrintTrackDataSummary().

---

The documentation for this class was generated from the following files:

• PndTrackingQA.h
• PndTrackingQA.cxx