PndMvdEventAnaTask Class Reference

#include <PndMvdEventAnaTask.h>

Inheritance diagram for PndMvdEventAnaTask:

Public Member Functions
	PndMvdEventAnaTask ()
virtual	~PndMvdEventAnaTask ()
virtual void	SetParContainers ()
virtual InitStatus	Init ()
virtual void	Exec (Option_t *opt)
virtual void	Finish ()
void	DrawTracksPerEvent (TString opt="")
void	DrawHitsPerTrack (TString opt="")
void	DrawEnergyPerHit (TString opt="")
void	DrawPointRes (TString opt="")
void	DrawPointResS (TString opt="")
void	DrawPointResD (TString opt="")
void	DrawPointResM (TString opt="")
void	DrawEnergyRes (TString opt="")
void	DrawDigisPerCluster (TString opt="")
void	DrawPointResStrip (TString opt="")
void	DrawEnergyResStrip (TString opt="")
void	DrawDigisPerClusterStrip (TString opt="")
void	DrawPtRes (TString opt="")
void	DrawPRes (TString opt="")
void	DrawRiemannRes (TString opt="")
void	DrawRiemannFakes (TString opt="")
void	DrawRiemannTracksPerTrack (TString opt="")
void	DrawRiemannTracksPerTrackAdd (TString opt="")
void	DrawRiemannVertexResolutionX (TString opt="")
void	DrawRiemannVertexResolutionY (TString opt="")
void	DrawRiemannVertexResolutionZ (TString opt="")

Private Member Functions
bool	MCHitBelongsToCluster (int HitIndex, PndSdsCluster *cluster, bool pixCluster)
void	GetTrackCandsForMCTrack (std::vector< int > pixHitId, std::vector< int > stripHitId, std::vector< int > &matches, std::vector< int > &result)
int	GetRecoHit (int clIndex, bool pixel) const
std::vector< int >	GetClusters (int MCHit, bool pixel)
void	PrintClusterDigiInfo (int clIndex, std::vector< Int_t > digiInd, bool pixel)
void	PrintRecoHitInfo (int hitInd, int digiSize, TVector3 MCPos, double MCEnergy, bool pixel) const
void	PrintTrackCand (GFTrackCand *cand) const
void	Register ()
void	Reset ()
void	ProduceHits ()
FairHit *	GetFairHit (Int_t detId, Int_t hitId)
std::map< int, std::vector< int > >	AssignHitsToTracks ()
	ClassDef (PndMvdEventAnaTask, 1)

Private Attributes
TClonesArray *	fMCTracks
TClonesArray *	fMCHits
TClonesArray *	fPixDigis
TClonesArray *	fStripDigis
TClonesArray *	fPixReco
TClonesArray *	fStripReco
TClonesArray *	fPixCluster
TClonesArray *	fStripCluster
TClonesArray *	fTrackCand
std::vector< int >	fGhostCand
TH1 *	fHTracksPerEvent
TH1 *	fHHitsPerTrack
TH1 *	fHEnergyPerHit
TH1 *	fHPointRes
TH1 *	fHPointResS
TH1 *	fHPointResD
TH1 *	fHPointResM
TH1 *	fHDigisPerCluster
TH1 *	fHEnergyRes
TH1 *	fHPRes
TH1 *	fHPtRes
TH1 *	fHPointResStrip
TH1 *	fHPointResSStrip
TH1 *	fHPointResDStrip
TH1 *	fHPointResMStrip
TH1 *	fHDigisPerClusterStrip
TH1 *	fHEnergyResStrip
TH1 *	fHRiemannRes
TH1 *	fHRiemannFakes
TH1 *	fHRiemannTracksPerTrack
TH1 *	fHRiemannTracksPerTrackAdd
TH1 *	fHRiemannVertexResolutionX
TH1 *	fHRiemannVertexResolutionY
TH1 *	fHRiemannVertexResolutionZ
bool	fPrintTrack
bool	fPrintMCHit
bool	fPrintCluster
bool	fPrintPixDigis
bool	fPrintPixHit
bool	fPrintStripCluster
bool	fPrintStripDigis
bool	fPrintStripHit
bool	fPrintTrackMatch
bool	fPrintGhosts
int	fNTracks
int	fNPossibleTracks
int	fNCompleteTracks
int	fNPartTracks
int	fNNotFoundPossibleTracks
int	fNNotFoundTracks
int	fNGhostTracks
int	fEventNr
std::map< int, std::vector< int > >	fTrackPixHitIdMap
std::map< int, std::vector< int > >	fTrackStripHitIdMap

Detailed Description

Definition at line 30 of file PndMvdEventAnaTask.h.

Constructor & Destructor Documentation

PndMvdEventAnaTask::PndMvdEventAnaTask

(

)

Default constructor

Definition at line 35 of file PndMvdEventAnaTask.cxx.

                                       : FairTask("Event Display task for PANDA PndMvd"),
        fPrintTrack(true), fPrintMCHit(true), fPrintCluster(true), fPrintPixDigis(true), fPrintPixHit(true),
        fPrintStripCluster(true), fPrintStripDigis(true), fPrintStripHit(true), fPrintTrackMatch(true), fPrintGhosts(true),
        fNTracks(0), fNPossibleTracks(0), fNCompleteTracks(0), fNPartTracks(0), fNNotFoundPossibleTracks(0), fNNotFoundTracks(0),
        fNGhostTracks(0), fEventNr(0)
{
}

PndMvdEventAnaTask::~PndMvdEventAnaTask ( )

virtual

Destructor

Definition at line 46 of file PndMvdEventAnaTask.cxx.

{
}

Member Function Documentation

std::map< int, std::vector< int > > PndMvdEventAnaTask::AssignHitsToTracks ( )

private

Definition at line 640 of file PndMvdEventAnaTask.cxx.

References fMCHits, and i.

Referenced by Exec().

{
        std::map<int, std::vector<int> > result;
        for (int i = 0; i < fMCHits->GetEntriesFast(); i++){                                                                                    //get all MC Hits
                PndSdsMCPoint* myPoint = (PndSdsMCPoint*)(fMCHits->At(i));                                                                      //sort MCHits with Tracks
                //PndMCTrack* myTrack = (PndMCTrack*)(fMCTracks->At(myPoint->GetTrackID()));
                result[myPoint->GetTrackID()].push_back(i);

        }
        return result;
}

PndMvdEventAnaTask::ClassDef ( PndMvdEventAnaTask  , 1    )

private

void PndMvdEventAnaTask::DrawDigisPerCluster ( TString  opt = "" )

inline

Definition at line 61 of file PndMvdEventAnaTask.h.

References fHDigisPerCluster.

{fHDigisPerCluster->DrawClone(opt);}

void PndMvdEventAnaTask::DrawDigisPerClusterStrip ( TString  opt = "" )

inline

Definition at line 65 of file PndMvdEventAnaTask.h.

References fHDigisPerClusterStrip.

{fHDigisPerClusterStrip->DrawClone(opt);}

void PndMvdEventAnaTask::DrawEnergyPerHit ( TString  opt = "" )

inline

Definition at line 54 of file PndMvdEventAnaTask.h.

References fHEnergyPerHit.

{fHEnergyPerHit->DrawClone(opt);}

void PndMvdEventAnaTask::DrawEnergyRes ( TString  opt = "" )

inline

Definition at line 60 of file PndMvdEventAnaTask.h.

References fHEnergyRes.

{fHEnergyRes->DrawClone(opt);}

void PndMvdEventAnaTask::DrawEnergyResStrip ( TString  opt = "" )

inline

Definition at line 64 of file PndMvdEventAnaTask.h.

References fHEnergyResStrip.

{fHEnergyResStrip->DrawClone(opt);}

void PndMvdEventAnaTask::DrawHitsPerTrack ( TString  opt = "" )

inline

Definition at line 53 of file PndMvdEventAnaTask.h.

References fHHitsPerTrack.

{fHHitsPerTrack->DrawClone(opt);}

void PndMvdEventAnaTask::DrawPointRes ( TString  opt = "" )

inline

Definition at line 56 of file PndMvdEventAnaTask.h.

References fHPointRes.

{fHPointRes->DrawClone(opt);}

void PndMvdEventAnaTask::DrawPointResD ( TString  opt = "" )

inline

Definition at line 58 of file PndMvdEventAnaTask.h.

References fHPointResD.

{fHPointResD->DrawClone(opt);}

void PndMvdEventAnaTask::DrawPointResM ( TString  opt = "" )

inline

Definition at line 59 of file PndMvdEventAnaTask.h.

References fHPointResM.

{fHPointResM->DrawClone(opt);}

void PndMvdEventAnaTask::DrawPointResS ( TString  opt = "" )

inline

Definition at line 57 of file PndMvdEventAnaTask.h.

References fHPointResS.

{fHPointResS->DrawClone(opt);}

void PndMvdEventAnaTask::DrawPointResStrip ( TString  opt = "" )

inline

Definition at line 63 of file PndMvdEventAnaTask.h.

References fHPointResStrip.

{fHPointResStrip->DrawClone(opt);}

void PndMvdEventAnaTask::DrawPRes ( TString  opt = "" )

inline

Definition at line 68 of file PndMvdEventAnaTask.h.

References fHPRes.

{fHPRes->DrawClone(opt);}

void PndMvdEventAnaTask::DrawPtRes ( TString  opt = "" )

inline

Definition at line 67 of file PndMvdEventAnaTask.h.

References fHPtRes.

{fHPtRes->DrawClone(opt);}

void PndMvdEventAnaTask::DrawRiemannFakes ( TString  opt = "" )

inline

Definition at line 71 of file PndMvdEventAnaTask.h.

References fHRiemannFakes.

{fHRiemannFakes->DrawClone(opt);}

void PndMvdEventAnaTask::DrawRiemannRes ( TString  opt = "" )

inline

Definition at line 70 of file PndMvdEventAnaTask.h.

References fHRiemannRes.

{fHRiemannRes->DrawClone(opt);}

void PndMvdEventAnaTask::DrawRiemannTracksPerTrack ( TString  opt = "" )

inline

Definition at line 72 of file PndMvdEventAnaTask.h.

References fHRiemannTracksPerTrack.

{fHRiemannTracksPerTrack->DrawClone(opt);}

void PndMvdEventAnaTask::DrawRiemannTracksPerTrackAdd ( TString  opt = "" )

inline

Definition at line 73 of file PndMvdEventAnaTask.h.

References fHRiemannTracksPerTrackAdd.

{fHRiemannTracksPerTrackAdd->DrawClone(opt);}

void PndMvdEventAnaTask::DrawRiemannVertexResolutionX ( TString  opt = "" )

inline

Definition at line 75 of file PndMvdEventAnaTask.h.

References fHRiemannVertexResolutionX.

{fHRiemannVertexResolutionX->DrawClone(opt);}

void PndMvdEventAnaTask::DrawRiemannVertexResolutionY ( TString  opt = "" )

inline

Definition at line 76 of file PndMvdEventAnaTask.h.

References fHRiemannVertexResolutionY.

{fHRiemannVertexResolutionY->DrawClone(opt);}

void PndMvdEventAnaTask::DrawRiemannVertexResolutionZ ( TString  opt = "" )

inline

Definition at line 77 of file PndMvdEventAnaTask.h.

References fHRiemannVertexResolutionZ.

{fHRiemannVertexResolutionZ->DrawClone(opt);}

void PndMvdEventAnaTask::DrawTracksPerEvent ( TString  opt = "" )

inline

Definition at line 52 of file PndMvdEventAnaTask.h.

References fHTracksPerEvent.

{fHTracksPerEvent->DrawClone(opt);}

void PndMvdEventAnaTask::Exec ( Option_t *  opt )

virtual

Virtual method Exec

Definition at line 168 of file PndMvdEventAnaTask.cxx.

References PndRiemannTrack::addHit(), AssignHitsToTracks(), fEventNr, fGhostCand, fHDigisPerCluster, fHDigisPerClusterStrip, fHEnergyPerHit, fHHitsPerTrack, fHPRes, fHPtRes, fHRiemannFakes, fHRiemannRes, fHRiemannTracksPerTrack, fHRiemannTracksPerTrackAdd, fHRiemannVertexResolutionX, fHRiemannVertexResolutionY, fHRiemannVertexResolutionZ, fHTracksPerEvent, fMCHits, fMCTracks, fNCompleteTracks, fNGhostTracks, fNNotFoundPossibleTracks, fNNotFoundTracks, fNPartTracks, fNPossibleTracks, fNTracks, fPixCluster, fPrintGhosts, fPrintMCHit, fPrintTrack, fPrintTrackMatch, fStripCluster, fTrackCand, fTrackPixHitIdMap, fTrackStripHitIdMap, PndSdsCluster::GetClusterList(), GetClusters(), GFTrackCand::getCurv(), GFTrackCand::getDip(), GetFairHit(), GFTrackCand::getHit(), PndMCTrack::GetMomentum(), PndMCTrack::GetMotherID(), GFTrackCand::getNHits(), PndSdsMCPoint::GetPosition(), PndSdsMCPoint::GetPositionOut(), GetRecoHit(), PndMCTrack::GetStartVertex(), GetTrackCandsForMCTrack(), hit, i, map, n, PndRiemannTrack::n(), p, p1, p2, PndMCTrack::Print(), PndSdsMCPoint::Print(), PrintClusterDigiInfo(), PrintRecoHitInfo(), PrintTrackCand(), pt(), PndRiemannTrack::refit(), PndRiemannTrack::SetVerbose(), and PndRiemannTrack::szFit().

{
        std::map<int, std::vector<int> > mcHitMap;                                              //Track ->  MCHits
        std::map<int, std::vector<int> > trackToTrackCandMap;                   //Track -> TrackCand

        std::vector<PndRiemannTrack> riemannTracks;
        std::vector<int> MCTrackOrderRiemann;                                                   //information which riemannTrack belongs to which MCTrack;

        TVector3 MCPos, RecoPos;
        double MCEnergy;
        double TrackP, TrackPt;

        mcHitMap = AssignHitsToTracks();
        fGhostCand.clear();
        fGhostCand.resize(fTrackCand->GetEntriesFast(), 0);
        fTrackPixHitIdMap.clear();
        fTrackStripHitIdMap.clear();

        std::cout << "------------Event " << fEventNr << "-------------" << std::endl;
        fEventNr++;
        fHTracksPerEvent->Fill(mcHitMap.size());
        fNTracks += mcHitMap.size();

        for (std::map<int, std::vector<int> >::const_iterator kIt = mcHitMap.begin(); kIt!= mcHitMap.end(); kIt++){  //go through all tracks
                PndMCTrack* myTrack = (PndMCTrack*)(fMCTracks->At(kIt->first));
                std::vector<int> MChits = kIt->second;
                TrackPt = myTrack->GetMomentum().Pt();
                TrackP = myTrack->GetMomentum().Mag();
                fHHitsPerTrack->Fill(MChits.size());

                if (fPrintTrack){
                        std::cout << "<<<<<<<<<<< MCTrack >>>>>>>>>> " << std::endl;
                        myTrack->Print(kIt->first);
                        TVector3 startVertex = myTrack->GetStartVertex();
                        std::cout << "Pt: " << TrackPt << " GeV/c; P: " << TrackP << " GeV/c" << std::endl;
                        std::cout << "StartVertex: " << startVertex.X() << " " << startVertex.Y() << " " << startVertex.Z() << std::endl;
                }
                for (unsigned int p = 0; p < MChits.size(); p++){                                                                                       //go through all hits in track
                        PndSdsMCPoint* myPoint = (PndSdsMCPoint*)(fMCHits->At(MChits[p]));
                        if (fPrintMCHit){
                                std::cout << "-------------------------------" << std::endl;
                                myPoint->Print();
                        }
                        MCPos = (myPoint->GetPosition() + myPoint->GetPositionOut())*0.5;
                        MCEnergy = myPoint->GetEnergyLoss()*10E9;
                        fHEnergyPerHit->Fill(MCEnergy);

                        std::vector<int> pixCluster = GetClusters(MChits[p], true);             //Indices of all clusters belonging to one hit

                        for (unsigned int clInd = 0; clInd < pixCluster.size(); clInd++)        {

                                PndSdsCluster* myCluster = (PndSdsCluster*)(fPixCluster->At(pixCluster[clInd]));
                                std::vector<Int_t> digiInd = myCluster->GetClusterList(); //gets the list of pixel Digis belonging to the cluster
                                int recoHit = GetRecoHit(pixCluster[clInd], true);
                                fHDigisPerCluster->Fill(digiInd.size());
                                if (recoHit > -1)
                                        fTrackPixHitIdMap[kIt->first].push_back(recoHit);

                                PrintClusterDigiInfo(pixCluster[clInd], digiInd, true);
                                if (recoHit < 0)
                                        std::cout << "-W- No Reco Hit found!" << std::endl;
                                else
                                        PrintRecoHitInfo(recoHit, digiInd.size(), MCPos, MCEnergy, true);
                        }

                        std::vector<int> stripCluster = GetClusters(MChits[p], false);

                        int hitCount = 0;
                        int oldRecoHit = -1;
                        for (unsigned int clInd = 0; clInd < stripCluster.size(); clInd++)      {
                                int recoHit = -1;

                                PndSdsCluster* myCluster =      (PndSdsCluster*)(fStripCluster->At(stripCluster[clInd]));
                                std::vector<Int_t> digiInd = myCluster->GetClusterList(); //gets the list of pixel Digis belonging to the cluster
                                recoHit = GetRecoHit(stripCluster[clInd], false);

                                fHDigisPerClusterStrip->Fill(digiInd.size());
                                std::cout << "RecoHit: " << recoHit << std::endl;
                                if (recoHit > -1){
                                        hitCount++;
                                        if (oldRecoHit != recoHit){
                                                fTrackStripHitIdMap[kIt->first].push_back(recoHit);
                                                oldRecoHit = recoHit;
                                        }
                                }
                                PrintClusterDigiInfo(stripCluster[clInd], digiInd, false);
                                //std::cout << " hitCount: " << hitCount << " oldReco " << oldRecoHit <<  " recoHit: " << recoHit << std::endl;
                                if (recoHit > -1){
                                        if (hitCount > 1){
                                                PrintRecoHitInfo(recoHit, digiInd.size(), MCPos, MCEnergy, false);
                                                if ((oldRecoHit > -1) && (oldRecoHit != recoHit))
                                                        PrintRecoHitInfo(oldRecoHit, digiInd.size(), MCPos, MCEnergy, false);
                                        }
                                }
                        }
                }
                std::vector<int> pixHits = fTrackPixHitIdMap[kIt->first];
                std::vector<int> stripHits = fTrackStripHitIdMap[kIt->first];

                std::cout << std::endl;
                std::cout << "TrackID " << kIt->first << ": ";
                for (unsigned int testInd = 0; testInd < pixHits.size(); testInd++)
                        std::cout << " 5/" << pixHits[testInd];

                for (unsigned int testInd = 0; testInd < stripHits.size(); testInd++)
                        std::cout << " 4/" << stripHits[testInd];
                std::cout << std::endl;

                std::cout << "MCHitMap: ";
                for (unsigned int testInd = 0; testInd < mcHitMap[kIt->first].size(); testInd++)
                        std::cout << mcHitMap[kIt->first].at(testInd) << " ";
                std::cout << std::endl;

                std::vector<int> matches;
                std::vector<int> candidates;
                GetTrackCandsForMCTrack(pixHits, stripHits, matches, candidates);
                std::cout << "TrackCands for MCTrack: ";
                for (unsigned int i = 0; i < candidates.size(); i++) std::cout << candidates[i];
                std::cout << std::endl;
                trackToTrackCandMap[kIt->first] = candidates;

                int TrackMatch = 0;
                int oldmatches = 0;
                int highestMatch=-1;
                for (unsigned int i = 0; i < matches.size(); i++){
                        if (oldmatches < matches[i]){
                                oldmatches = matches[i];
                                highestMatch = i;
                        }
                        GFTrackCand* myCand = (GFTrackCand*)fTrackCand->At(candidates[i]);
                        PndRiemannTrack myRiemannTrack;
                        MCTrackOrderRiemann.push_back(kIt->first);
                        myRiemannTrack.SetVerbose(1);
                        for (UInt_t j = 0; j < myCand->getNHits(); j++){
                                unsigned int detId, hitId;
                                myCand->getHit(j, detId, hitId);
                                PndRiemannHit hit(GetFairHit(detId, hitId));
                                myRiemannTrack.addHit(hit);
                        }

                        myRiemannTrack.refit();
                        myRiemannTrack.szFit();
                        TVectorD n = myRiemannTrack.n();
                        //std::cout << "RiemannNormal: "  << n[0] << " " << n[1] << " " << n[2] << std::endl;
                        riemannTracks.push_back(myRiemannTrack);

                        double curv = myCand->getCurv();
                        double dip = myCand->getDip();
                        double pt = 1/curv;
                        pt*=2;
                        pt*=0.00299792;
                        unsigned int detId, hitId;
                        if (matches[i]>2){
                                TrackMatch++;
                                myCand->getHit(0,detId, hitId);
                                if (detId > 0)
                                        fHRiemannFakes->Fill(myCand->getNHits()- matches[i]);
                                else fHRiemannFakes->Fill(myCand->getNHits()- matches[i] -1);
                        }
                        if (fPrintTrackMatch){
                                myCand->getHit(0,detId, hitId);
                                std::cout << std::endl;
                                std::cout << "HitMatch: " << matches[i] << std::endl;
                                std::cout << "Hits in Track: " << myCand->getNHits() << " Difference: ";
                                if (detId > 0) std::cout << myCand->getNHits() - matches[i] << std::endl;
                                else std::cout << myCand->getNHits() - matches [i] -1 << std::endl;

                                PrintTrackCand(myCand);
                                std::cout << "Pt: " << pt << " GeV/c " << " P: " << pt/dip << " GeV/c" << std::endl;
                                std::cout << "Pt error: " << TrackPt - pt << " P error: " << TrackP - pt/dip << std::endl;
                                std::cout << "TrackID: " << kIt->first << " mcHitMap.size: " << mcHitMap[kIt->first].size() << " matches: " << matches[i] << std::endl;
                                std::cout << "Missing Hits: " << mcHitMap[kIt->first].size() - matches[i] << std::endl;
                                if (mcHitMap[kIt->first].size() < (myCand->getNHits()-1))
                                        fHRiemannRes->Fill(-2);                                         //more hits than expected
                        }
                }

                if (mcHitMap[kIt->first].size() > 2){
                        if (mcHitMap[kIt->first].size() > 3){
                                fNPossibleTracks++;
                                if (oldmatches == 0)
                                        fNNotFoundPossibleTracks++;
                        }
                        else if (myTrack->GetMotherID() < 0){
                                fNPossibleTracks++;
                                if (oldmatches == 0)
                                        fNNotFoundPossibleTracks++;
                        }
                }
                if (oldmatches == 0)
                        fNNotFoundTracks++;


                if (matches.size() > 0){                                        // there are riemann tracks to a MC Track
                        GFTrackCand* myCand = (GFTrackCand*)fTrackCand->At(candidates[highestMatch]);
                        double curv = myCand->getCurv();
                        double dip = myCand->getDip();
                        double pt = 1/curv;
                        pt*=2;
                        pt*=0.00299792;
                        fHPtRes->Fill(TrackPt - pt);
                        fHPRes->Fill(TrackP - pt/dip);
                        fHRiemannRes->Fill(mcHitMap[kIt->first].size() - matches[highestMatch]);
                        if (mcHitMap[kIt->first].size() - matches[highestMatch] == 0)
                                fNCompleteTracks++;
                        else fNPartTracks++;
                }
                std::cout << "Found TracksPerTrack: " << TrackMatch;
                if (mcHitMap[kIt->first].size() > 2) std::cout << " 3Hits+"     << std::endl;
                if (mcHitMap[kIt->first].size() > 2) fHRiemannTracksPerTrackAdd->Fill(TrackMatch);
                fHRiemannTracksPerTrack->Fill(TrackMatch);
        }
        if (riemannTracks.size() > 1){
                std::cout << riemannTracks.size() << " Riemann Tracks used!" << std::endl;
                for (unsigned int i = 0; i < riemannTracks.size() - 1; i++){
                        for (unsigned int j = i + 1; j < riemannTracks.size(); j++)     {
                                TVector3 p1, p2;
                                //riemannTracks[i].refit();
                                //riemannTracks[i].szFit();
                                //std::cout << "Track: " << i << std::endl;
                                //riemannTracks[i].PrintHits();

                                //riemannTracks[j].refit();
                                //riemannTracks[j].szFit();
                                //std::cout << "Track: " << j << std::endl;
                                //riemannTracks[j].PrintHits();

                                std::cout << "Vertex Test for: " << MCTrackOrderRiemann[i] << " and " << MCTrackOrderRiemann[j] << std::endl;
                                int result = riemannTracks[i].calcIntersection(riemannTracks[j], p1, p2);

                                if (result == 1){
                                        std::cout << "Vertex1: " << p1.X() << " " << p1.Y() << " " << p1.Z() << std::endl;
                                        std::cout << "Vertex2: " << p2.X() << " " << p2.Y() << " " << p2.Z() << std::endl;
                                        PndMCTrack* myMCTrack = (PndMCTrack*)(fMCTracks->At(MCTrackOrderRiemann[i]));
                                        TVector3 MCVertex = myMCTrack->GetStartVertex();
                                        std::cout << "MCVertex " << MCTrackOrderRiemann[i] << ": "<< MCVertex.X() << " " << MCVertex.Y() << " " << MCVertex.Z() << std::endl;
                                        MCVertex -= (p1+p2)*0.5;
                                        std::cout << "Difference: " << MCVertex.X() << " " << MCVertex.Y() << " " << MCVertex.Z() << std::endl;
                                        fHRiemannVertexResolutionX->Fill(MCVertex.X());
                                        fHRiemannVertexResolutionY->Fill(MCVertex.Y());
                                        fHRiemannVertexResolutionZ->Fill(MCVertex.Z());


                                }
                        }
                }
        }
        if (fPrintGhosts){
                std::cout << std::endl;
                std::cout << "----Ghost TrackCandidates:-------" << std::endl;
                for (unsigned int tcIndex = 0; tcIndex < fGhostCand.size(); tcIndex++){
                        if (fGhostCand[tcIndex] < 3){
                                GFTrackCand* myTrackCand = (GFTrackCand*)fTrackCand->At(tcIndex);
                                PrintTrackCand(myTrackCand);
                                fHRiemannRes->Fill(-1); //Ghosts
                                fNGhostTracks++;
                        }
                }
                std::cout << std::endl;
        }
}

void PndMvdEventAnaTask::Finish ( )

virtual

Definition at line 430 of file PndMvdEventAnaTask.cxx.

References fNCompleteTracks, fNGhostTracks, fNNotFoundPossibleTracks, fNNotFoundTracks, fNPartTracks, fNPossibleTracks, and fNTracks.

{
        std::cout << std::endl;
        std::cout << "--------- Summary Track Fitting -----------" << std::endl;
        std::cout << "Number of Tracks: " << fNTracks << std::endl;
        std::cout << "Number of Tracks with more than 3 hits: " << fNPossibleTracks << std::endl;
        std::cout << (double)fNCompleteTracks / fNTracks * 100<< " % found completely" << std::endl;
        std::cout << (double)fNCompleteTracks / fNPossibleTracks * 100<< " % of possible tracks found completely" << std::endl;
        std::cout << (double)fNPartTracks / fNTracks * 100<< " % found partially" << std::endl;
        std::cout << (double)fNPartTracks / fNPossibleTracks * 100<< " % of possible tracks found partially" << std::endl;
        std::cout << (double)fNNotFoundPossibleTracks / fNPossibleTracks * 100 << " % of possible tracks not found" << std::endl;
        std::cout << (double)fNNotFoundTracks / fNTracks * 100<< " % of  Tracks not found in total" << std::endl;
        std::cout << (double)fNGhostTracks / fNTracks * 100<< " % of Ghost Tracks" << std::endl;
}

std::vector< int > PndMvdEventAnaTask::GetClusters ( int  MCHit, bool  pixel  )

private

Definition at line 462 of file PndMvdEventAnaTask.cxx.

References fPixCluster, fStripCluster, and MCHitBelongsToCluster().

Referenced by Exec().

{
        TClonesArray* cluster;

        std::vector<int> result;

        if (pixel == true){
                cluster = fPixCluster;
        }
        else{
                cluster = fStripCluster;
        }

        if (cluster != 0) {
                for (int clIndex = 0; clIndex < cluster->GetEntriesFast(); clIndex++){          //go through all pixel clusters
                        PndSdsCluster* myCluster = (PndSdsCluster*)(cluster->At(clIndex));
                        if (MCHitBelongsToCluster(MCHit, myCluster, pixel)){
                                result.push_back(clIndex);
                        }
                }
        }
        return result;
}

FairHit * PndMvdEventAnaTask::GetFairHit ( Int_t  detId, Int_t  hitId  )

private

Definition at line 446 of file PndMvdEventAnaTask.cxx.

References fPixReco, fStripReco, and p.

Referenced by Exec().

{
        FairHit* p;

        if (detId == 5){
                return (FairHit *) fPixReco->At(hitId);
        }
        else if (detId == 4){
                return p=(FairHit *) fStripReco->At(hitId);
        }

        std::cout << "-E- FairRiemannTrackCandDraw::GetFairHit : Unknown Detector with ID: " << detId << std::endl;
        return 0;
}

int PndMvdEventAnaTask::GetRecoHit ( int  clIndex, bool  pixel  ) const

private

Definition at line 486 of file PndMvdEventAnaTask.cxx.

References fPixReco, fStripReco, PndSdsHit::GetBotIndex(), PndSdsHit::GetClusterIndex(), and reco().

Referenced by Exec().

{
        TClonesArray* reco;

        if (pixel == true){
                reco = fPixReco;
        }
        else{
                reco = fStripReco;
        }
        if (reco != 0){
                for (int hitIndex = 0; hitIndex < reco->GetEntriesFast(); hitIndex++){
                        PndSdsHit* myHit = (PndSdsHit*)reco->At(hitIndex);
                        if ((myHit->GetClusterIndex() == clIndex) || myHit->GetBotIndex() == clIndex){ //test if RecoHit belongs to cluster
                                return hitIndex;
                        }
                }
        }
        return -1;
}

void PndMvdEventAnaTask::GetTrackCandsForMCTrack ( std::vector< int >  pixHitId, std::vector< int >  stripHitId, std::vector< int > &  matches, std::vector< int > &  result  )

private

Definition at line 601 of file PndMvdEventAnaTask.cxx.

References fGhostCand, fTrackCand, GFTrackCand::getHit(), GFTrackCand::getNHits(), and i.

Referenced by Exec().

{
        unsigned int detId, hitId;
        int hitMatch = 0;

        if (fTrackCand != 0){
                for (int i = 0; i < fTrackCand->GetEntriesFast(); i++){
                        GFTrackCand* myTrackCand = (GFTrackCand*)fTrackCand->At(i);
                        hitMatch = 0;
                        for (unsigned int j = 0; j < myTrackCand->getNHits(); j++){
                                myTrackCand->getHit(j, detId, hitId);
                                //std::cout << "DetId: " << detId << " HitId: " << hitId << std::endl;
                                if (detId == 5){
                                        for (unsigned int k = 0; k < pixHitId.size(); k++){
                                                //std::cout << "PixHitId: " << pixHitId[k] << std::endl;
                                                if ((int)hitId == pixHitId[k])
                                                        hitMatch++;
                                        }
                                }
                                else if (detId == 4){
                                        for (unsigned int k = 0; k < stripHitId.size(); k++){
                                                //std::cout << "StripHitId: " << stripHitId[k] << std::endl;
                                                if ((int)hitId == stripHitId[k])
                                                        hitMatch++;
                                        }
                                }
                        }
                        //std::cout << "internal HitMatch: " << hitMatch << std::endl;
                        if (hitMatch > 2){
                                matches.push_back(hitMatch);
                                result.push_back(i);
                        }
                        if (fGhostCand[i] < hitMatch)
                                fGhostCand[i] = hitMatch;
                }
        }
}

InitStatus PndMvdEventAnaTask::Init ( )

virtual

Definition at line 51 of file PndMvdEventAnaTask.cxx.

References fHDigisPerCluster, fHDigisPerClusterStrip, fHEnergyPerHit, fHEnergyRes, fHEnergyResStrip, fHHitsPerTrack, fHPointRes, fHPointResD, fHPointResDStrip, fHPointResM, fHPointResMStrip, fHPointResS, fHPointResSStrip, fHPointResStrip, fHPRes, fHPtRes, fHRiemannFakes, fHRiemannRes, fHRiemannTracksPerTrack, fHRiemannTracksPerTrackAdd, fHRiemannVertexResolutionX, fHRiemannVertexResolutionY, fHRiemannVertexResolutionZ, fHTracksPerEvent, fMCHits, fMCTracks, fPixCluster, fPixDigis, fPixReco, fStripCluster, fStripDigis, fStripReco, and fTrackCand.

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

        // Get input arrays
        fMCTracks = (TClonesArray*) ioman->GetObject("MCTrack");
        if (!fMCTracks){
                std::cout << "-W- PndMvdEventAnaTask::Init: "<< "No MCTrack" << " array!" << std::endl;
                return kERROR;
        }

        fMCHits = (TClonesArray*) ioman->GetObject("MVDPoint");
        if ( !fMCHits)  {
                std::cout << "-W- PndMvdEventAnaTask::Init: "<< "No MVDPoint"<<" array!" << std::endl;
                return kERROR;
        }

        fStripDigis = (TClonesArray*) ioman->GetObject("MVDStripDigis");
        if ( !fStripDigis){
                std::cout << "-W- PndMvdEventAnaTask::Init: "<< "No MVDStripDigis"<<" array!" << std::endl;
        }

        fPixDigis = (TClonesArray*) ioman->GetObject("MVDPixelDigis");
        if ( !fPixDigis){
                std::cout << "-W- PndMvdEventAnaTask::Init: "<< "No MVDPixDigis"<<" array!" << std::endl;
        }

        fPixReco = (TClonesArray*) ioman->GetObject("MVDHitsPixel");
        if ( !fPixReco) {
                std::cout << "-W- PndMvdEventAnaTask::Init: "<< "No MVDHitsPixel"<<" array!" << std::endl;
        }

        fStripReco = (TClonesArray*) ioman->GetObject("MVDHitsStrip");
        if ( !fStripReco) {
                std::cout << "-W- PndMvdEventAnaTask::Init: "<< "No MVDHitsStrip" << " array!" << std::endl;
        }

        fPixCluster = (TClonesArray*) ioman->GetObject("MVDClusterCand");
        if ( !fPixCluster){
                std::cout << "-W- PndMvdEventAnaTask::Init: "<< "No MVDClusterCand"     <<" array!" << std::endl;
        }

        fStripCluster = (TClonesArray*) ioman->GetObject("MVDStripClusterCand");
        if ( !fStripCluster)    {
                std::cout << "-W- PndMvdEventAnaTask::Init: " << "No MVDStripClusterCand" <<" array!" << std::endl;
        }

        fTrackCand = (TClonesArray*) ioman->GetObject("MVDRiemannTrackCand");
                if ( !fTrackCand)       {
                        std::cout << "-W- PndMvdEventAnaTask::Init: " << "No MVDRiemannTrackCand" <<" array!" << std::endl;
                        fTrackCand = (TClonesArray*) ioman->GetObject("MVDIdealTrackCand");
                        if (!fTrackCand)
                                std::cout << "-W- PndMvdEventAnaTask::Init: " << "No MVDIdealTrackCand" <<" array!" << std::endl;

                }

        fHTracksPerEvent = new TH1I("HTracksPerEvent", "Tracks per Event", 21, -0.5, 20.5);
        fHHitsPerTrack = new TH1I("HHitsPerTrack", "Hits per Track", 21,0.5,20.5);
        fHEnergyPerHit = new TH1D("HEnergyPerHit","Energy per Hit", 200, 0, 10000000);

        fHPointRes = new TH1D("HPointRes", "Point Resolution", 1000, 0,0.1);
        fHPointRes->SetLineColor(1);
        fHPointResS = new TH1D("HPointResS", "Point Resolution", 1000, 0,0.1);
        fHPointResS->SetLineColor(3);
        fHPointResD = new TH1D("HPointResD", "Point Resolution", 1000, 0,0.1);
        fHPointResD->SetLineColor(4);
        fHPointResM = new TH1D("HPointResM", "Point Resolution", 1000, 0,0.1);
        fHPointResM->SetLineColor(5);

        fHDigisPerCluster = new TH1I("HDigisPerCluster","Digis per Cluster", 20, 0, 20);
        fHEnergyRes = new TH1D("HEnergyRes", "Energy Resolution", 1000, -100000, 100000);
        fHPRes = new TH1D("HPRes","Momentum Resolution", 1000, -5,5);
        fHPtRes = new TH1D("HPtRes","Transversal Momentum Resolution", 1000, -5,5);

        fHPointResStrip = new TH1D("HPointResStrip", "Point Resolution Strips", 1000, 0,0.1);
        fHPointResStrip->SetLineColor(6);
        fHPointResSStrip = new TH1D("HPointResSStrip", "Point Resolution Strip", 1000, 0,0.1);
        fHPointResSStrip->SetLineColor(7);
        fHPointResDStrip = new TH1D("HPointResDStrip", "Point Resolution Strip", 1000, 0,0.1);
        fHPointResDStrip->SetLineColor(8);
        fHPointResMStrip = new TH1D("HPointResMStrip", "Point Resolution Strip", 1000, 0,0.1);
        fHPointResMStrip->SetLineColor(9);

        fHDigisPerClusterStrip = new TH1I("HDigisPerClusterStrip","Digis per Cluster Strips", 20, 0, 20);
        fHDigisPerClusterStrip->SetLineColor(2);
        fHEnergyResStrip = new TH1D("HEnergyResStrip", "Energy Resolution Strips", 1000, -100000, 100000);
        fHEnergyResStrip->SetLineColor(2);

        fHRiemannRes = new TH1I("HRiemannRes", "Quality of the Riemann Trackfinding", 16,-5.5,10.5);
        fHRiemannFakes = new TH1I("HRiemannFakes", "Wrong assign hits in Track", 16, -5.5,10.5);
        fHRiemannFakes->SetLineColor(2);
        fHRiemannTracksPerTrack = new TH1I("HRiemannTracksPerTrack", "Found Tracks per MC Track", 11, -0.5, 10.5);
        fHRiemannTracksPerTrackAdd = new TH1I("HRiemannTracksPerTrackAdd", "Found Tracks per MC Track", 11, -0.5, 10.5);
        fHRiemannTracksPerTrackAdd->SetLineColor(2);

        fHRiemannVertexResolutionX = new TH1D("HRiemannVertexResolutionX","Difference between reco vertex and MC vertex", 1000, -1, 1);
        fHRiemannVertexResolutionY = new TH1D("HRiemannVertexResolutionY","Difference between reco vertex and MC vertex", 1000, -1, 1);
        fHRiemannVertexResolutionZ = new TH1D("HRiemannVertexResolutionZ","Difference between reco vertex and MC vertex", 1000, -1, 1);

  return kSUCCESS;
}

bool PndMvdEventAnaTask::MCHitBelongsToCluster ( int  HitIndex, PndSdsCluster *  cluster, bool  pixCluster  )

private

Definition at line 583 of file PndMvdEventAnaTask.cxx.

References fPixDigis, fStripDigis, PndSdsCluster::GetClusterList(), PndSdsDigi::GetIndex(), PndSdsDigi::GetNIndices(), and i.

Referenced by GetClusters().

{
        bool result = false;
        std::vector<Int_t> clusterList = cluster->GetClusterList();
        for (unsigned int i = 0; i < clusterList.size() && result == false; i++){
                PndSdsDigi* myDigi;
                if (pixCluster)
                        myDigi = (PndSdsDigi*)(fPixDigis->At(clusterList[i]));
                else
                        myDigi = (PndSdsDigi*)(fStripDigis->At(clusterList[i]));
                for (int j = 0; j < myDigi->GetNIndices(); j++)
                        if (myDigi->GetIndex(j) == HitIndex)
                                result = true;
        }
        return result;
}

void PndMvdEventAnaTask::PrintClusterDigiInfo ( int  clIndex, std::vector< Int_t >  digiInd, bool  pixel  )

private

Definition at line 507 of file PndMvdEventAnaTask.cxx.

References fPixDigis, fPrintCluster, fPrintPixDigis, fStripDigis, PndSdsDigi::Print(), and s.

Referenced by Exec().

{
        TClonesArray* digis;

        if (pixel){
                digis = fPixDigis;
        }
        else{
                digis = fStripDigis;
        }

        if (digis == 0)
                fPrintPixDigis = false;

        if (fPrintCluster)
                std::cout << "Hit belongs to cluster " << clIndex << std::endl;
        if (fPrintPixDigis)     {
                for (unsigned int s = 0; s < digiInd.size(); s++)               {
                        PndSdsDigi* myDigi = (PndSdsDigi*)(digis->At(digiInd[s]));
                        if (pixel) ((PndSdsDigiPixel*)myDigi)->Print();
                        else ((PndSdsDigiStrip*)myDigi)->Print();
                }
        }
}

void PndMvdEventAnaTask::PrintRecoHitInfo ( int  hitInd, int  digiSize, TVector3  MCPos, double  MCEnergy, bool  pixel  ) const

private

Definition at line 533 of file PndMvdEventAnaTask.cxx.

References fHEnergyRes, fHEnergyResStrip, fHPointRes, fHPointResD, fHPointResDStrip, fHPointResM, fHPointResMStrip, fHPointResS, fHPointResSStrip, fHPointResStrip, fPixReco, fPrintPixHit, fStripReco, PndSdsHit::GetEloss(), PndSdsHit::GetPosition(), PndSdsHit::Print(), and reco().

Referenced by Exec().

{
        TClonesArray* reco;
        TH1* hPointRes;
        TH1* hPointResS;
        TH1* hPointResD;
        TH1* hPointResM;
        TH1* hEnergyRes;

        if (pixel){
                reco = fPixReco;

                hPointRes       = fHPointRes;
                hPointResS = fHPointResS;
                hPointResD = fHPointResD;
                hPointResM = fHPointResM;
                hEnergyRes = fHEnergyRes;
        }
        else{
                reco = fStripReco;

                hPointRes       = fHPointResStrip;
                hPointResS = fHPointResSStrip;
                hPointResD = fHPointResDStrip;
                hPointResM = fHPointResMStrip;
                hEnergyRes = fHEnergyResStrip;
        }

        PndSdsHit* myHit = (PndSdsHit*)reco->At(hitInd);
        if (fPrintPixHit)
        {
                if (pixel) std::cout << "PixHit: ";
                else std::cout << "StripHit: ";
                std::cout << hitInd << std::endl; //write out RecoHit
                myHit->Print();
        }
        TVector3 RecoPos = myHit->GetPosition();
        double RecoEnergy = myHit->GetEloss()*10E9;
        TVector3 result = MCPos - RecoPos;
        ((TH1D*)hPointRes)->Fill(result.Mag());
        if (digiSize == 1)
                hPointResS->Fill(result.Mag());
        if (digiSize == 2)
                hPointResD->Fill(result.Mag());
        if (digiSize > 2)
                hPointResM->Fill(result.Mag());
        ((TH1D*)hEnergyRes)->Fill(MCEnergy-RecoEnergy);
}

void PndMvdEventAnaTask::PrintTrackCand ( GFTrackCand *  cand ) const

private

Definition at line 652 of file PndMvdEventAnaTask.cxx.

References GFTrackCand::getHit(), GFTrackCand::getNHits(), hit, and i.

Referenced by Exec().

{
  unsigned int det, hit;
     //std::cout << "TrackCand: " << cand->getCurv() << " curv, " << cand->getDip() << " dip, " << (int)(cand->inverted()) << " inverted." << "\n";
     for (unsigned int i = 0; i < cand->getNHits(); i++){
         cand->getHit(i, det, hit);
         std::cout << det << "/" << hit << " ";
     }
     std::cout << "\n";
}

void PndMvdEventAnaTask::ProduceHits ( )

private

void PndMvdEventAnaTask::Register ( )

private

void PndMvdEventAnaTask::Reset ( )

private

void PndMvdEventAnaTask::SetParContainers ( )

virtual

Virtual method Init

Definition at line 158 of file PndMvdEventAnaTask.cxx.

{
  // Get Base Container
//  FairRun* ana = FairRun::Instance();
//  FairRuntimeDb* rtdb=ana->GetRuntimeDb();

}

Member Data Documentation

int PndMvdEventAnaTask::fEventNr

private

Definition at line 145 of file PndMvdEventAnaTask.h.

Referenced by Exec().

std::vector<int> PndMvdEventAnaTask::fGhostCand

private

Definition at line 94 of file PndMvdEventAnaTask.h.

Referenced by Exec(), and GetTrackCandsForMCTrack().

TH1* PndMvdEventAnaTask::fHDigisPerCluster

private

Definition at line 104 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHDigisPerClusterStrip

private

Definition at line 113 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHEnergyPerHit

private

Definition at line 98 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHEnergyRes

private

Definition at line 105 of file PndMvdEventAnaTask.h.

Referenced by DrawEnergyRes(), Init(), and PrintRecoHitInfo().

TH1* PndMvdEventAnaTask::fHEnergyResStrip

private

Definition at line 114 of file PndMvdEventAnaTask.h.

Referenced by DrawEnergyResStrip(), Init(), and PrintRecoHitInfo().

TH1* PndMvdEventAnaTask::fHHitsPerTrack

private

Definition at line 97 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHPointRes

private

Definition at line 100 of file PndMvdEventAnaTask.h.

Referenced by DrawPointRes(), Init(), and PrintRecoHitInfo().

TH1* PndMvdEventAnaTask::fHPointResD

private

Definition at line 102 of file PndMvdEventAnaTask.h.

Referenced by DrawPointResD(), Init(), and PrintRecoHitInfo().

TH1* PndMvdEventAnaTask::fHPointResDStrip

private

Definition at line 111 of file PndMvdEventAnaTask.h.

Referenced by Init(), and PrintRecoHitInfo().

TH1* PndMvdEventAnaTask::fHPointResM

private

Definition at line 103 of file PndMvdEventAnaTask.h.

Referenced by DrawPointResM(), Init(), and PrintRecoHitInfo().

TH1* PndMvdEventAnaTask::fHPointResMStrip

private

Definition at line 112 of file PndMvdEventAnaTask.h.

Referenced by Init(), and PrintRecoHitInfo().

TH1* PndMvdEventAnaTask::fHPointResS

private

Definition at line 101 of file PndMvdEventAnaTask.h.

Referenced by DrawPointResS(), Init(), and PrintRecoHitInfo().

TH1* PndMvdEventAnaTask::fHPointResSStrip

private

Definition at line 110 of file PndMvdEventAnaTask.h.

Referenced by Init(), and PrintRecoHitInfo().

TH1* PndMvdEventAnaTask::fHPointResStrip

private

Definition at line 109 of file PndMvdEventAnaTask.h.

Referenced by DrawPointResStrip(), Init(), and PrintRecoHitInfo().

TH1* PndMvdEventAnaTask::fHPRes

private

Definition at line 106 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHPtRes

private

Definition at line 107 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHRiemannFakes

private

Definition at line 117 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHRiemannRes

private

Definition at line 116 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHRiemannTracksPerTrack

private

Definition at line 118 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHRiemannTracksPerTrackAdd

private

Definition at line 119 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHRiemannVertexResolutionX

private

Definition at line 121 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHRiemannVertexResolutionY

private

Definition at line 122 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHRiemannVertexResolutionZ

private

Definition at line 123 of file PndMvdEventAnaTask.h.

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

TH1* PndMvdEventAnaTask::fHTracksPerEvent

private

Definition at line 96 of file PndMvdEventAnaTask.h.

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

TClonesArray* PndMvdEventAnaTask::fMCHits

private

Definition at line 85 of file PndMvdEventAnaTask.h.

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

TClonesArray* PndMvdEventAnaTask::fMCTracks

private

Definition at line 84 of file PndMvdEventAnaTask.h.

Referenced by Exec(), and Init().

int PndMvdEventAnaTask::fNCompleteTracks

private

Definition at line 139 of file PndMvdEventAnaTask.h.

Referenced by Exec(), and Finish().

int PndMvdEventAnaTask::fNGhostTracks

private

Definition at line 143 of file PndMvdEventAnaTask.h.

Referenced by Exec(), and Finish().

int PndMvdEventAnaTask::fNNotFoundPossibleTracks

private

Definition at line 141 of file PndMvdEventAnaTask.h.

Referenced by Exec(), and Finish().

int PndMvdEventAnaTask::fNNotFoundTracks

private

Definition at line 142 of file PndMvdEventAnaTask.h.

Referenced by Exec(), and Finish().

int PndMvdEventAnaTask::fNPartTracks

private

Definition at line 140 of file PndMvdEventAnaTask.h.

Referenced by Exec(), and Finish().

int PndMvdEventAnaTask::fNPossibleTracks

private

Definition at line 138 of file PndMvdEventAnaTask.h.

Referenced by Exec(), and Finish().

int PndMvdEventAnaTask::fNTracks

private

Definition at line 137 of file PndMvdEventAnaTask.h.

Referenced by Exec(), and Finish().

TClonesArray* PndMvdEventAnaTask::fPixCluster

private

Definition at line 90 of file PndMvdEventAnaTask.h.

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

TClonesArray* PndMvdEventAnaTask::fPixDigis

private

Definition at line 86 of file PndMvdEventAnaTask.h.

Referenced by Init(), MCHitBelongsToCluster(), and PrintClusterDigiInfo().

TClonesArray* PndMvdEventAnaTask::fPixReco

private

Definition at line 88 of file PndMvdEventAnaTask.h.

Referenced by GetFairHit(), GetRecoHit(), Init(), and PrintRecoHitInfo().

bool PndMvdEventAnaTask::fPrintCluster

private

Definition at line 128 of file PndMvdEventAnaTask.h.

Referenced by PrintClusterDigiInfo().

bool PndMvdEventAnaTask::fPrintGhosts

private

Definition at line 135 of file PndMvdEventAnaTask.h.

Referenced by Exec().

bool PndMvdEventAnaTask::fPrintMCHit

private

Definition at line 127 of file PndMvdEventAnaTask.h.

Referenced by Exec().

bool PndMvdEventAnaTask::fPrintPixDigis

private

Definition at line 129 of file PndMvdEventAnaTask.h.

Referenced by PrintClusterDigiInfo().

bool PndMvdEventAnaTask::fPrintPixHit

private

Definition at line 130 of file PndMvdEventAnaTask.h.

Referenced by PrintRecoHitInfo().

bool PndMvdEventAnaTask::fPrintStripCluster

private

Definition at line 131 of file PndMvdEventAnaTask.h.

bool PndMvdEventAnaTask::fPrintStripDigis

private

Definition at line 132 of file PndMvdEventAnaTask.h.

bool PndMvdEventAnaTask::fPrintStripHit

private

Definition at line 133 of file PndMvdEventAnaTask.h.

bool PndMvdEventAnaTask::fPrintTrack

private

Definition at line 126 of file PndMvdEventAnaTask.h.

Referenced by Exec().

bool PndMvdEventAnaTask::fPrintTrackMatch

private

Definition at line 134 of file PndMvdEventAnaTask.h.

Referenced by Exec().

TClonesArray* PndMvdEventAnaTask::fStripCluster

private

Definition at line 91 of file PndMvdEventAnaTask.h.

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

TClonesArray* PndMvdEventAnaTask::fStripDigis

private

Definition at line 87 of file PndMvdEventAnaTask.h.

Referenced by Init(), MCHitBelongsToCluster(), and PrintClusterDigiInfo().

TClonesArray* PndMvdEventAnaTask::fStripReco

private

Definition at line 89 of file PndMvdEventAnaTask.h.

Referenced by GetFairHit(), GetRecoHit(), Init(), and PrintRecoHitInfo().

TClonesArray* PndMvdEventAnaTask::fTrackCand

private

Definition at line 92 of file PndMvdEventAnaTask.h.

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

std::map<int, std::vector<int> > PndMvdEventAnaTask::fTrackPixHitIdMap

private

Definition at line 147 of file PndMvdEventAnaTask.h.

Referenced by Exec().

std::map<int, std::vector<int> > PndMvdEventAnaTask::fTrackStripHitIdMap

private

Definition at line 148 of file PndMvdEventAnaTask.h.

Referenced by Exec().

---

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

• PndMvdEventAnaTask.h
• PndMvdEventAnaTask.cxx