PndTrackingQATask Class Reference

#include <PndTrackingQATask.h>

Inheritance diagram for PndTrackingQATask:

Public Member Functions
	PndTrackingQATask (TString trackBranchName, TString idealBranchName, Bool_t pndTrackData=kTRUE)
virtual	~PndTrackingQATask ()
virtual void	SetParContainers ()
virtual InitStatus	Init ()
virtual void	Exec (Option_t *opt)
virtual void	Finish ()
void	SetIdealTrackBranchName (TString name)
void	SetTrackBranchName (TString name, Bool_t pndTrackData=kTRUE)
	Sets the branch name of the track data which should be analyzed. More...
void	AddHitsBranchName (TString name)
	Adds branch names of detector data which should be taken into account in the analysis. More...
void	SetOutputMCInfoBranchName (TString name)
void	SetOutputRecoInfoBranchName (TString name)
void	SetFunctorName (TString name)
void	SetFunctor ()

Private Member Functions
virtual void	FillQualyHisto (std::map< Int_t, Int_t > trackQualifikation, Int_t nGhosts)
virtual void	FillMCStatus (std::map< Int_t, Int_t > trackMCStatus)
virtual void	FillEfficiencies (std::map< Int_t, std::map< TString, std::pair< Double_t, Int_t > > > efficiencies)
virtual void	MapToHist (std::map< Int_t, Double_t >, TH1 *)
virtual void	SetQualyHisto (TH1 *histo, Bool_t relative, Int_t base=1)
virtual Int_t	GetSumOfAllValidMCHits (FairMultiLinkedData *trackData)
void	AssociateRecoTracksToMCTracks ()
PndTrackingQualityMCInfo	GetMCInfoFromIdealTrack (PndTrack *idealtrack)
Int_t	GetMCInfoIdFromIdealTrackId (int idealtrackid)
void	InitializeHistograms ()
void	LabelQualyHistogram (TH1 *)
void	ColorHistogram ()
void	Register ()
void	Reset ()
	ClassDef (PndTrackingQATask, 1)

Private Attributes
const TString	fHypoName [5] ={"Electron","Muon","Pion","Kaon","Proton"}
std::vector< TString >	fBranchNames
TString	fMCInfoBranchName
TString	fRecoInfoBranchName
std::map< TString, FairMultiLinkedData >	fMapLinkData
std::map< TString, TH2 * >	fMapEfficiencies
std::map< int, int >	fMCInfoIdIdealId
Int_t	fNGhosts
TClonesArray *	fTrack
TClonesArray *	fMCTrack
TClonesArray *	fTrackCand
TClonesArray *	fSttHitArray
TClonesArray *	fMCTrackInfo
TClonesArray *	fRecoTrackInfo
TClonesArray *	fIdealTrack
TClonesArray *	fSttTubeArray
FairRootManager *	ioman
std::map< Int_t, Int_t >	fMapTrackQualifikation
TString	fTrackBranchName
TString	fIdealTrackBranchName
Bool_t	fPndTrackOrTrackCand
PndGeoSttPar *	fSttParameters
TString	fPossibleTrackFunctorName
PndTrackFunctor *	fPossibleTrackFunctor
RhoTuple *	fTuple
TH1 *	fIdealTracksPerEvent
TH1 *	fIdealPHisto
TH1 *	fIdealPtHisto
TH1 *	fIdealPlHisto
TH1 *	fIdealPrimTracksPerEvent
TH1 *	fIdealSecTracksPerEvent
TH1 *	fPHisto
TH1 *	fPRelHisto
TH1 *	fPtHisto
TH1 *	fPtRelHisto
TH1 *	fPlHisto
TH1 *	fPlRelHisto
TH1 *	fQualyHisto
THStack *	fQualyStack
TH1 *	fQualyHisto_mc
TH1 *	fQualyHisto_neg
TH1 *	fQualyHisto_pos
TH1 *	fQualyHisto_all
TH1 *	fQualyHisto_rel_all
TH1 *	fQualyHisto_rel_possible
Int_t	fEventNr

Detailed Description

Definition at line 36 of file PndTrackingQATask.h.

Constructor & Destructor Documentation

PndTrackingQATask::PndTrackingQATask	(	TString	trackBranchName,
		TString	idealBranchName,
		Bool_t	pndTrackData = kTRUE
	)

Default constructor

The quality numbers, qualityNumbers, as used here are defined in PndTrackingQualityAnalysis.h

Definition at line 39 of file PndTrackingQATask.cxx.

                                                                                                          :
  FairTask("Creates PndMC test"), fMCInfoBranchName("MCTrackInfo"), fRecoInfoBranchName("RecoTrackInfo"), fTrackBranchName(trackBranchName), fIdealTrackBranchName(idealBranchName), fPndTrackOrTrackCand(pndTrackData), fEventNr(0) {
}

PndTrackingQATask::~PndTrackingQATask ( )

virtual

Destructor

Definition at line 46 of file PndTrackingQATask.cxx.

                                      {
}

Member Function Documentation

void PndTrackingQATask::AddHitsBranchName ( TString  name )

inline

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

Definition at line 64 of file PndTrackingQATask.h.

References fBranchNames.

Referenced by Init().

{ fBranchNames.push_back(name);}

void PndTrackingQATask::AssociateRecoTracksToMCTracks ( )

private

PndTrackingQualityRecoInfo PndTrackingQATask::GetRecoInfoFromRecoTrack(int recotrackid, PndTrack *track) {

PndTrackCand *trkcand = track->GetTrackCandPtr();

Int_t nofsttpoint = trkcand->GetNHitsDet(FairRootManager::Instance()->GetBranchId("STTHit")); Int_t nofmvdpixpoint = trkcand->GetNHitsDet(FairRootManager::Instance()->GetBranchId("MVDHitsPixel")); Int_t nofmvdstrpoint = trkcand->GetNHitsDet(FairRootManager::Instance()->GetBranchId("MVDHitsStrip")); int nofmvdpoint = nofmvdpixpoint + nofmvdstrpoint; Int_t nofgempoint = trkcand->GetNHitsDet(FairRootManager::Instance()->GetBranchId("GEMHit"));

int nofsttskewpoint = 0, nofsttparalpoint = 0; this loop counts skewed (–> parallel) STT/FTS hits for(Int_t ihit = 0; ihit < trkcand->GetNHits(); ihit++) { PndTrackCandHit candhit = trkcand->GetSortedHit(ihit); Int_t hitID = candhit.GetHitId(); Int_t detID = candhit.GetDetId();

if(detID != FairRootManager::Instance()->GetBranchId("STTHit") continue; PndSttHit stthit = (PndSttHit) fSttHitArray->At(hitID); Int_t tubeID = stthit->GetTubeID(); PndSttTube tube = (PndSttTube) fSttTubeArray->At(tubeID); if(tube->IsSkew()) nofsttskewpoint++; else nofsttparalpoint++; }

---

int mctrackid = trackid->GetCorrTrackID(); int noftruehits = trackid->GetMultTrackID();

int nofassomctracks = trackid->GetNCorrTrackId(); int noffakehits = 0; for(int itrk = 1; itrk < nofassomctracks; itrk++) { int noffake = trackid->GetMultTrackID(itrk); noffakehits += noffake; }

:...................: int noftruemvdpixhits = 0, noftruemvdstrhits = 0, noftruesttparalhits = 0, noftruesttskewhits = 0, noftruegemhits = 0, noftruescitilhits = 0; int noffakemvdpixhits = 0, noffakemvdstrhits = 0, noffakesttparalhits = 0, noffakesttskewhits = 0, noffakegemhits = 0, noffakescitilhits = 0;

FairHit *hit = NULL; FairMCPoint *point = NULL; for(Int_t ihit = 0; ihit < trkcand->GetNHits(); ihit++) { PndTrackCandHit candhit = trkcand->GetSortedHit(ihit); Int_t hitID1 = candhit.GetHitId(); Int_t detID1 = candhit.GetDetId();

if(detID1 == FairRootManager::Instance()->GetBranchId(fMvdPixelBranch)) { hit = (FairHit*) fMvdPixelHitArray->At(hitID1); int refindex = hit->GetRefIndex(); if(refindex == -1) noffakemvdpixhits++; else { point = (FairMCPoint*) fMvdPointArray->At(refindex); int reftrackid = point->GetTrackID(); if(reftrackid != mctrackid) noffakemvdpixhits++; else noftruemvdpixhits++; } } else if(detID1 == FairRootManager::Instance()->GetBranchId(fMvdStripBranch)) { hit = (FairHit*) fMvdStripHitArray->At(hitID1); int refindex = hit->GetRefIndex(); if(refindex == -1) noffakemvdstrhits++; else { point = (FairMCPoint*) fMvdPointArray->At(refindex); int reftrackid = point->GetTrackID(); if(reftrackid != mctrackid) noffakemvdstrhits++; else noftruemvdstrhits++; } } if(detID1 == FairRootManager::Instance()->GetBranchId(fSttBranch)) { hit = (FairHit*) fSttHitArray->At(hitID1);

Int_t tubeID = ((PndSttHit*) hit)->GetTubeID(); PndSttTube tube = (PndSttTube) fSttTubeArray->At(tubeID); int refindex = hit->GetRefIndex(); if(refindex == -1) { if(tube->IsSkew()) noffakesttskewhits++; else noffakesttparalhits++; } else { point = (FairMCPoint*) fSttPointArray->At(refindex); int reftrackid = point->GetTrackID(); if(reftrackid != mctrackid) { if(tube->IsSkew()) noffakesttskewhits++; else noffakesttparalhits++; } else { if(tube->IsSkew()) noftruesttskewhits++; else noftruesttparalhits++; } } } else if(detID1 == FairRootManager::Instance()->GetBranchId(fGemBranch)) { hit = (FairHit*) fGemHitArray->At(hitID1); int refindex = hit->GetRefIndex(); if(refindex == -1) noffakegemhits++; else { point = (FairMCPoint*) fGemPointArray->At(refindex); { int reftrackid = point->GetTrackID(); if(reftrackid != mctrackid) noffakegemhits++; else noftruegemhits++; } } } else if(detID1 == FairRootManager::Instance()->GetBranchId(fSciTBranch)) { hit = (FairHit*) fSciTilHitArray->At(hitID1); int refindex = hit->GetRefIndex(); if(refindex == -1) noffakescitilhits++; else { point = (FairMCPoint*) fSciTilPointArray->At(refindex); int reftrackid = point->GetTrackID(); if(reftrackid != mctrackid) noffakescitilhits++; else noftruescitilhits++; }

}

}

PndTrkRecoTrackInfo info(recotrackid); info.SetNofMvdPixTrueHits(noftruemvdpixhits); info.SetNofMvdStrTrueHits(noftruemvdstrhits); info.SetNofSttParalTrueHits(noftruesttparalhits); info.SetNofSttSkewTrueHits(noftruesttskewhits); info.SetNofGemTrueHits(noftruegemhits); info.SetNofSciTilTrueHits(noftruescitilhits); info.SetNofMvdPixFakeHits(noffakemvdpixhits); info.SetNofMvdStrFakeHits(noffakemvdstrhits); info.SetNofSttParalFakeHits(noffakesttparalhits); info.SetNofSttSkewFakeHits(noffakesttskewhits); info.SetNofGemFakeHits(noffakegemhits); info.SetNofSciTilFakeHits(noffakescitilhits);

info.SetMCTrackID(mctrackid);

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

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

info.SetCharge(track->GetParamFirst().GetQ());

for(int jtrk = 0; jtrk < fMCTrackInfo->GetEntriesFast(); jtrk++) { PndTrkMCTrackInfo mcinfo = (PndTrkMCTrackInfo) fMCTrackInfo->At(jtrk); int mcinfotrackid = mcinfo->GetMCTrackID(); cout << "mcinfotrackid " << mcinfo->GetMCTrackID() << " " << info.GetMCTrackID() << endl; if(mcinfotrackid == mctrackid) {

info.SetNofMvdPixMissingHits(mcinfo->GetNofMvdPixPoints() - noftruemvdpixhits); info.SetNofMvdStrMissingHits(mcinfo->GetNofMvdStrPoints() - noftruemvdstrhits); info.SetNofSttParalMissingHits(mcinfo->GetNofSttParalPoints() - noftruesttparalhits); info.SetNofSttSkewMissingHits(mcinfo->GetNofSttSkewPoints() - noftruesttskewhits); info.SetNofGemMissingHits(mcinfo->GetNofGemPoints() - noftruegemhits); info.SetNofSciTilMissingHits(mcinfo->GetNofSciTilPoints() - noftruescitilhits);

cout << "good mcinfotrackid " << mcinfo->GetMCTrackID() << " " << info.GetMCTrackID() << endl; info.SetMCTrackInfo(mcinfo); break; } }

return info; }

Definition at line 886 of file PndTrackingQATask.cxx.

References fMCTrackInfo, fRecoTrackInfo, PndTrackingQualityMCInfo::GetAssoRecoTrackID(), PndTrackingQualityRecoInfo::GetEfficiency(), PndTrackingQualityMCInfo::GetMCTrackID(), PndTrackingQualityRecoInfo::GetMCTrackID(), PndTrackingQualityRecoInfo::GetPurity(), PndTrackingQualityRecoInfo::GetRecoTrackID(), PndTrackingQualityMCInfo::SetAssoRecoTrackID(), PndTrackingQualityRecoInfo::SetClone(), PndTrackingQualityMCInfo::SetRecoTrackID(), and PndTrackingQualityRecoInfo::SetTrue().

Referenced by Exec().

                                                      {
  // loop over mc track infos
  for(int imctrk = 0; imctrk < fMCTrackInfo->GetEntriesFast(); imctrk++) {
    PndTrackingQualityMCInfo *mcinfo = (PndTrackingQualityMCInfo *) fMCTrackInfo->At(imctrk);
    int mctrackid0 = mcinfo->GetMCTrackID();
    if(mcinfo->GetAssoRecoTrackID() != -1) continue;
    double tmpeff = 0., tmppur =  0.;
    int tmptruerecotrackid = -1;
    
    // loop over reco track infos
    PndTrackingQualityRecoInfo *tmprecoinfo = NULL;
    for(int itrk = 0; itrk < fRecoTrackInfo->GetEntriesFast(); itrk++) {
      PndTrackingQualityRecoInfo *recoinfo = (PndTrackingQualityRecoInfo *) fRecoTrackInfo->At(itrk);
      int mctrackid = recoinfo->GetMCTrackID();
      if(mctrackid != mctrackid0) continue;
      mcinfo->SetRecoTrackID(recoinfo->GetRecoTrackID());
      recoinfo->SetClone();
      // it must have either the higher efficiency ...
      if(recoinfo->GetEfficiency() < tmpeff) continue;
      // ... or, if they are even, the highest purity
      if(recoinfo->GetEfficiency() == tmpeff && recoinfo->GetPurity() < tmppur) continue;

      tmpeff = recoinfo->GetEfficiency();
      tmppur =  recoinfo->GetPurity();
      tmptruerecotrackid = recoinfo->GetRecoTrackID();
      tmprecoinfo = recoinfo;
    }
    if(tmprecoinfo == NULL) continue;  

    tmprecoinfo->SetTrue();
    mcinfo->SetAssoRecoTrackID(tmptruerecotrackid);
    
  }
}

PndTrackingQATask::ClassDef ( PndTrackingQATask  , 1    )

private

void PndTrackingQATask::ColorHistogram ( )

private

Definition at line 632 of file PndTrackingQATask.cxx.

References fQualyHisto, fQualyHisto_all, fQualyHisto_mc, fQualyHisto_neg, fQualyHisto_pos, qualityNumbers::kAtLeastThreePrim, qualityNumbers::kAtLeastThreeSec, qualityNumbers::kFound, qualityNumbers::kFullyFound, qualityNumbers::kGhost, qualityNumbers::kLessThanThreePrim, qualityNumbers::kMcAtLeastThreePrim, qualityNumbers::kMcAtLeastThreeSec, qualityNumbers::kMcLessThanThreePrim, qualityNumbers::kMcPossiblePrim, qualityNumbers::kMcPossibleSec, qualityNumbers::kNotFound, qualityNumbers::kPartiallyFound, qualityNumbers::kPossiblePrim, qualityNumbers::kPossibleSec, and qualityNumbers::kSpuriousFound.

Referenced by Finish().

                                       {
        fQualyHisto_pos->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kGhost), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kGhost)));
        fQualyHisto_pos->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kSpuriousFound), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kSpuriousFound)));
        fQualyHisto_pos->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPartiallyFound), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPartiallyFound)));
        fQualyHisto_pos->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kFullyFound), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kFullyFound)));
        fQualyHisto_pos->SetLineColor(kGreen + 2);

        fQualyHisto_all->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kFound), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kFound)));
        fQualyHisto_all->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kNotFound), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kNotFound)));
        fQualyHisto_all->SetLineColor(kBlack);


        fQualyHisto_neg->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPossibleSec), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPossibleSec)));
        fQualyHisto_neg->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPossiblePrim), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPossiblePrim)));
        fQualyHisto_neg->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kAtLeastThreeSec), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kAtLeastThreeSec)));
        fQualyHisto_neg->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kAtLeastThreePrim), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kAtLeastThreePrim)));
        fQualyHisto_neg->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kLessThanThreePrim), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kLessThanThreePrim)));
        fQualyHisto_neg->SetLineColor(kRed + 2);

        fQualyHisto_mc->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcPossibleSec), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcPossibleSec)));
        fQualyHisto_mc->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcPossiblePrim), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcPossiblePrim)));
        fQualyHisto_mc->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcAtLeastThreeSec), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcAtLeastThreeSec)));
        fQualyHisto_mc->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcAtLeastThreePrim), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcAtLeastThreePrim)));
        fQualyHisto_mc->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcLessThanThreePrim), fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcLessThanThreePrim)));
        fQualyHisto_mc->SetLineColor(kBlue);

}

void PndTrackingQATask::Exec ( Option_t *  opt )

virtual

Virtual method Exec

Definition at line 206 of file PndTrackingQATask.cxx.

References PndTrackingQA::AnalyseEvent(), AssociateRecoTracksToMCTracks(), RhoTuple::Column(), Double_t, RhoTuple::DumpData(), fBranchNames, fEventNr, fIdealPHisto, fIdealPlHisto, fIdealPtHisto, fIdealTrack, fIdealTrackBranchName, fIdealTracksPerEvent, FillEfficiencies(), FillMCStatus(), FillQualyHisto(), fMCInfoIdIdealId, fMCTrack, fMCTrackInfo, fPHisto, fPlHisto, fPlRelHisto, fPndTrackOrTrackCand, fPossibleTrackFunctor, fPRelHisto, fPtHisto, fPtRelHisto, fRecoTrackInfo, fTrackBranchName, fTuple, fVerbose, PndTrackingQA::GetEfficiencies(), PndTrackingQA::GetIdealTrackIdFromMCTrackId(), PndTrackingQA::GetIdealTrackIdFromRecoTrackId(), GetMCInfoFromIdealTrack(), GetMCInfoIdFromIdealTrackId(), PndTrackingQA::GetMCTrackFound(), PndMCTrack::GetMomentum(), PndTrackingQA::GetNGhosts(), PndTrackingQualityMCInfo::GetNofMCPoints(), PndTrackingQA::GetP(), PndTrack::GetParamFirst(), PndMCTrack::GetPdgCode(), PndTrackingQA::GetPlResolution(), PndTrackingQA::GetPlResolutionRel(), PndTrackingQA::GetPResolution(), PndTrackingQA::GetPResolutionRel(), PndTrackingQA::GetPtResolution(), PndTrackingQA::GetPtResolutionRel(), PndTrackingQualityRecoInfo::GetRecoTrackID(), PndTrackingQA::GetTrackMCStatus(), PndTrackingQA::GetTrackQualification(), i, PndTrackingQA::Init(), MapToHist(), PndTrackingQA::PrintTrackQualityMap(), PndTrackingQA::SetHitsBranchNames(), PndTrackingQualityRecoInfo::SetIdealTrackId(), PndTrackingQualityMCInfo::SetMCQuality(), PndTrackingQualityMCInfo::SetMCTrackID(), PndTrackingQualityRecoInfo::SetMCTrackInfo(), PndTrackingQualityMCInfo::SetMomentum(), PndTrackingQualityMCInfo::SetPDGCode(), PndTrackingQualityMCInfo::SetQuality(), and PndTrackingQA::SetVerbose().

                                      {
  fMCTrackInfo->Delete();
  fRecoTrackInfo->Delete();

  if (fVerbose > 0)
          std::cout << "----- Event " << fEventNr << " ------" << std::endl;


        PndTrackingQA qaAna(fTrackBranchName, fIdealTrackBranchName, fPossibleTrackFunctor, fPndTrackOrTrackCand);
        qaAna.SetVerbose(fVerbose);
        qaAna.SetHitsBranchNames(fBranchNames);
        qaAna.Init();
        qaAna.AnalyseEvent(fRecoTrackInfo);

        std::map<Int_t, Int_t> qualiMap = qaAna.GetTrackQualification();
        std::map<Int_t, Int_t> mcStatusMap = qaAna.GetTrackMCStatus();
        std::map<Int_t, Int_t> mcFoundMap = qaAna.GetMCTrackFound();
        std::map<Int_t, TVector3> recoPMap = qaAna.GetP();
//      std::map<Int_t, Double_t> recoPtMap = qaAna.GetPt();


        FillQualyHisto(qualiMap, qaAna.GetNGhosts());
        FillMCStatus(mcStatusMap);
        fIdealTracksPerEvent->Fill(fIdealTrack->GetEntries());
        for (int i = 0; i < fIdealTrack->GetEntries(); i++){
                PndTrack* myTrack = (PndTrack*)fIdealTrack->At(i);
                fIdealPHisto->Fill(myTrack->GetParamFirst().GetMomentum().Mag());
                fIdealPtHisto->Fill(myTrack->GetParamFirst().GetMomentum().Pt());
                fIdealPlHisto->Fill(myTrack->GetParamFirst().GetMomentum().Pz());
        }

        FillEfficiencies(qaAna.GetEfficiencies());
        MapToHist(qaAna.GetPResolution(), fPHisto);
        MapToHist(qaAna.GetPResolutionRel(), fPRelHisto);
        MapToHist(qaAna.GetPtResolution(), fPtHisto);
        MapToHist(qaAna.GetPtResolutionRel(), fPtRelHisto);
        MapToHist(qaAna.GetPlResolution(), fPlHisto);
        MapToHist(qaAna.GetPlResolutionRel(), fPlRelHisto);

        // fill MC Track Info ......................................
        for (std::map<Int_t, Int_t>::iterator iter = qualiMap.begin(); iter != qualiMap.end(); iter++)
        {
          Int_t mcTrackId = iter->first;

          Int_t idealTrackId = qaAna.GetIdealTrackIdFromMCTrackId(mcTrackId);
          if (idealTrackId < 0){
                  std::cout << "-W- PndTrackingQATask::Exec no idealTrack for mcTrack " << mcTrackId << std::endl;
                  continue;
          }
          Int_t trackQuality = iter->second;
                          
          PndTrack *idealtrack = (PndTrack*) fIdealTrack->At(idealTrackId);
          
          if (idealtrack == 0){
                  std::cout << "-E- No ideal track found for idealTrackId " << idealTrackId << std::endl;
                  continue;
          }
          if (mcTrackId == -1){
                  std::cout << "-W- PndTrackingQATask::Exec mcTrackId == -1" << std::endl;
                  continue;
          }

          PndMCTrack * myMcTrack = (PndMCTrack *) fMCTrack->At(mcTrackId);

          if (myMcTrack == 0){
                  std::cout << "-E- PndTrackingQATask::Exec mcMyTrack == 0" << std::endl;
                  continue;
          }
          Int_t pdgId = myMcTrack->GetPdgCode();

          int size = fMCTrackInfo->GetEntriesFast();
          PndTrackingQualityMCInfo mctrackinfo = GetMCInfoFromIdealTrack(idealtrack);
          mctrackinfo.SetMCTrackID(mcTrackId);
          mctrackinfo.SetQuality(trackQuality);
          mctrackinfo.SetPDGCode(pdgId);
          mctrackinfo.SetMomentum(myMcTrack->GetMomentum());
          mctrackinfo.SetMCQuality(mcStatusMap[mcTrackId]);
          //  mctrackinfo.SetReconstructabilityStatus();
          
          if(mctrackinfo.GetNofMCPoints() > 0) {
            new((*fMCTrackInfo)[size]) PndTrackingQualityMCInfo(mctrackinfo);
            fMCInfoIdIdealId[idealTrackId] = size;
          }
          //     cout << "MCTRack " << mctrackinfo.GetMCTrackID() << endl;
        }
        // ............................................................

        // loop over reco track info and associate the mc track info
        for(int itrk = 0; itrk < fRecoTrackInfo->GetEntriesFast(); itrk++) {
          PndTrackingQualityRecoInfo *recoinfo = (PndTrackingQualityRecoInfo *) fRecoTrackInfo->At(itrk);
          Int_t idealTrackId = qaAna.GetIdealTrackIdFromRecoTrackId(recoinfo->GetRecoTrackID());
          recoinfo->SetIdealTrackId(idealTrackId);
          if (idealTrackId < 0){
                  std::cout << "-W- PndTrackingQATask::Exec no idealTrack for recoTrack " << itrk << std::endl;
                  continue;
          }

          PndTrackingQualityMCInfo *mctrackinfo = (PndTrackingQualityMCInfo*) fMCTrackInfo->At(GetMCInfoIdFromIdealTrackId(idealTrackId));
          recoinfo->SetMCTrackInfo(mctrackinfo);
        }
        // associate reconstructed and mc tracks
        AssociateRecoTracksToMCTracks();

        // Save the Tree (/RhoTuple) for some possible additional analysis
        for (std::map<Int_t, Int_t>::iterator iter = qualiMap.begin(); iter != qualiMap.end(); iter++) {
                Int_t mcTrackId = iter->first;
                Int_t trackQuality = iter->second;

                if (mcTrackId == -1){
                        std::cout << "-W- PndTrackingQATask::Exec mcTrackId == -1" << std::endl;
                        continue;
                }

                TVector3 recoMomentum = recoPMap[mcTrackId];

                PndMCTrack * myMcTrack = (PndMCTrack *) fMCTrack->At(mcTrackId);

                if (myMcTrack == 0){
                  std::cout << "-E- PndTrackingQATask::Exec mcMyTrack == 0" << std::endl;
                  continue;
                }
                TVector3 mcMomentum = myMcTrack->GetMomentum();
                Int_t pdgId = myMcTrack->GetPdgCode();

                fTuple->Column("EvtNr", (Int_t) fEventNr);  // number of the currently processed event

                fTuple->Column("McTrackId", (Int_t) mcTrackId);  // id of the currently processed track
                fTuple->Column("McTrackFoundNTimes", (Int_t) mcFoundMap[mcTrackId]);  // A given MC track was found N times
                fTuple->Column("TrackQuality", (Int_t) trackQuality);  // the quality of the current track
                fTuple->Column("Mc_TrackQuality", (Int_t) mcStatusMap[mcTrackId] - 6);  // the mc quality of the current track, -6 to match the global qualityNumbers

                fTuple->Column("PdgId", (Int_t) pdgId);
                fTuple->Column("Mc_px", (Double_t) mcMomentum.Px());  // To compare to the additionally saved pt histogram, call Draw("Reco_pt:Mc_pt","TrackQuality > 0") on the Tuple
                fTuple->Column("Mc_py", (Double_t) mcMomentum.Py());
                fTuple->Column("Mc_pz", (Double_t) mcMomentum.Pz());
                fTuple->Column("Mc_pt", (Double_t) mcMomentum.Pt());
                fTuple->Column("Reco_px", (Double_t) recoMomentum.Px());
                fTuple->Column("Reco_py", (Double_t) recoMomentum.Py());
                fTuple->Column("Reco_pz", (Double_t) recoMomentum.Pz());
                fTuple->Column("Reco_pt", (Double_t) recoMomentum.Pt());
//              fTuple->Column("Reco_pt2", (Double_t) recoPtMap[mcTrackId]);  // cross check

                fTuple->DumpData();
        }

        if (fVerbose > 0)
                qaAna.PrintTrackQualityMap();
        fEventNr++;
}

void PndTrackingQATask::FillEfficiencies ( std::map< Int_t, std::map< TString, std::pair< Double_t, Int_t > > >  efficiencies )

privatevirtual

Definition at line 390 of file PndTrackingQATask.cxx.

References fMapEfficiencies, map, and TString.

Referenced by Exec().

{
        for (std::map<Int_t, std::map<TString, std::pair<Double_t, Int_t> > >::iterator iterTracks = efficiencies.begin(); iterTracks != efficiencies.end(); iterTracks++ ){
                std::map<TString, std::pair<Double_t, Int_t> > branchEfficiency = iterTracks->second;
                for (std::map<TString, std::pair<Double_t, Int_t> >::iterator iterBranch = branchEfficiency.begin(); iterBranch != branchEfficiency.end(); iterBranch++ ){
                        fMapEfficiencies[iterBranch->first]->Fill(iterBranch->second.second, iterBranch->second.first);
                }
        }
}

void PndTrackingQATask::FillMCStatus ( std::map< Int_t, Int_t >  trackMCStatus )

privatevirtual

Definition at line 381 of file PndTrackingQATask.cxx.

References fQualyHisto, qualityNumbers::kMcPossibleSec, and qualityNumbers::kPossibleSec.

Referenced by Exec().

{
        int mcOffset = qualityNumbers::kPossibleSec - qualityNumbers::kMcPossibleSec;
        for(std::map<Int_t, Int_t>::iterator iter = trackMCStatus.begin(); iter != trackMCStatus.end(); iter++){
                fQualyHisto->Fill(iter->second - mcOffset);  // mcOffset = 6
        }
}

void PndTrackingQATask::FillQualyHisto ( std::map< Int_t, Int_t >  trackQualifikation, Int_t  nGhosts  )

privatevirtual

Analyses the track data and assigns quality indicator to track. Quality indicators: 1 : Not assigned 2 : All hits of the MC track were found and no additional once 3 : Some hits of the MC track were found and no additional once 4 : 70 % of all hits found belong to this MC track

Definition at line 366 of file PndTrackingQATask.cxx.

References fQualyHisto, qualityNumbers::kFound, qualityNumbers::kGhost, and qualityNumbers::kNotFound.

Referenced by Exec().

{

        fQualyHisto->Fill(qualityNumbers::kGhost, nGhosts);
        for(std::map<Int_t, Int_t>::iterator iter = trackQualifikation.begin(); iter != trackQualifikation.end(); iter++){
                fQualyHisto->Fill(iter->second);
                if (iter->second > 0){
                        fQualyHisto->Fill(qualityNumbers::kFound);
                }
                else {
                        fQualyHisto->Fill(qualityNumbers::kNotFound);
                }
        }
}

void PndTrackingQATask::Finish ( )

virtual

Definition at line 519 of file PndTrackingQATask.cxx.

References ColorHistogram(), Double_t, fBranchNames, fIdealPHisto, fIdealPlHisto, fIdealPtHisto, fIdealTracksPerEvent, fMapEfficiencies, fPHisto, fPlHisto, fPlRelHisto, fPRelHisto, fPtHisto, fPtRelHisto, fQualyHisto, fQualyHisto_all, fQualyHisto_mc, fQualyHisto_neg, fQualyHisto_pos, fQualyHisto_rel_all, fQualyHisto_rel_possible, fQualyStack, fTuple, RhoTuple::GetInternalTree(), i, qualityNumbers::kAtLeastThreePrim, qualityNumbers::kAtLeastThreeSec, qualityNumbers::kFullyFound, qualityNumbers::kGhost, qualityNumbers::kLessThanThreePrim, qualityNumbers::kMcAllTracksWithHits, qualityNumbers::kMcAtLeastThreePrim, qualityNumbers::kMcAtLeastThreeSec, qualityNumbers::kMcLessThanThreePrim, qualityNumbers::kMcPossiblePrim, qualityNumbers::kMcPossibleSec, qualityNumbers::kPartiallyFound, qualityNumbers::kPossiblePrim, qualityNumbers::kPossibleSec, qualityNumbers::kSpuriousFound, and SetQualyHisto().

                               {
        ColorHistogram();
        fQualyStack->Add(fQualyHisto_mc);
        fQualyStack->Add(fQualyHisto_neg);
        fQualyStack->Add(fQualyHisto_pos);
        fQualyStack->Add(fQualyHisto_all);
        fQualyStack->SetName("fQualyHistoColor");
        fQualyStack->SetTitle(fQualyHisto->GetTitle());

        // gROOT->SetBatch(kTRUE);
        // fQualyHisto->Draw();
        // LabelQualyHistogram((TH1*) fQualyStack);

        for (size_t i = 0; i < fBranchNames.size(); i++){
                fMapEfficiencies[fBranchNames[i]]->Write();
        }
        fIdealTracksPerEvent->Write();
        fIdealPHisto->Write();
        fIdealPtHisto->Write();
        fIdealPlHisto->Write();

        fPHisto->Write();
        fPRelHisto->Write();
        fPtHisto->Write();
        fPtRelHisto->Write();
        fPlHisto->Write();
        fPlRelHisto->Write();
        fQualyHisto->Write();
        fQualyStack->Write();
        
        Int_t allTracks = 0;
        Int_t allTracksWithHits = 0;
        Int_t allPossibleTracksWithHits = 0;
        Int_t allTracksWithHitsNotFound = 0;

        Int_t mcLessThanThreePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcLessThanThreePrim));
        Int_t mcAtLeastThreePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcAtLeastThreePrim));
        Int_t mcAtLeastThreeSec = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcAtLeastThreeSec));
        Int_t mcPossiblePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcPossiblePrim));
        Int_t mcPossibleSec = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcPossibleSec));

        Int_t lessThanThreePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kLessThanThreePrim));
        Int_t atLeastThreePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kAtLeastThreePrim));
        Int_t atLeastThreeSec = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kAtLeastThreeSec));
        Int_t possiblePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPossiblePrim));
        Int_t possibleSec = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPossibleSec));

        allTracksWithHits += mcAtLeastThreePrim;  // Todo
        allTracksWithHits += mcAtLeastThreeSec;
        allTracksWithHits += mcPossiblePrim;
        allTracksWithHits += mcPossibleSec;

        allTracks = allTracksWithHits + lessThanThreePrim;

        allPossibleTracksWithHits += mcPossiblePrim;
        allPossibleTracksWithHits += mcPossibleSec;

        allTracksWithHitsNotFound += atLeastThreePrim;
        allTracksWithHitsNotFound += atLeastThreeSec;
        allTracksWithHitsNotFound += possiblePrim;
        allTracksWithHitsNotFound += possibleSec;

        Double_t fullyFound = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kFullyFound));
        Double_t partiallyFound = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPartiallyFound));
        Double_t spuriousFound = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kSpuriousFound));
        //Double_t allFound = fullyFound + partiallyFound + spuriousFound; //[R.K.04/2017] unused variable
        //Double_t notFound = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kNotFound)); //[R.K.03/2017] unused variable

        Double_t ghosts = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kGhost));

        std::cout << "fQualyHisto: All Tracks: " << allTracks << std::endl
                          << " Primary Tracks < 3 hits: " << mcLessThanThreePrim << ": Not Found: " << lessThanThreePrim << std::endl
                          << " All Tracks with hits: " << allTracksWithHits << ". Not Found: " << allTracksWithHitsNotFound << std::endl
                          << " Primary Tracks with >= 3 hits, but not a possible track: " << mcAtLeastThreePrim << ". Not Found: " << atLeastThreePrim << std::endl
                          << " Secondary Tracks with >= 3 hits, but not a possible track: " << mcAtLeastThreeSec << ". Not Found: " << atLeastThreeSec << std::endl
                          << " Primary Tracks possible: " << mcPossiblePrim << ". Not Found: " << possiblePrim << std::endl
                          << " Secondary Tracks possible: " << mcPossibleSec << ". Not Found: " << possibleSec << std::endl
                          << " All Possible Tracks with hits: " << allPossibleTracksWithHits << std::endl

                          << " FullyFound: "    << fullyFound   << " "
                          << fullyFound / allTracksWithHits * 100.0 << "% (of all tracks), "
                          << fullyFound / allPossibleTracksWithHits * 100.0 << "% (of all tracks possible)"

                          << " PartlyFound: "  << partiallyFound        << " "
                          << partiallyFound / allTracksWithHits * 100.0 << "% "
                          << partiallyFound / allPossibleTracksWithHits * 100.0 << "% "

                          << " Spurious: "      << spuriousFound                << " "
                          << spuriousFound / allTracksWithHits * 100.0 << "% "
                          << spuriousFound / allPossibleTracksWithHits * 100.0 << "% "

                          << " Ghosts: "        << ghosts               << " "
                          << ghosts / allTracksWithHits * 100.0 << "% "
                          << ghosts / allPossibleTracksWithHits * 100.0 << "% " << std::endl;

        SetQualyHisto(fQualyHisto_rel_all, kTRUE, allTracksWithHits);
        SetQualyHisto(fQualyHisto_rel_possible, kTRUE, allPossibleTracksWithHits);

        fQualyHisto->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcAllTracksWithHits), allTracksWithHits);
        fQualyHisto->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kLessThanThreePrim), mcLessThanThreePrim - lessThanThreePrim);
        fQualyHisto->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kAtLeastThreePrim), mcAtLeastThreePrim - atLeastThreePrim);
        fQualyHisto->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kAtLeastThreeSec), mcAtLeastThreeSec - atLeastThreeSec);
        fQualyHisto->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPossiblePrim), mcPossiblePrim - possiblePrim);
        fQualyHisto->SetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPossibleSec), mcPossibleSec - possibleSec);

        fQualyHisto_rel_all->Write();
        fQualyHisto_rel_possible->Write();
        fQualyHisto->Write();
        fTuple->GetInternalTree()->Write();

        std::cout << "Finish finished!" << std::endl;
}

PndTrackingQualityMCInfo PndTrackingQATask::GetMCInfoFromIdealTrack ( PndTrack *  idealtrack )

private

Definition at line 660 of file PndTrackingQATask.cxx.

References fSttHitArray, fSttTubeArray, PndTrackCandHit::GetDetId(), PndTrackCandHit::GetHitId(), PndMCTrack::GetMotherID(), PndTrackCand::GetNHits(), PndTrackCand::GetNHitsDet(), PndTrack::GetParamFirst(), PndTrack::GetParamLast(), PndTrackCand::GetSortedHit(), PndMCTrack::GetStartVertex(), PndTrack::GetTrackCandPtr(), PndSttHit::GetTubeID(), PndSttTube::IsSkew(), PndTrackingQualityMCInfo::SetCharge(), PndTrackingQualityMCInfo::SetIsPrimary(), PndTrackingQualityMCInfo::SetMomentumFirst(), PndTrackingQualityMCInfo::SetMomentumLast(), PndTrackingQualityMCInfo::SetPositionFirst(), PndTrackingQualityMCInfo::SetPositionLast(), and PndTrackingQualityMCInfo::SetVertex().

Referenced by Exec().

                                                                                        {
  
  PndTrackCand *idealtrkcand = idealtrack->GetTrackCandPtr();
    
  //Int_t nofsttpoint = idealtrkcand->GetNHitsDet(FairRootManager::Instance()->GetBranchId("STTHit")); //[R.K. 01/2017] unused variable
  Int_t nofmvdpixpoint = idealtrkcand->GetNHitsDet(FairRootManager::Instance()->GetBranchId("MVDHitsPixel"));
  Int_t nofmvdstrpoint = idealtrkcand->GetNHitsDet(FairRootManager::Instance()->GetBranchId("MVDHitsStrip"));
  //Int_t nofmvdpoint = nofmvdpixpoint + nofmvdstrpoint; //[R.K. 01/2017] unused variable
  Int_t nofgempoint = idealtrkcand->GetNHitsDet(FairRootManager::Instance()->GetBranchId("GEMHit"));
  Int_t nofftspoint = idealtrkcand->GetNHitsDet(FairRootManager::Instance()->GetBranchId("FTSHit"));
  
  int nofsttskewpoint = 0, nofsttparalpoint = 0;    
  // this loop counts skewed (--> parallel) STT/FTS hits
  for(size_t ihit = 0; ihit < idealtrkcand->GetNHits(); ihit++) {
    PndTrackCandHit idealcandhit = idealtrkcand->GetSortedHit(ihit);
    Int_t hitID = idealcandhit.GetHitId();
    Int_t detID = idealcandhit.GetDetId();
      
    if(detID != FairRootManager::Instance()->GetBranchId("STTHit")) continue; 
    PndSttHit *stthit = (PndSttHit*) fSttHitArray->At(hitID);   //todo: For time based sim this has to be replaced with FariRootManager::GetCloneOfLinkData
    Int_t tubeID = stthit->GetTubeID();
    PndSttTube *tube = (PndSttTube*) fSttTubeArray->At(tubeID);
    if(tube->IsSkew()) nofsttskewpoint++;
    else nofsttparalpoint++;
  }

  PndTrackingQualityMCInfo info(nofmvdpixpoint, nofmvdstrpoint, nofsttparalpoint, nofsttskewpoint, nofgempoint, nofftspoint);
  std::vector<FairLink> mcTracks = idealtrack->GetSortedMCTracks();
  if (mcTracks.size() > 0){
          PndMCTrack* myMCTrack = (PndMCTrack*)FairRootManager::Instance()->GetCloneOfLinkData(mcTracks[0]);
          if (myMCTrack != nullptr){
                  info.SetVertex(myMCTrack->GetStartVertex());
                  if (myMCTrack->GetMotherID() < 0){
                          info.SetIsPrimary(kTRUE);
                  }
                  else{
                          info.SetIsPrimary(kFALSE);
                  }
          }
  }
  // CHECK
  // Bool_t isreco = Reconstructability(nofmvdpixpoint, nofmvdstrpoint, nofsttparalpoint, nofsttskewpoint, nofgempoint, nofscitilpoint);
  //  info.SetReconstructability(isreco);


  info.SetPositionFirst(idealtrack->GetParamFirst().GetPosition());
  info.SetMomentumFirst(idealtrack->GetParamFirst().GetMomentum());
  info.SetPositionLast(idealtrack->GetParamLast().GetPosition());
  info.SetMomentumLast(idealtrack->GetParamLast().GetMomentum());
  info.SetCharge(idealtrack->GetParamFirst().GetQ());

 
  return info;

}

Int_t PndTrackingQATask::GetMCInfoIdFromIdealTrackId ( int  idealtrackid )

inlineprivate

Definition at line 101 of file PndTrackingQATask.h.

References fMCInfoIdIdealId.

Referenced by Exec().

{ return fMCInfoIdIdealId[idealtrackid]; }

Int_t PndTrackingQATask::GetSumOfAllValidMCHits ( FairMultiLinkedData *  trackData )

privatevirtual

Definition at line 356 of file PndTrackingQATask.cxx.

References fBranchNames, and ioman.

{
        Int_t result = 0;
        for (size_t branchIndex = 0; branchIndex < fBranchNames.size(); branchIndex++){
                result += trackData->GetLinksWithType(ioman->GetBranchId(fBranchNames[branchIndex])).GetNLinks();
        }
        return result;
}

InitStatus PndTrackingQATask::Init ( )

virtual

Definition at line 50 of file PndTrackingQATask.cxx.

References AddHitsBranchName(), fBranchNames, fIdealTrack, fIdealTrackBranchName, PndSttMapCreator::FillTubeArray(), fMapEfficiencies, fMCInfoBranchName, fMCTrack, fMCTrackInfo, fPossibleTrackFunctorName, fRecoInfoBranchName, fRecoTrackInfo, fSttHitArray, fSttParameters, fSttTubeArray, fTrack, fTrackBranchName, fTuple, i, InitializeHistograms(), ioman, and SetFunctor().

                                   {
        InitializeHistograms();

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

        fTrack = (TClonesArray*) ioman->GetObject(fTrackBranchName);
        fMCTrack = (TClonesArray*) ioman->GetObject("MCTrack");
        //      fIdealTrackCand = (TClonesArray*) ioman->GetObject(fIdealTrackBranchName);
        fIdealTrack = (TClonesArray*) ioman->GetObject(fIdealTrackBranchName);
        fSttHitArray = (TClonesArray*) ioman->GetObject("STTHit");

        if (fTrack == nullptr){
                std::cout << "-E- PndTrackingQATask::Init " << "no track branch " << fTrackBranchName << std::endl;
                return kFATAL;
        }
        if (fMCTrack == nullptr){
                std::cout << "-E- PndTrackingQATask::Init " << "no MC track branch " << std::endl;
                return kFATAL;
        }

        if (fIdealTrack == nullptr){
                std::cout << "-E- PndTrackingQATask::Init " << "no ideal track branch " << fIdealTrackBranchName << std::endl;
                return kFATAL;
        }

        // MC info for quality
        fMCTrackInfo = new TClonesArray("PndTrackingQualityMCInfo");
        ioman->Register(fMCInfoBranchName,  "QualityAssurance", fMCTrackInfo, kTRUE); // CHECK
        fRecoTrackInfo = new TClonesArray("PndTrackingQualityRecoInfo");
        ioman->Register(fRecoInfoBranchName,  "QualityAssurance", fRecoTrackInfo, kTRUE); // CHECK

        fTuple = new RhoTuple("qaTuple", "QA Rho");

        if (fBranchNames.size() == 0){
                AddHitsBranchName("MVDHitsPixel");
                AddHitsBranchName("MVDHitsStrip");
                AddHitsBranchName("STTHit");
                AddHitsBranchName("GEMHit");
                AddHitsBranchName("FTSHit");
        //      std::cout << "PndTrackingQualityAnalysis::Init() CorrectedSkewedHits present: " << FairRootManager::Instance()->GetBranchId("CorrectedSkewedHits") << " ";
        //      if (FairRootManager::Instance()->GetBranchId("CorrectedSkewedHits")  > 0){
        //              std::cout << "kTRUE";
        //              AddHitsBranchName("CorrectedSkewedHits");
        //      }
        //      std::cout << std::endl;
        }

        if (fPossibleTrackFunctorName.Length() == 0)
                fPossibleTrackFunctorName = "StandardTrackFunctor";

        SetFunctor();
        for (size_t i = 0; i < fBranchNames.size(); i++){
                fMapEfficiencies[fBranchNames[i]] = new TH2D(fBranchNames[i], fBranchNames[i], 100, 0., 100., 50, 0, 1.1);
                fMapEfficiencies[fBranchNames[i]]->SetDrawOption("COLz");
        }

        // ----------------------------------------   maps of STT tubes
        PndSttMapCreator *mapperStt = new PndSttMapCreator(fSttParameters);
        fSttTubeArray = mapperStt->FillTubeArray();
        // ----------------------------------------------------  end map

//      std::cout << "-I- PndTrackingQATask::Init: Initialization successfull" << std::endl;

        return kSUCCESS;
}

void PndTrackingQATask::InitializeHistograms ( )

private

Definition at line 121 of file PndTrackingQATask.cxx.

References fIdealPHisto, fIdealPlHisto, fIdealPtHisto, fIdealTracksPerEvent, fPHisto, fPlHisto, fPlRelHisto, fPRelHisto, fPtHisto, fPtRelHisto, fQualyHisto, fQualyHisto_all, fQualyHisto_mc, fQualyHisto_neg, fQualyHisto_pos, fQualyHisto_rel_all, fQualyHisto_rel_possible, fQualyStack, and LabelQualyHistogram().

Referenced by Init().

                                             {
        fIdealTracksPerEvent = new TH1I("fIdealTracksPerEvent", "Ideal Tracks per Event", 1000, -0.5,999.5);
        fIdealTracksPerEvent->GetXaxis()->SetTitle("Tracks/Event");
        fIdealPHisto = new TH1I("fIdealPHisto", "Ideal total Momentum", 1500, -0.5,14.5);
        fIdealPHisto->GetXaxis()->SetTitle("p [GeV/c]");
        fIdealPtHisto = new TH1I("fIdealPtHisto", "Ideal Tansversal Momentum", 1500, -0.5,14.5);
        fIdealPtHisto->GetXaxis()->SetTitle("p_{t} [GeV/c]");
        fIdealPlHisto = new TH1I("fIdealPlHisto", "Ideal Longitudinal Momentum", 1500, -0.5,14.5);
        fIdealPlHisto->GetXaxis()->SetTitle("p_{l} [GeV/c]");
        fPHisto = new TH1D("fPHisto", "Momentum Resolution", 1000, -1, 1);
        fPHisto->GetXaxis()->SetTitle("p^{RECO} - p^{MC} / GeV");
        fPHisto->GetYaxis()->SetTitle("counts");
        fPRelHisto = new TH1D("fPRelHisto", "Relative Momentum Resolution", 1000, -1, 1);
        fPRelHisto->GetXaxis()->SetTitle("(p^{RECO} - p^{MC}) / p^{MC}");
        fPRelHisto->GetYaxis()->SetTitle("counts");
        fPtHisto = new TH1D("fPtHisto", "Transverse Momentum Resolution", 1000, -1, 1);
        fPtHisto->GetXaxis()->SetTitle("p_{t}^{RECO} - p_{t}^{MC} / GeV");
        fPtHisto->GetYaxis()->SetTitle("counts");
        fPtRelHisto = new TH1D("fPtRelHisto", "Relative Transverse Momentum Resolution", 1000, -1, 1);
        fPtRelHisto->GetXaxis()->SetTitle("(p_{t}^{RECO} - p_{t}^{MC}) / p_{t}^{MC}");
        fPtRelHisto->GetYaxis()->SetTitle("counts");
        fPlHisto = new TH1D("fPlHisto", "Longitudinal Momentum Resolution", 1000, -1, 1);
        fPlHisto->GetXaxis()->SetTitle("p_{l}^{RECO} - p_{l}^{MC} / GeV");
        fPlHisto->GetYaxis()->SetTitle("counts");
        fPlRelHisto = new TH1D("fPlRelHisto", "Relative Longitudinal Momentum Resolution", 1000, -1, 1);
        fPlRelHisto->GetXaxis()->SetTitle("(p_{l}^{RECO} - p_{l}^{MC}) / p_{l}^{MC}");
        fPlRelHisto->GetYaxis()->SetTitle("counts");

        fQualyHisto = new TH1I("fQualyHisto", "Quality of Trackfinding;;Counts", 26, -15.5, 10.5);
        fQualyHisto->SetDrawOption("TEXT HIST");
        LabelQualyHistogram(fQualyHisto);

        fQualyHisto_all = new TH1I("fQualyHisto_all", "Quality of Trackfinding;;Counts", 26, -15.5, 10.5);
        fQualyHisto_pos = new TH1I("fQualyHisto_pos", "Quality of Trackfinding;;Counts", 26, -15.5, 10.5);
        fQualyHisto_neg = new TH1I("fQualyHisto_neg", "Quality of Trackfinding;;Counts", 26, -15.5, 10.5);
        fQualyHisto_mc = new TH1I("fQualyHisto_mc", "Quality of Trackfinding;;Counts", 26, -15.5, 10.5);
        fQualyStack = new THStack();

        fQualyHisto_rel_all = new TH1D("fQualyHisto_rel_all", "Quality of Trackfinding;;Relative", 26, -15.5, 10.5);
        fQualyHisto_rel_all->SetBarWidth(0.45);
        fQualyHisto_rel_all->SetBarOffset(0.1);
        fQualyHisto_rel_all->SetFillColor(kBlue);

        fQualyHisto_rel_possible = new TH1D("fQualyHisto_rel_possible", "Quality of Trackfinding;;Relative", 26, -15.5, 10.5);
        fQualyHisto_rel_possible->SetBarWidth(0.4);
        fQualyHisto_rel_possible->SetBarOffset(0.55);
        fQualyHisto_rel_possible->SetFillColor(kRed);


        LabelQualyHistogram(fQualyHisto_rel_all);
        LabelQualyHistogram(fQualyHisto_rel_possible);
}

void PndTrackingQATask::LabelQualyHistogram ( TH1 *  hist )

private

Definition at line 174 of file PndTrackingQATask.cxx.

References qualityNumbers::kAtLeastThreePrim, qualityNumbers::kAtLeastThreeSec, qualityNumbers::kFound, qualityNumbers::kFullyFound, qualityNumbers::kGhost, qualityNumbers::kLessThanThreePrim, qualityNumbers::kMcAtLeastThreePrim, qualityNumbers::kMcAtLeastThreeSec, qualityNumbers::kMcLessThanThreePrim, qualityNumbers::kMcPossiblePrim, qualityNumbers::kMcPossibleSec, qualityNumbers::kNotFound, qualityNumbers::kPartiallyFound, qualityNumbers::kPossiblePrim, qualityNumbers::kPossibleSec, and qualityNumbers::kSpuriousFound.

Referenced by InitializeHistograms().

                                                      {
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kFullyFound), "Fully found");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kPartiallyFound), "Partially found");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kSpuriousFound), "Spurious found");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kGhost), "Ghosts");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kNotFound), "Total not found");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kFound), "Total found");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kPossibleSec), "Possible, Sec.");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kPossiblePrim), "Possible, Prim.");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kAtLeastThreeSec), ">= 3 Hits, Sec.");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kAtLeastThreePrim), ">= 3 Hits, Prim.");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kLessThanThreePrim), "< 3 Hits, Prim.");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kMcPossibleSec), "MC: Possible, Sec.");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kMcPossiblePrim), "MC: Possible, Prim.");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kMcAtLeastThreeSec), "MC: >= 3 Hits, Sec.");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kMcAtLeastThreePrim), "MC: >= 3 Hits, Prim.");
        hist->GetXaxis()->SetBinLabel(hist->FindFixBin(qualityNumbers::kMcLessThanThreePrim), "MC: < 3 Hits, Prim.");
}

void PndTrackingQATask::MapToHist ( std::map< Int_t, Double_t >  map, TH1 *  histo  )

privatevirtual

Definition at line 399 of file PndTrackingQATask.cxx.

Referenced by Exec().

                                                                           {
        for (std::map<Int_t, Double_t>::iterator iter = map.begin(); iter != map.end(); iter++ ){
                histo->Fill(iter->second);
        }
}

void PndTrackingQATask::Register ( )

private

void PndTrackingQATask::Reset ( )

private

void PndTrackingQATask::SetFunctor

(

)

Definition at line 200 of file PndTrackingQATask.cxx.

References fPossibleTrackFunctor, fPossibleTrackFunctorName, and PndTrackFunctor::make_PndTrackFunctor().

Referenced by Init().

{
        fPossibleTrackFunctor = PndTrackFunctor::make_PndTrackFunctor(fPossibleTrackFunctorName.Data());
}

void PndTrackingQATask::SetFunctorName ( TString  name )

inline

Definition at line 69 of file PndTrackingQATask.h.

References fPossibleTrackFunctorName, and name.

Referenced by trackingQA_forward_complete().

{ fPossibleTrackFunctorName = name; }

void PndTrackingQATask::SetIdealTrackBranchName ( TString  name )

inline

Definition at line 58 of file PndTrackingQATask.h.

References fIdealTrackBranchName, and name.

{fIdealTrackBranchName = name;};

void PndTrackingQATask::SetOutputMCInfoBranchName ( TString  name )

inline

Definition at line 66 of file PndTrackingQATask.h.

References fMCInfoBranchName, and name.

{ fMCInfoBranchName = name; }

void PndTrackingQATask::SetOutputRecoInfoBranchName ( TString  name )

inline

Definition at line 67 of file PndTrackingQATask.h.

References fRecoInfoBranchName, and name.

{ fRecoInfoBranchName = name; }

void PndTrackingQATask::SetParContainers ( )

virtual

Virtual method Init

Definition at line 195 of file PndTrackingQATask.cxx.

References fSttParameters, and rtdb.

                                         {
  FairRuntimeDb* rtdb = FairRun::Instance()->GetRuntimeDb();
  fSttParameters = (PndGeoSttPar*) rtdb->getContainer("PndGeoSttPar");
}

void PndTrackingQATask::SetQualyHisto ( TH1 *  histo, Bool_t  relative, Int_t  base = 1  )

privatevirtual

Definition at line 405 of file PndTrackingQATask.cxx.

References Double_t, fQualyHisto, qualityNumbers::kAtLeastThreePrim, qualityNumbers::kAtLeastThreeSec, qualityNumbers::kFound, qualityNumbers::kFullyFound, qualityNumbers::kGhost, qualityNumbers::kLessThanThreePrim, qualityNumbers::kMcAllTracksWithHits, qualityNumbers::kMcAtLeastThreePrim, qualityNumbers::kMcAtLeastThreeSec, qualityNumbers::kMcLessThanThreePrim, qualityNumbers::kMcPossiblePrim, qualityNumbers::kMcPossibleSec, qualityNumbers::kNotFound, qualityNumbers::kPartiallyFound, qualityNumbers::kPossiblePrim, qualityNumbers::kPossibleSec, and qualityNumbers::kSpuriousFound.

Referenced by Finish().

{
        Int_t allTracks = 0;
        Int_t allTracksWithHits = 0;
        Int_t allPossibleTracksWithHits = 0;
        Int_t allTracksWithHitsNotFound = 0;

        Int_t mcLessThanThreePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcLessThanThreePrim));
        Int_t mcAtLeastThreePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcAtLeastThreePrim));
        Int_t mcAtLeastThreeSec = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcAtLeastThreeSec));
        Int_t mcPossiblePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcPossiblePrim));
        Int_t mcPossibleSec = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kMcPossibleSec));

        Int_t lessThanThreePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kLessThanThreePrim));
        Int_t atLeastThreePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kAtLeastThreePrim));
        Int_t atLeastThreeSec = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kAtLeastThreeSec));
        Int_t possiblePrim = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPossiblePrim));
        Int_t possibleSec = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPossibleSec));

        Double_t fullyFound = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kFullyFound));
        Double_t partiallyFound = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kPartiallyFound));
        Double_t spuriousFound = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kSpuriousFound));
        Double_t allFound = fullyFound + partiallyFound + spuriousFound;

        Double_t ghosts = fQualyHisto->GetBinContent(fQualyHisto->FindFixBin(qualityNumbers::kGhost));

        allTracksWithHits += mcAtLeastThreePrim;  // Todo
        allTracksWithHits += mcAtLeastThreeSec;
        allTracksWithHits += mcPossiblePrim;
        allTracksWithHits += mcPossibleSec;

        allTracks = allTracksWithHits + lessThanThreePrim;

        allPossibleTracksWithHits += mcPossiblePrim;
        allPossibleTracksWithHits += mcPossibleSec;

        allTracksWithHitsNotFound += atLeastThreePrim;
        allTracksWithHitsNotFound += atLeastThreeSec;
        allTracksWithHitsNotFound += possiblePrim;
        allTracksWithHitsNotFound += possibleSec;

        Double_t divisor = 1.0;
        if (relative == kTRUE){
                divisor = allTracks / 100.0;
        }

        histo->Fill(qualityNumbers::kMcAllTracksWithHits, (Double_t)allTracksWithHits / divisor);
        histo->Fill(qualityNumbers::kMcLessThanThreePrim, (Double_t)mcLessThanThreePrim / divisor);
        histo->Fill(qualityNumbers::kMcAtLeastThreePrim, (Double_t)mcAtLeastThreePrim / divisor);
        histo->Fill(qualityNumbers::kMcAtLeastThreeSec, (Double_t)mcAtLeastThreeSec / divisor);
        histo->Fill(qualityNumbers::kMcPossiblePrim, (Double_t)mcPossiblePrim / divisor);
        histo->Fill(qualityNumbers::kMcPossibleSec, (Double_t)mcPossibleSec / divisor);

        divisor = 1.0;

        if (mcLessThanThreePrim > 0){
                if (relative == kTRUE){
                                divisor = mcLessThanThreePrim / 100.0;
                }
                histo->Fill(qualityNumbers::kLessThanThreePrim, (Double_t)(mcLessThanThreePrim - lessThanThreePrim) /divisor);
        }

        divisor = 1.0;

        if (mcAtLeastThreePrim > 0) {
                if (relative == kTRUE){
                                divisor = mcAtLeastThreePrim / 100.0;
                }
                histo->Fill(qualityNumbers::kAtLeastThreePrim, (Double_t)(mcAtLeastThreePrim - atLeastThreePrim) / divisor);
        }

        divisor = 1.0;

        if (mcAtLeastThreeSec > 0){
                if (relative == kTRUE){
                                divisor = mcAtLeastThreeSec / 100.0;
                }
                histo->Fill(qualityNumbers::kAtLeastThreeSec, (Double_t)(Double_t)(mcAtLeastThreeSec - atLeastThreeSec) / divisor);
        }

        divisor = 1.0;

        if (mcPossiblePrim > 0){
                if (relative == kTRUE){
                                divisor = mcPossiblePrim / 100.0;
                }
                histo->Fill(qualityNumbers::kPossiblePrim, (Double_t)(mcPossiblePrim - possiblePrim) / divisor);
        }

        divisor = 1.0;

        if (mcPossibleSec > 0){
                if (relative == kTRUE){
                                divisor = mcPossibleSec / 100.0;
                }
                histo->Fill(qualityNumbers::kPossibleSec, (Double_t)(mcPossibleSec - possibleSec) / divisor);
        }

        Double_t baseDouble = base;
        if (relative == kTRUE){
                baseDouble /= 100.0;
        }

        if (base == 0)
                return;

        histo->Fill(qualityNumbers::kFullyFound, fullyFound / baseDouble);
        histo->Fill(qualityNumbers::kPartiallyFound, partiallyFound / baseDouble);
        histo->Fill(qualityNumbers::kSpuriousFound, spuriousFound / baseDouble);
        histo->Fill(qualityNumbers::kGhost, ghosts / baseDouble);
        histo->Fill(qualityNumbers::kFound, allFound / baseDouble);
        histo->Fill(qualityNumbers::kNotFound, (base - allFound) / baseDouble);
}

void PndTrackingQATask::SetTrackBranchName ( TString  name, Bool_t  pndTrackData = kTRUE  )

inline

Sets the branch name of the track data which should be analyzed.

Definition at line 61 of file PndTrackingQATask.h.

References fPndTrackOrTrackCand, fTrackBranchName, and name.

{fPndTrackOrTrackCand = pndTrackData; fTrackBranchName = name;} //alternatively PndTrackCandData can be analysed. Therefore pndTrackData has to be set to kFALSE

Member Data Documentation

std::vector<TString> PndTrackingQATask::fBranchNames

private

Definition at line 106 of file PndTrackingQATask.h.

Referenced by AddHitsBranchName(), Exec(), Finish(), GetSumOfAllValidMCHits(), and Init().

Int_t PndTrackingQATask::fEventNr

private

Definition at line 164 of file PndTrackingQATask.h.

Referenced by Exec().

const TString PndTrackingQATask::fHypoName[5] ={"Electron","Muon","Pion","Kaon","Proton"}

private

Definition at line 75 of file PndTrackingQATask.h.

TH1* PndTrackingQATask::fIdealPHisto

private

Definition at line 143 of file PndTrackingQATask.h.

Referenced by Exec(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fIdealPlHisto

private

Definition at line 145 of file PndTrackingQATask.h.

Referenced by Exec(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fIdealPrimTracksPerEvent

private

Definition at line 146 of file PndTrackingQATask.h.

TH1* PndTrackingQATask::fIdealPtHisto

private

Definition at line 144 of file PndTrackingQATask.h.

Referenced by Exec(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fIdealSecTracksPerEvent

private

Definition at line 147 of file PndTrackingQATask.h.

TClonesArray* PndTrackingQATask::fIdealTrack

private

Definition at line 124 of file PndTrackingQATask.h.

Referenced by Exec(), and Init().

TString PndTrackingQATask::fIdealTrackBranchName

private

Definition at line 132 of file PndTrackingQATask.h.

Referenced by Exec(), Init(), and SetIdealTrackBranchName().

TH1* PndTrackingQATask::fIdealTracksPerEvent

private

Definition at line 142 of file PndTrackingQATask.h.

Referenced by Exec(), Finish(), and InitializeHistograms().

std::map<TString, TH2*> PndTrackingQATask::fMapEfficiencies

private

Definition at line 111 of file PndTrackingQATask.h.

Referenced by FillEfficiencies(), Finish(), and Init().

std::map<TString, FairMultiLinkedData> PndTrackingQATask::fMapLinkData

private

Definition at line 109 of file PndTrackingQATask.h.

std::map<Int_t, Int_t> PndTrackingQATask::fMapTrackQualifikation

private

Definition at line 129 of file PndTrackingQATask.h.

TString PndTrackingQATask::fMCInfoBranchName

private

Definition at line 107 of file PndTrackingQATask.h.

Referenced by Init(), and SetOutputMCInfoBranchName().

std::map< int, int > PndTrackingQATask::fMCInfoIdIdealId

private

Definition at line 113 of file PndTrackingQATask.h.

Referenced by Exec(), and GetMCInfoIdFromIdealTrackId().

TClonesArray* PndTrackingQATask::fMCTrack

private

Definition at line 118 of file PndTrackingQATask.h.

Referenced by Exec(), and Init().

TClonesArray* PndTrackingQATask::fMCTrackInfo

private

Definition at line 122 of file PndTrackingQATask.h.

Referenced by AssociateRecoTracksToMCTracks(), Exec(), and Init().

Int_t PndTrackingQATask::fNGhosts

private

Definition at line 115 of file PndTrackingQATask.h.

TH1* PndTrackingQATask::fPHisto

private

Definition at line 148 of file PndTrackingQATask.h.

Referenced by Exec(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fPlHisto

private

Definition at line 152 of file PndTrackingQATask.h.

Referenced by Exec(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fPlRelHisto

private

Definition at line 153 of file PndTrackingQATask.h.

Referenced by Exec(), Finish(), and InitializeHistograms().

Bool_t PndTrackingQATask::fPndTrackOrTrackCand

private

Definition at line 133 of file PndTrackingQATask.h.

Referenced by Exec(), and SetTrackBranchName().

PndTrackFunctor* PndTrackingQATask::fPossibleTrackFunctor

private

Definition at line 138 of file PndTrackingQATask.h.

Referenced by Exec(), and SetFunctor().

TString PndTrackingQATask::fPossibleTrackFunctorName

private

Definition at line 136 of file PndTrackingQATask.h.

Referenced by Init(), SetFunctor(), and SetFunctorName().

TH1* PndTrackingQATask::fPRelHisto

private

Definition at line 149 of file PndTrackingQATask.h.

Referenced by Exec(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fPtHisto

private

Definition at line 150 of file PndTrackingQATask.h.

Referenced by Exec(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fPtRelHisto

private

Definition at line 151 of file PndTrackingQATask.h.

Referenced by Exec(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fQualyHisto

private

Definition at line 154 of file PndTrackingQATask.h.

Referenced by ColorHistogram(), FillMCStatus(), FillQualyHisto(), Finish(), InitializeHistograms(), and SetQualyHisto().

TH1* PndTrackingQATask::fQualyHisto_all

private

Definition at line 159 of file PndTrackingQATask.h.

Referenced by ColorHistogram(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fQualyHisto_mc

private

Definition at line 156 of file PndTrackingQATask.h.

Referenced by ColorHistogram(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fQualyHisto_neg

private

Definition at line 157 of file PndTrackingQATask.h.

Referenced by ColorHistogram(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fQualyHisto_pos

private

Definition at line 158 of file PndTrackingQATask.h.

Referenced by ColorHistogram(), Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fQualyHisto_rel_all

private

Definition at line 160 of file PndTrackingQATask.h.

Referenced by Finish(), and InitializeHistograms().

TH1* PndTrackingQATask::fQualyHisto_rel_possible

private

Definition at line 161 of file PndTrackingQATask.h.

Referenced by Finish(), and InitializeHistograms().

THStack* PndTrackingQATask::fQualyStack

private

Definition at line 155 of file PndTrackingQATask.h.

Referenced by Finish(), and InitializeHistograms().

TString PndTrackingQATask::fRecoInfoBranchName

private

Definition at line 107 of file PndTrackingQATask.h.

Referenced by Init(), and SetOutputRecoInfoBranchName().

TClonesArray* PndTrackingQATask::fRecoTrackInfo

private

Definition at line 123 of file PndTrackingQATask.h.

Referenced by AssociateRecoTracksToMCTracks(), Exec(), and Init().

TClonesArray* PndTrackingQATask::fSttHitArray

private

Definition at line 121 of file PndTrackingQATask.h.

Referenced by GetMCInfoFromIdealTrack(), and Init().

PndGeoSttPar* PndTrackingQATask::fSttParameters

private

Definition at line 134 of file PndTrackingQATask.h.

Referenced by Init(), and SetParContainers().

TClonesArray* PndTrackingQATask::fSttTubeArray

private

Definition at line 125 of file PndTrackingQATask.h.

Referenced by GetMCInfoFromIdealTrack(), and Init().

TClonesArray* PndTrackingQATask::fTrack

private

Definition at line 117 of file PndTrackingQATask.h.

Referenced by Init().

TString PndTrackingQATask::fTrackBranchName

private

Definition at line 131 of file PndTrackingQATask.h.

Referenced by Exec(), Init(), and SetTrackBranchName().

TClonesArray* PndTrackingQATask::fTrackCand

private

Definition at line 119 of file PndTrackingQATask.h.

RhoTuple* PndTrackingQATask::fTuple

private

Definition at line 141 of file PndTrackingQATask.h.

Referenced by Exec(), Finish(), and Init().

FairRootManager* PndTrackingQATask::ioman

private

Definition at line 127 of file PndTrackingQATask.h.

Referenced by GetSumOfAllValidMCHits(), and Init().

---

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

• PndTrackingQATask.h
• PndTrackingQATask.cxx