PndForwardTrackFinderTask Class Reference

#include <PndForwardTrackFinderTask.h>

Inheritance diagram for PndForwardTrackFinderTask:

Public Member Functions
	PndForwardTrackFinderTask ()
virtual	~PndForwardTrackFinderTask ()
virtual InitStatus	Init ()
virtual void	SetParContainers ()
virtual void	Exec (Option_t *opt)
virtual void	FinishEvent ()
virtual void	Finish ()
void	saveCombined (vector< PndLineApproximation > combined, Int_t branch, Int_t branchID, Bool_t useOrgHits)
void	saveCorrectedTracklets (map< Int_t, vector< PndFtsExpandedTrackCand >>)
void	saveTrackCollection (vector< PndTrackCollection > coll, Bool_t withOrgHits)

Private Member Functions
void	createStatictcs (vector< PndTrackCollection > c, vector< PndLineApproximation > a)
PndLineApproximation	getBest (PndTrackCollection &c, vector< PndLineApproximation > a)
Int_t	getMcId (vector< PndFtsHit * > hits)
	ClassDef (PndForwardTrackFinderTask, 1)

Private Attributes
Int_t	eventNumber
TClonesArray *	fHits
FairRootManager *	fIoman
std::vector< PndTrackCand >	fFirstTrackCand
string	branchName = "FTSHitErr"
TClonesArray *	planes
TClonesArray *	planesHit
TClonesArray *	fFirstTrackCandArray
TClonesArray *	correctedTracklets
TClonesArray *	correctedHits
TClonesArray *	fLayerTracks
TClonesArray *	fLayerTracksHits
TClonesArray *	fGlobalTracks
TClonesArray *	fGlobalTracksHits
TClonesArray *	fFinalSolution
TClonesArray *	fTrackCollection
TClonesArray *	fTrackCollectionHits
TClonesArray *	rootBranches [5]
PndFtsCellTrackletGenerator *	fPndFtsCellTrackletGenerator
PndFtsLineApproximator *	fPndFtsLineApproximator
PndTrackCombiner *	fPndTrackCombiner
PndModuleCombiner *	fModuleCombiner
PndWayFollower *	fWayFollower
Int_t	combinedTracksHitNum
Int_t	combinedTracksTrackNum
map< Int_t, PndFtsHit * >	fOriginalHits
Int_t	dists [20]
Int_t	angles [20]

Detailed Description

Definition at line 28 of file PndForwardTrackFinderTask.h.

Constructor & Destructor Documentation

PndForwardTrackFinderTask::PndForwardTrackFinderTask ( )

inline

Definition at line 31 of file PndForwardTrackFinderTask.h.

References PndModuleCombiner::compAngle, PndTrackCombiner::compAngle, PndModuleCombiner::compDist, PndTrackCombiner::compDist, PndTrackCombiner::compQuali, PndModuleCombiner::hitAddT, and PndWayFollower::qualiT.

                                    : eventNumber(0) {
                PndTrackCombiner::compDist  = 0.8;
                PndTrackCombiner::compAngle = 7;
                PndModuleCombiner::compDist = 0.8;
                PndModuleCombiner::compAngle = 7;
                PndTrackCombiner::compQuali = 700;
                PndWayFollower::qualiT = 4000;
                PndModuleCombiner::hitAddT = 3;
        }

PndForwardTrackFinderTask::~PndForwardTrackFinderTask ( )

virtual

Definition at line 5 of file PndForwardTrackFinderTask.cxx.

                                                      {

}

Member Function Documentation

PndForwardTrackFinderTask::ClassDef ( PndForwardTrackFinderTask  , 1    )

private

void PndForwardTrackFinderTask::createStatictcs ( vector< PndTrackCollection >  c, vector< PndLineApproximation >  a  )

private

Definition at line 257 of file PndForwardTrackFinderTask.cxx.

References angle, angles, dists, Double_t, PndFtsLineComparator::getAngle2D(), getBest(), PndLine::getDir(), PndFtsLineComparator::getDist2D(), PndTrackCollection::getLastLine(), PndLineApproximation::getLine(), PndLine::getP1(), PndLine::getRating(), i, and PndFtsLineComparator::setZValue().

                                                                                                          {
        PndFtsLineComparator comparator(0,0);
        for(size_t i=0;i<c.size();i++){
                PndTrackCollection coll = c[i];
                PndLineApproximation appr = getBest(coll,a);
                if(appr.getLine().getRating()==-1) continue;
                PndLine l1 = coll.getLastLine();
                PndLine l2 = appr.getLine();
                comparator.setZValue((l1.getP1()[2]+l2.getP1()[2])/2);
                Double_t dist = comparator.getDist2D(l1.getP1(),l2.getP1(),l1.getDir(),l2.getDir());
                Double_t angle = comparator.getAngle2D(l1.getDir(),l2.getDir());
//              cout << "Dist=" << (Int_t)(dist/5) << endl;
//              cout << "Angle=" << (Int_t)(angle/5) << endl;;
                if(dist>=100) dists[19]++;
                else dists[(Int_t)(dist/5)]++;
                if(angle>=100) angles[19]++;
                else angles[(Int_t)(angle/5)]++;
        }
}

void PndForwardTrackFinderTask::Exec ( Option_t *  opt )

virtual

Definition at line 52 of file PndForwardTrackFinderTask.cxx.

References PndModuleCombiner::addUnusedHits(), c, PndTrackCombiner::combine(), combinedTracksHitNum, combinedTracksTrackNum, PndModuleCombiner::combineModules(), PndFtsLineApproximator::createExpandedTrackCand(), eventNumber, fFirstTrackCand, fHits, PndFtsCellTrackletGenerator::findTracks(), fIoman, fModuleCombiner, PndWayFollower::followLines(), fOriginalHits, fPndFtsCellTrackletGenerator, fPndFtsLineApproximator, fPndTrackCombiner, fWayFollower, PndFtsExpandedTrackCand::getLineApproximations(), PndFtsCellTrackletGenerator::getTracklets(), PndFtsHit::GetTubeID(), hit, hits, i, PndWayFollower::init(), PndTrackCombiner::init(), map, PndFtsCellTrackletGenerator::reset(), saveCombined(), saveCorrectedTracklets(), saveTrackCollection(), and PndFtsCellTrackletGenerator::setHits().

                                              {
        std::cout
                        << ">>>>>>>>>>>>>>====================PndForwardTrackFinderTask::Exec====================<<<<<<<<<<<<<<"
                        << std::endl;
        std::cout << "EventNumber:" << eventNumber++ << std::endl;
        //reset the TrackletGenerator
        fPndFtsCellTrackletGenerator->reset();
        //get the hits and add to the TrackletGenerator
        std::vector<PndFtsHit*> hits;
        for (int i = 0; i < fHits->GetEntries(); i++) {
                PndFtsHit* hit = (PndFtsHit*) (fHits->At(i));
                hit->SetEntryNr(FairLink(-1, fIoman->GetEntryNr(), fIoman->GetBranchId("FTSHit"), i));
                //hit->SetEntryNr(FairLink(-1, fIoman->GetEntryNr(), fIoman->GetBranchId("FTSHitErr"), i));
                hits.push_back(hit);
                fOriginalHits[hit->GetTubeID()]=hit;
        }
        fPndFtsCellTrackletGenerator->setHits(hits);

        fPndFtsCellTrackletGenerator->findTracks();

        //create first track cand
        map<Int_t, vector<PndTrackCand>> result = fPndFtsCellTrackletGenerator->getTracklets();
        fFirstTrackCand.clear();
        for (map<Int_t, vector<PndTrackCand>>::iterator it = result.begin();
                        it != result.end(); it++) {
                for(size_t i=0;i<it->second.size();i++)
                        fFirstTrackCand.push_back(it->second[i]);
        }
//      cout << fFirstTrackCand.size() << " Tracks found " << endl;
        if(fFirstTrackCand.size() > 100){
                fFirstTrackCand.clear();
                result.clear();
                cout << "Too mutch tracks for reconstruction" << endl;
        }

        //save data in root-branch
        for (size_t i = 0; i < fFirstTrackCand.size(); i++) {
                new ((*fFirstTrackCandArray)[i]) PndTrackCand(fFirstTrackCand[i]); //PndTrackCand* myCand =  //[R.K.03/2017] unused variable
        }

        //create expanded track cands
        map<Int_t, vector<PndFtsExpandedTrackCand>> expandedTrackCands;
        for (map<Int_t, vector<PndTrackCand>>::iterator it = result.begin();
                                it != result.end(); it++) {
                vector<PndTrackCand> myCands = it->second;
                for(size_t i=0;i<myCands.size();i++){
                        PndTrackCand myCand = myCands[i];
                        PndFtsExpandedTrackCand c = fPndFtsLineApproximator->createExpandedTrackCand(myCand);
                        if(c.getLineApproximations().size()!=0)
                                expandedTrackCands[it->first].push_back(c);
                }
        }
        saveCorrectedTracklets(expandedTrackCands);

        //combine the expanded track cands
        fPndTrackCombiner->init(expandedTrackCands);
        // cout << "----------------------combine module 1" << endl;
        vector<PndLineApproximation> combined1 = fPndTrackCombiner->combine(0);
        // cout << "-------------------------combine module 2" << endl;
        vector<PndLineApproximation> combined2 = fPndTrackCombiner->combine(1);
        // cout << "-----------------------------combine module 5" << endl;
        vector<PndLineApproximation> combined5 = fPndTrackCombiner->combine(4);
        // cout << "-------------------------------combine module 6" << endl;
        vector<PndLineApproximation> combined6 = fPndTrackCombiner->combine(5);

        combinedTracksHitNum = 0;
        combinedTracksTrackNum = 0;
        // cout << "save layer tracks " << endl;
        saveCombined(combined1,0,fIoman->GetBranchId("LayerTracksHits"),kFALSE);
        saveCombined(combined2,0,fIoman->GetBranchId("LayerTracksHits"),kFALSE);
        saveCombined(combined5,0,fIoman->GetBranchId("LayerTracksHits"),kFALSE);
        saveCombined(combined6,0,fIoman->GetBranchId("LayerTracksHits"),kFALSE);

        vector<PndLineApproximation> m12 = fModuleCombiner->combineModules(combined1,combined2);
        vector<PndLineApproximation> m56 = fModuleCombiner->combineModules(combined5,combined6);

        //way follower
        fWayFollower->init(m12,expandedTrackCands);
        vector<PndTrackCollection> ptc = fWayFollower->followLines(8);

        //createStatictcs(ptc,m56);

        fModuleCombiner->combineModules(ptc,m56);
        fModuleCombiner->addUnusedHits(hits,ptc);
        saveTrackCollection(ptc,kFALSE);

        //save
        combinedTracksHitNum = 0;
        combinedTracksTrackNum = 0;
        // cout << "save global " << endl;
        saveCombined(m12,2,fIoman->GetBranchId("GlobalTracksHits"),kFALSE);
        // cout << "save final solution" << endl;
        saveTrackCollection(ptc,kTRUE);


}

void PndForwardTrackFinderTask::Finish ( )

virtual

Definition at line 163 of file PndForwardTrackFinderTask.cxx.

                                       {
//      cout << "Dists:" << endl;
//      for(int i=0;i<20;i++)
//              cout << dists[i] <<";";
//      cout << endl <<"Angles:" << endl;
//      for(int i=0;i<20;i++)
//              cout << angles[i] <<";";
}

void PndForwardTrackFinderTask::FinishEvent ( )

virtual

Definition at line 148 of file PndForwardTrackFinderTask.cxx.

References correctedHits, correctedTracklets, fFinalSolution, fFirstTrackCandArray, fGlobalTracks, fGlobalTracksHits, fLayerTracks, fLayerTracksHits, fTrackCollection, fTrackCollectionHits, planes, and planesHit.

                                            {
        fFirstTrackCandArray->Delete();
        fLayerTracks->Delete();
        correctedHits->Delete();
        correctedTracklets->Delete();
        fLayerTracksHits->Delete();
        fGlobalTracks->Delete();
        fGlobalTracksHits->Delete();
        planes->Delete();
        planesHit->Delete();
        fTrackCollection->Delete();
        fTrackCollectionHits->Delete();
        fFinalSolution->Delete();
}

PndLineApproximation PndForwardTrackFinderTask::getBest ( PndTrackCollection &  c, vector< PndLineApproximation >  a  )

private

Definition at line 277 of file PndForwardTrackFinderTask.cxx.

References PndTrackCollection::getHits(), PndLineApproximation::getLine(), getMcId(), i, and PndLine::setRating().

Referenced by createStatictcs().

                                                                                                           {
        Int_t mc = getMcId(c.getHits());
        for(size_t i=0;i<a.size();i++){
                Int_t mc2 = getMcId(a[i].getHits());
                if(mc==mc2) return a[i];
        }
        PndLineApproximation appr;
        appr.getLine().setRating(-1);
        return appr;
}

Int_t PndForwardTrackFinderTask::getMcId ( vector< PndFtsHit * >  hits )

private

Definition at line 288 of file PndForwardTrackFinderTask.cxx.

References fIoman, fOriginalHits, hit, i, m, and p.

Referenced by getBest().

                                                               {
        Int_t mcTrackBranchId = fIoman->GetBranchId("MCTrack");
        vector<Int_t> trackIDs;
        for(size_t i=0;i<hits.size();i++){
                PndFtsHit* hit = fOriginalHits[hits[i]->GetTubeID()];
                FairLink link = hit->GetEntryNr();
                PndFtsPoint* p = (PndFtsPoint*) fIoman->GetCloneOfLinkData(link);
                FairMultiLinkedData mld = p->GetLinksWithType(mcTrackBranchId);
                FairLink linksToMc = mld.GetLink(0);
                int trackID = linksToMc.GetIndex();
                trackIDs.push_back(trackID);
        }
        Int_t maxID = 0;
        Int_t maxVal = -1;
        map<Int_t,Int_t> m;
        for(size_t i=0;i<trackIDs.size();i++){
                m[trackIDs[i]]++;
                if(m[trackIDs[i]] > maxVal){
                        maxVal = m[trackIDs[i]];
                        maxID = trackIDs[i];
                }
        }
        return maxID;
}

InitStatus PndForwardTrackFinderTask::Init ( )

virtual

Definition at line 13 of file PndForwardTrackFinderTask.cxx.

References angles, correctedHits, correctedTracklets, dists, fFinalSolution, fFirstTrackCandArray, fGlobalTracks, fGlobalTracksHits, fHits, fIoman, fLayerTracks, fLayerTracksHits, fModuleCombiner, fPndFtsCellTrackletGenerator, fPndFtsLineApproximator, fPndTrackCombiner, fTrackCollection, fTrackCollectionHits, fWayFollower, i, planes, planesHit, and rootBranches.

                                           {
        fIoman = FairRootManager::Instance();
        //load hits
        fHits = (TClonesArray*) fIoman->GetObject("FTSHit"); //correct hits
        //planes
        planes = fIoman->Register("Planes", "PndTrack","FTS", kTRUE);
        planesHit = fIoman->Register("PlanesHits", "PndFtsHit","FTS", kTRUE);
        //tracklets
        fFirstTrackCandArray = fIoman->Register("FirstTrackCand", "PndTrackCand","FTS", kTRUE);
        //corrected tracklets
        correctedTracklets = fIoman->Register("CorrectedTracklets", "PndTrack","FTS", kTRUE);
        correctedHits = fIoman->Register("CorrectedHits", "PndFtsHit","FTS", kTRUE);
        //layer tracks
        fLayerTracks = fIoman->Register("LayerTracks", "PndTrack","FTS", kTRUE);
        fLayerTracksHits = fIoman->Register("LayerTracksHits", "PndFtsHit","FTS", kTRUE);
        //global tracks befor and after magnet
        fGlobalTracks = fIoman->Register("GlobalTracks", "PndTrack","FTS", kTRUE);
        fGlobalTracksHits = fIoman->Register("GlobalTracksHits", "PndFtsHit","FTS", kTRUE);
        //final Solution
        fFinalSolution = fIoman->Register("FinalSolution", "PndTrack","FTS", kTRUE);
        //track collection
        fTrackCollection = fIoman->Register("TrackCollection", "PndTrack","FTS", kTRUE);
        fTrackCollectionHits = fIoman->Register("TrackCollectionHits", "PndFtsHit","FTS", kTRUE);
        //fill the root-branches array
        rootBranches[0]=fLayerTracks;
        rootBranches[1]=fLayerTracksHits;
        rootBranches[2]=fGlobalTracks;
        rootBranches[3]=fGlobalTracksHits;
        fPndFtsCellTrackletGenerator = new PndFtsCellTrackletGenerator();
        fPndFtsLineApproximator = new PndFtsLineApproximator();
        fPndTrackCombiner = new PndTrackCombiner(planes,planes);
        fModuleCombiner = new PndModuleCombiner();
        fWayFollower = new PndWayFollower(planes,planesHit);

        for(int i=0;i<20;i++)dists[i]=0;
        for(int i=0;i<20;i++)angles[i]=0;
        return kSUCCESS;
}

void PndForwardTrackFinderTask::saveCombined	(	vector< PndLineApproximation >	combined,
		Int_t	branch,
		Int_t	branchID,
		Bool_t	useOrgHits
	)

Definition at line 172 of file PndForwardTrackFinderTask.cxx.

References PndTrackCand::AddHit(), c, combinedTracksHitNum, combinedTracksTrackNum, fIoman, fOriginalHits, PndLine::getDir(), PndLineApproximation::getHits(), PndLineApproximation::getLine(), PndLine::getP1(), PndFtsHit::GetTubeID(), hit, i, rootBranches, and v.

Referenced by Exec().

                                                                                                                               {
        if (branchID == -1) {
                std::cout << "PndForwardTrackFinderTask::saveCombined branchID == -1" << std::endl;
        }
        TVector3 v(1, 1, 1);
        for (size_t i = 0; i < combined.size(); i++) {
                PndLineApproximation l = combined[i];
                PndLine l2 = l.getLine();
                PndTrackCand c;
                FairTrackParP tp1(v, v, v, v, 1, v, v, v);
                FairTrackParP tp2(l2.getP1(), 3 * l2.getDir().Unit(), v, v, 1, v, v, v);
                for (size_t j = 0; j < l.getHits().size(); j++) {
                        PndFtsHit* hit = l.getHits()[j];
                        if(!useOrgHits){
                                hit->SetEntryNr(FairLink(-1, fIoman->GetEntryNr(),branchID, combinedTracksHitNum));
                                new ((*(rootBranches[branch+1]))[combinedTracksHitNum++]) PndFtsHit(*hit); //PndFtsHit* myHit =  //[R.K.03/2017] unused variable
                        } else {
                                hit = fOriginalHits[hit->GetTubeID()];
                        }
                        c.AddHit(hit->GetEntryNr(), j);
                }
                new ((*(rootBranches[branch]))[combinedTracksTrackNum++]) PndTrack(tp1, tp2, c); //PndTrack* myCand =  //[R.K.03/2017] unused variable
        }
}

void PndForwardTrackFinderTask::saveCorrectedTracklets

(

map< Int_t, vector< PndFtsExpandedTrackCand >>

res

)

Definition at line 197 of file PndForwardTrackFinderTask.cxx.

References PndTrackCand::AddHit(), fIoman, PndLine::getDir(), PndLineApproximation::getHits(), PndLineApproximation::getLine(), PndFtsExpandedTrackCand::getLineApproximations(), PndLine::getP1(), hit, i, map, res, and v.

Referenced by Exec().

                                                                                                     {
        Int_t trackNum = 0;
        Int_t hitNum= 0;
        for (map<Int_t, vector<PndFtsExpandedTrackCand>>::iterator it = res.begin();it != res.end(); it++) {
                vector<PndFtsExpandedTrackCand> etc = it->second;
                for(size_t i=0;i<etc.size();i++){
                        PndFtsExpandedTrackCand cand = etc[i];
                        vector<PndLineApproximation> approxs = cand.getLineApproximations();
                        for(size_t j=0;j<approxs.size();j++){
                                PndLineApproximation approx = approxs[j];
                                PndTrackCand trackCand;
                                for (size_t k = 0; k < approx.getHits().size(); k++) {
                                        PndFtsHit* hit = approx.getHits()[k];
                                        hit->SetEntryNr(FairLink(-1, fIoman->GetEntryNr(),fIoman->GetBranchId("CorrectedHits"),hitNum));
                                        new ((*correctedHits)[hitNum++]) PndFtsHit(*hit);//PndFtsHit* myHit =  //[R.K.03/2017] unused variable
                                        trackCand.AddHit(hit->GetEntryNr(), k);
                                }
                                TVector3 v(1, 1, 1);
                                FairTrackParP tp1(approx.getLine().getP1(),
                                                3 * approx.getLine().getDir().Unit(), v, v, 1, v, v, v);
                                FairTrackParP tp2(v, 2 * v, v, v, 1, v, v, v);
                                //PndTrack* myCand = 
        new ((*correctedTracklets)[trackNum++]) PndTrack(tp1, tp2, trackCand);
//                              std::cout << "PndForwardTrackFinderTask::saveCorrectedTracklets myCand: " << *myCand << std::endl;
                        }
                }
        }
}

void PndForwardTrackFinderTask::saveTrackCollection	(	vector< PndTrackCollection >	coll,
		Bool_t	withOrgHits
	)

Definition at line 226 of file PndForwardTrackFinderTask.cxx.

References a, PndTrackCand::AddHit(), c, fIoman, fOriginalHits, PndTrackCollection::getCurrLine(), PndLine::getDir(), PndLineApproximation::getHits(), PndLineApproximation::getLine(), PndTrackCollection::getLines(), PndLine::getP1(), PndTrackCollection::getPndTrack(), hit, i, and v.

Referenced by Exec().

                                                                                                     {
        Int_t trackNum = 0;
        Int_t hitNum = 0;
        TVector3 v(1, 1, 1);
        for(size_t k=0;k<coll.size();k++){
                PndTrackCollection c = coll[k];
                if(withOrgHits){
                        new ((*fFinalSolution)[trackNum++]) PndTrack(c.getPndTrack(fOriginalHits));//PndTrack* myCand =  //[R.K.03/2017] unused variable
                } else {
                        vector<PndLineApproximation> *approx = c.getLines();
                        for(size_t i=0;i<approx->size();i++){
                                PndLineApproximation a = (*approx)[i];
                                PndTrackCand trackCand;
                                for(size_t j=0;j<a.getHits().size();j++){
                                        PndFtsHit* hit = a.getHits()[j];
                                        hit->SetEntryNr(FairLink(-1, fIoman->GetEntryNr(),fIoman->GetBranchId("TrackCollectionHits"),hitNum));
                                        new ((*fTrackCollectionHits)[hitNum++]) PndFtsHit(*hit);//PndFtsHit* myHit =  //[R.K.03/2017] unused variable
                                        trackCand.AddHit(hit->GetEntryNr(), j);
                                }
                                FairTrackParP tp1(a.getLine().getP1(),3 * a.getLine().getDir().Unit(), v, v, 1, v, v, v);
                                FairTrackParP tp2(v, 2 * v, v, v, 1, v, v, v);
                                new ((*fTrackCollection)[trackNum++]) PndTrack(tp1, tp2, trackCand);//PndTrack* myCand =  //[R.K.03/2017] unused variable
                        }
                        FairTrackParP tp1(c.getCurrLine().getP1(),3 * c.getCurrLine().getDir().Unit(), v, v, 1, v, v, v);
                        FairTrackParP tp2(v, 2 * v, v, v, 1, v, v, v);
                        PndTrackCand  trackCand;
                        new ((*fTrackCollection)[trackNum++]) PndTrack(tp1, tp2, trackCand);//PndTrack* myCand =  //[R.K.03/2017] unused variable
                }
        }
}

void PndForwardTrackFinderTask::SetParContainers ( )

virtual

Definition at line 9 of file PndForwardTrackFinderTask.cxx.

                                                 {

}

Member Data Documentation

Int_t PndForwardTrackFinderTask::angles[20]

private

Definition at line 93 of file PndForwardTrackFinderTask.h.

Referenced by createStatictcs(), and Init().

string PndForwardTrackFinderTask::branchName = "FTSHitErr"

private

Definition at line 60 of file PndForwardTrackFinderTask.h.

Int_t PndForwardTrackFinderTask::combinedTracksHitNum

private

Definition at line 84 of file PndForwardTrackFinderTask.h.

Referenced by Exec(), and saveCombined().

Int_t PndForwardTrackFinderTask::combinedTracksTrackNum

private

Definition at line 85 of file PndForwardTrackFinderTask.h.

Referenced by Exec(), and saveCombined().

TClonesArray* PndForwardTrackFinderTask::correctedHits

private

Definition at line 66 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

TClonesArray* PndForwardTrackFinderTask::correctedTracklets

private

Definition at line 65 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

Int_t PndForwardTrackFinderTask::dists[20]

private

Definition at line 92 of file PndForwardTrackFinderTask.h.

Referenced by createStatictcs(), and Init().

Int_t PndForwardTrackFinderTask::eventNumber

private

Definition at line 54 of file PndForwardTrackFinderTask.h.

Referenced by Exec().

TClonesArray* PndForwardTrackFinderTask::fFinalSolution

private

Definition at line 71 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

std::vector<PndTrackCand> PndForwardTrackFinderTask::fFirstTrackCand

private

Definition at line 59 of file PndForwardTrackFinderTask.h.

Referenced by Exec().

TClonesArray* PndForwardTrackFinderTask::fFirstTrackCandArray

private

Definition at line 64 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

TClonesArray* PndForwardTrackFinderTask::fGlobalTracks

private

Definition at line 69 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

TClonesArray* PndForwardTrackFinderTask::fGlobalTracksHits

private

Definition at line 70 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

TClonesArray* PndForwardTrackFinderTask::fHits

private

Definition at line 57 of file PndForwardTrackFinderTask.h.

Referenced by Exec(), and Init().

FairRootManager* PndForwardTrackFinderTask::fIoman

private

Definition at line 58 of file PndForwardTrackFinderTask.h.

Referenced by Exec(), getMcId(), Init(), saveCombined(), saveCorrectedTracklets(), and saveTrackCollection().

TClonesArray* PndForwardTrackFinderTask::fLayerTracks

private

Definition at line 67 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

TClonesArray* PndForwardTrackFinderTask::fLayerTracksHits

private

Definition at line 68 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

PndModuleCombiner* PndForwardTrackFinderTask::fModuleCombiner

private

Definition at line 80 of file PndForwardTrackFinderTask.h.

Referenced by Exec(), and Init().

map<Int_t,PndFtsHit*> PndForwardTrackFinderTask::fOriginalHits

private

Definition at line 87 of file PndForwardTrackFinderTask.h.

Referenced by Exec(), getMcId(), saveCombined(), and saveTrackCollection().

PndFtsCellTrackletGenerator* PndForwardTrackFinderTask::fPndFtsCellTrackletGenerator

private

Definition at line 77 of file PndForwardTrackFinderTask.h.

Referenced by Exec(), and Init().

PndFtsLineApproximator* PndForwardTrackFinderTask::fPndFtsLineApproximator

private

Definition at line 78 of file PndForwardTrackFinderTask.h.

Referenced by Exec(), and Init().

PndTrackCombiner* PndForwardTrackFinderTask::fPndTrackCombiner

private

Definition at line 79 of file PndForwardTrackFinderTask.h.

Referenced by Exec(), and Init().

TClonesArray* PndForwardTrackFinderTask::fTrackCollection

private

Definition at line 72 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

TClonesArray* PndForwardTrackFinderTask::fTrackCollectionHits

private

Definition at line 73 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

PndWayFollower* PndForwardTrackFinderTask::fWayFollower

private

Definition at line 81 of file PndForwardTrackFinderTask.h.

Referenced by Exec(), and Init().

TClonesArray* PndForwardTrackFinderTask::planes

private

Definition at line 62 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

TClonesArray* PndForwardTrackFinderTask::planesHit

private

Definition at line 63 of file PndForwardTrackFinderTask.h.

Referenced by FinishEvent(), and Init().

TClonesArray* PndForwardTrackFinderTask::rootBranches[5]

private

Definition at line 75 of file PndForwardTrackFinderTask.h.

Referenced by Init(), and saveCombined().

---

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

• PndForwardTrackFinderTask.h
• PndForwardTrackFinderTask.cxx