PndRiemannTrackFinder Class Reference

#include <PndRiemannTrackFinder.h>

Inheritance diagram for PndRiemannTrackFinder:

Public Member Functions
	PndRiemannTrackFinder ()
virtual	~PndRiemannTrackFinder ()
void	FindTracks ()
	Main function to start the riemann track finding. More...
void	MergeTracks ()
void	SetHits (std::vector< FairHit * > hits)
void	AddHits (std::vector< FairHit * > hits, Int_t branchId)
	Replaces the existing array of hits with a new one. More...
void	AddHits (TClonesArray *hits, Int_t branchId)
	Appends the new array of hits to the existing one. More...
void	AddHit (FairHit *hit)
void	SetVerbose (int val)
	Adds one new hit to the array of hits. More...
int	NTracks ()
PndRiemannTrack	GetTrack (int i)
	Returns the number of found tracks. More...
PndTrack	GetPndTrack (int i, double B)
	Returns the track with the index i. More...
std::set< Int_t >	GetTrackCandidates (int i)
std::vector< PndTrackCand >	GetTrackCand ()
	Returns the hits belonging to track i. More...
std::vector< PndTrackCand >	GetMergedTrackCands ()
PndTrackCand	GetTrackCand (int i)
double	HitDistance (FairHit *h1, FairHit *h2)
	Calculates the distance between two hits. More...
int	HitTooClose (std::set< Int_t > hitsInUse, FairHit *newHit, double threshold)
	returns if and which hit was too close to the hit which is tested More...
void	SetMaxPlaneDistance (double val)
void	SetMaxSZDist (double val)
void	SetMaxSZChi2 (double val)
void	SetMinPointDist (double val)
void	SetUseZeroPos (bool val)
void	SetMinNumberOfHits (int val)
void	SetCurvDiff (double val)
void	SetDipDiff (double val)

Protected Member Functions
std::vector< std::set< Int_t > >	GetStartTracks ()
bool	CheckHitDistance (int hit1, int hit2)
	Tests if the distance is larger than fMinPointDistance. More...
bool	CheckSZ (PndRiemannTrack aTrack)
	Tests the results of the sz fit. More...
bool	CheckRiemannHit (PndRiemannTrack *track, PndRiemannHit *hit)
bool	CheckHitInSameSensor (int hit1, int hit2)
	Tests if hits in the same sensor are selected. More...
bool	CheckHitInTrack (std::set< int > hitIds, int hit)
	Check if this HitId is used in the track already. More...
bool	CheckZeroPassing (std::set< int > hitIds, int hit)
	If the track contains (0,0) all points have to go forward or all have to go backward. More...
PndRiemannTrack	CreateRiemannTrack (std::set< Int_t > aHits)
	Creates a PndRiemannTrack from an array of indices of Hits. More...
bool	TrackExists (std::set< Int_t > hitsInTrack)
std::vector< int >	FindTracksWithSimilarParameters (int TrackInd, std::vector< int > &TracksToTest, double curvDiff, double dipDiff)
std::vector< int >	FindTracksWithSimilarHits (std::vector< int > &TracksToTest, std::vector< PndTrackCand > tempTrCnd, std::vector< int > &tempKillAfter)
	---------—added by me More...
void	RemoveTrack (int TrackInd, std::vector< int > &TrackList)
PndTrackCand	CreateOneTrackCand (std::vector< int > tracks, std::vector< PndTrackCand > tempTrCnd)

Protected Attributes
std::vector< FairHit * >	fHits
	Vector of all FairHits used for track finding (fitting) More...
std::vector< PndRiemannTrack >	fTracks
	Resulting Riemann Tracks. More...
std::vector< std::set< Int_t > >	fHitsInTracks
	Vector of indizes which hits where used in which track. More...
std::vector< PndTrackCand >	fTrackCand
	List of track candidates. More...
std::vector< std::pair< double, double > >	fCurvAndDipOfCand
	Curvature and dip of fPndTrackCand. More...
std::vector< PndTrackCand >	fMergedTrackCand
std::vector< std::set< int > >	fHitsTooClose
	matrix of TrackNr and hits which are too close to one of the three starting points More...
std::map< int, FairLink >	fMapHitToID
	map to convert the list of hits back into a FairLink More...
std::map< FairLink, int >	fMapIDtoHit
	map to convert the list of detID/hitID hits into the list of hits for track finding More...
double	fMaxPlaneDist
	Distance cut between new point and riemann plane. More...
double	fMaxSZDist
	Distance cut between s-z coordinate of a new point and the sz-fit of the hits in the track. More...
double	fMinPointDist
	Minimum distance between two points to use them as point for the base plane. More...
double	fMaxSZChi2
	Maximum allowed Chi2 in an sz fit. More...
int	fMinNumberOfHits
	Minimum number of hits in track necessary for a match. More...
double	fCurvDiff
	TrackMerger parameter. More...
double	fDipDiff
	TrackMerger parameter. More...
double	fMagField
	size of the magnetic field in Tesla More...
int	fVerbose
bool	fUseZeroPos

Detailed Description

Definition at line 15 of file PndRiemannTrackFinder.h.

Constructor & Destructor Documentation

PndRiemannTrackFinder::PndRiemannTrackFinder

(

)

Definition at line 8 of file PndRiemannTrackFinder.cxx.

References fHits, fMapHitToID, fMapIDtoHit, fUseZeroPos, and pos.

                                            : fMaxPlaneDist(1), fMaxSZDist(1),fMinPointDist(1), fMaxSZChi2(1),fMinNumberOfHits(4), fCurvDiff(0.05), fDipDiff(0.05), fMagField(2.0), fVerbose(0), fUseZeroPos(false)
{
        if (fUseZeroPos){
                TVector3 pos(0.0,0.0,0.0);
                TVector3 dpos(0.1,0.1,0.1);
                FairHit* ZeroHit = new FairHit(-1, pos, dpos, -1);
                fHits.push_back(ZeroHit);
                FairLink myID;
                fMapHitToID[fHits.size()-1]=myID;
                fMapIDtoHit[myID] = fHits.size()-1;
        }
}

PndRiemannTrackFinder::~PndRiemannTrackFinder ( )

virtual

Definition at line 21 of file PndRiemannTrackFinder.cxx.

References fHits, and fUseZeroPos.

{
        if (fUseZeroPos)
                delete(fHits[0]);
}

Member Function Documentation

void PndRiemannTrackFinder::AddHit ( FairHit *  hit )

inline

Definition at line 26 of file PndRiemannTrackFinder.h.

References fHits.

{fHits.push_back(hit);};                                                

void PndRiemannTrackFinder::AddHits	(	std::vector< FairHit * >	hits,
		Int_t	branchId
	)

Replaces the existing array of hits with a new one.

Appends the new array of hits to the existing one

Definition at line 27 of file PndRiemannTrackFinder.cxx.

References fHits, fMapHitToID, fMapIDtoHit, and i.

{
        Int_t startSize = 0; //= fHits.size();
        for (size_t i = 0; i < hits.size(); i++){
                fHits.push_back(hits[i]);
                FairHit* myHit = fHits[i];
                FairLink myID;
                if (myHit->GetEntryNr().GetIndex() < 0){
                        myID = FairLink(branchId, startSize + i);
                }
                else
                        myID = myHit->GetEntryNr();
                fMapHitToID[fHits.size()-1]=myID;
                fMapIDtoHit[myID] = fHits.size()-1;
        }
}

void PndRiemannTrackFinder::AddHits	(	TClonesArray *	hits,
		Int_t	branchId
	)

Appends the new array of hits to the existing one.

Definition at line 44 of file PndRiemannTrackFinder.cxx.

References fHits, fMapHitToID, fMapIDtoHit, and i.

{
        Int_t startSize = 0;//= fHits.size();
        for (int i = 0; i < hits->GetEntries(); i++){
                FairHit* myHit = (FairHit*)(hits->At(i));
                fHits.push_back(myHit);
                FairLink myID;
                if (myHit->GetEntryNr().GetIndex() < 0){
                        myID = FairLink(-1, -1, branchId, startSize + i, 1);
                }
                else
                        myID = myHit->GetEntryNr();
                fMapHitToID[fHits.size()-1]=myID;
                fMapIDtoHit[myID] = fHits.size()-1;
        }
}

bool PndRiemannTrackFinder::CheckHitDistance ( int  hit1, int  hit2  )

protected

Tests if the distance is larger than fMinPointDistance.

Definition at line 238 of file PndRiemannTrackFinder.cxx.

References fHits, fMinPointDist, fVerbose, and HitDistance().

Referenced by FindTracks(), PndMvdSttGemRiemannTrackFinder::FindTracks(), PndMvdSttGemRiemannTrackFinder::GetStartTracks(), GetStartTracks(), and PndMvdSttGemRiemannTrackFinder::GetTooCloseHitsInLayer().

{
        double dist = HitDistance(fHits[hit1], fHits[hit2]);
        if (dist < fMinPointDist)
        {
                if (fVerbose > 1) std::cout << "Hits: " << hit1 << " " << hit2 << " too close " << dist << std::endl;
                return false;
        }
        return true;
}

bool PndRiemannTrackFinder::CheckHitInSameSensor ( int  hit1, int  hit2  )

protected

Tests if hits in the same sensor are selected.

Definition at line 305 of file PndRiemannTrackFinder.cxx.

References fHits.

Referenced by PndMvdSttGemRiemannTrackFinder::GetStartTracks(), and GetStartTracks().

{
        FairHit* first = fHits[hit1];
        FairHit* second = fHits[hit2];

        if (first->GetDetectorID() != 1 || first->GetDetectorID() != 2)
                return false;

        if(((PndSdsHit*)first)->GetSensorID() == ((PndSdsHit*)second)->GetSensorID()){
                std::cout << hit1 << " " << hit2 <<" in Same Sensor: " << ((PndSdsHit*)first)->GetSensorID() << std::endl;
                return true;
        }
        return false;
}

bool PndRiemannTrackFinder::CheckHitInTrack ( std::set< int >  hitIds, int  hit  )

protected

Check if this HitId is used in the track already.

Definition at line 320 of file PndRiemannTrackFinder.cxx.

References fVerbose.

Referenced by PndMvdSttGemRiemannTrackFinder::FindTracks().

{
        for (std::set<int>::iterator iter = hitIds.begin(); iter != hitIds.end(); iter++){
                if (*iter == hit){
                        if (fVerbose > 1) std::cout << "-I- PndRiemannTrackFinder::CheckHitInTrack - Hit: " << hit << " already in track!" << std::endl;
                        return true;
                }
        }
        return false;
}

bool PndRiemannTrackFinder::CheckRiemannHit ( PndRiemannTrack *  track, PndRiemannHit *  hit  )

protected

Definition at line 331 of file PndRiemannTrackFinder.cxx.

References PndRiemannTrack::calcSZChi2(), PndRiemannTrack::dist(), fabs(), fMaxPlaneDist, fMaxSZChi2, fMaxSZDist, fVerbose, and PndRiemannTrack::szDist().

Referenced by FindTracks().

{
        double dist = track->dist(hit);
        double szDist = track->szDist(hit);
        double szChi2 = track->calcSZChi2(hit);

        if (fVerbose > 1) std::cout << ": dist " << dist << " szDist " << szDist << " szChi2 " << szChi2 << std::endl;

        if (fabs(dist) > fMaxPlaneDist){
                if (fVerbose > 1) std::cout << "dist larger than " << fMaxPlaneDist << std::endl;
                return false;
        }
        if (szChi2 > fMaxSZChi2){
                if (fVerbose > 1) std::cout << " SZ Chi2 too big! Cut at: " << fMaxSZChi2<< std::endl;
                return false;
        }
        if (fabs(szDist) > fMaxSZDist){ 
                if (fVerbose > 1) std::cout << " SZ Dist too big! Cut at: " << fMaxSZDist << std::endl;
                return false;
        }
        return true;
}

bool PndRiemannTrackFinder::CheckSZ ( PndRiemannTrack  aTrack )

protected

Tests the results of the sz fit.

Definition at line 249 of file PndRiemannTrackFinder.cxx.

References fMaxSZChi2, fVerbose, PndRiemannTrack::szChi2(), and PndRiemannTrack::szFit().

Referenced by GetStartTracks().

{
        aTrack.szFit();
        if (aTrack.szChi2() > fMaxSZChi2 || aTrack.szChi2() < 0){
                if (fVerbose > 1) std::cout << "sz-Fit does not match, Chi2: " << fMaxSZChi2 << std::endl;
                return false;
        }
        return true;
}

bool PndRiemannTrackFinder::CheckZeroPassing ( std::set< int >  hitIds, int  hit  )

protected

If the track contains (0,0) all points have to go forward or all have to go backward.

Definition at line 259 of file PndRiemannTrackFinder.cxx.

References fHits, fMapHitToID, fVerbose, and hit.

Referenced by PndMvdSttGemRiemannTrackFinder::FindTracks(), and PndMvdSttGemRiemannTrackFinder::GetStartTracks().

{
        FairHit* testHit = fHits[hit];
        FairHit* myHit;
        std::set<int>::iterator iter;

        std::set<int>::iterator zeroPos = hitIds.end();
        for (iter = hitIds.begin(); iter != hitIds.end(); iter++){
                if (fMapHitToID[*iter].GetIndex() < 0){
                        zeroPos = iter;
                }
        }
        if (zeroPos != hitIds.end()) {
                if (zeroPos  !=  --hitIds.end()) {
                        myHit = fHits[*(++zeroPos)];
                } else {
                        myHit = fHits[*(--zeroPos)];
                }
        } else {
                myHit = fHits[*hitIds.begin()];
        }
        TVector3 point1, point2, result;
        //std::cout << " TestHit: " << *testHit << " BaseHit: " << *myHit << std::endl;
        myHit->Position(point1);
        testHit->Position(point2);
        if ((point1 * point2) < 0){
                //std::cout << "product " << point1 * point2 << " negative: ZeroPassing" << std::endl;
                if (fVerbose > 1) std::cout << "ZeroPassing!" << std::endl;
                return true;
        }
        return false;
}

PndTrackCand PndRiemannTrackFinder::CreateOneTrackCand ( std::vector< int >  tracks, std::vector< PndTrackCand >  tempTrCnd  )

protected

Definition at line 560 of file PndRiemannTrackFinder.cxx.

References PndTrackCand::AddHit(), PndTrackCandHit::GetDetId(), PndTrackCandHit::GetHitId(), PndTrackCand::GetNHits(), PndTrackCand::GetSortedHit(), hits, i, and map.

Referenced by MergeTracks().

{
        PndTrackCand result;

        std::map<std::pair<unsigned int, unsigned int>, int > hits;
        for (size_t i = 0; i < tracks.size(); i++){
                PndTrackCand myTrackCand = tempTrCnd[tracks[i]];

                unsigned int detId, hitId;
                for (size_t j = 0; j < myTrackCand.GetNHits(); j++){
                        detId=myTrackCand.GetSortedHit(j).GetDetId();
                        hitId=myTrackCand.GetSortedHit(j).GetHitId();
                        hits[std::pair<unsigned int, unsigned int>(detId, hitId)]++;
                }
        }
        for (std::map<std::pair<unsigned int, unsigned int>, int >::const_iterator it = hits.begin(); it!= hits.end(); it++){
                std::pair<unsigned int, unsigned int> dethit = it->first;
                result.AddHit(dethit.first, dethit.second,0);
        }
        return result;
}

PndRiemannTrack PndRiemannTrackFinder::CreateRiemannTrack ( std::set< Int_t >  aHits )

protected

Creates a PndRiemannTrack from an array of indices of Hits.

Definition at line 292 of file PndRiemannTrackFinder.cxx.

References PndRiemannTrack::addHit(), fHits, hit, PndRiemannTrack::refit(), and PndRiemannTrack::szFit().

Referenced by FindTracks(), and PndMvdSttGemRiemannTrackFinder::FindTracks().

{
        PndRiemannTrack result;
        for (std::set<int>::iterator iter = aHits.begin(); iter != aHits.end(); iter++)
        {
                PndRiemannHit hit(fHits[*iter], *iter);
                result.addHit(hit);
        }
        result.refit(false);
        result.szFit(false);
        return result;
}

void PndRiemannTrackFinder::FindTracks

(

)

Main function to start the riemann track finding.

Definition at line 61 of file PndRiemannTrackFinder.cxx.

References PndTrackCand::AddHit(), PndRiemannTrack::addHit(), CheckHitDistance(), CheckRiemannHit(), CreateRiemannTrack(), PndRiemannTrack::dDip(), PndRiemannTrack::dip(), PndRiemannTrack::dR(), PndRiemannTrack::dX(), PndRiemannTrack::dY(), fCurvAndDipOfCand, fHits, fHitsInTracks, fHitsTooClose, fMapHitToID, fMinNumberOfHits, fTrackCand, fTracks, fVerbose, PndRiemannTrack::getNumHits(), GetStartTracks(), PndRiemannTrack::getSZm(), PndRiemannTrack::getSZt(), hits, n, PndRiemannTrack::orig(), p, r, PndRiemannTrack::r(), PndRiemannTrack::refit(), s, PndRiemannTrack::szFit(), TrackExists(), and TrackHits().

{
        std::vector<std::set<Int_t> > Tracks = GetStartTracks();                                //Get the possible track seeds
    std::set<int> tooClose;
    std::set<int>::iterator iter;
        for (size_t trackId = 0; trackId < Tracks.size(); trackId++){                           //Go through all track seeds and search for additional points

                if (Tracks[trackId].size() != 3)
                        std::cout << "-E- PndRiemannTrackFinder::FindTracks: Start points: " << Tracks[trackId].size()
                                  << " in Track: " << trackId << std::endl;

                std::set<Int_t> StartTrack = Tracks[trackId];                                   //Take a start track

                if (fVerbose > 1){
                        iter = StartTrack.begin();
                        std::cout << "------------------------------------" << std::endl;
                        std::cout << "Start Plane from Points: " << *iter << " "
                                          << *(++iter) << " " << *(++iter) << std::endl;
                }
                if (TrackExists(StartTrack) == true){
                        if (fVerbose > 1) std::cout << "Track exists already!" << std::endl;
                        continue;
                }
                PndRiemannTrack actTrack = CreateRiemannTrack(StartTrack);
                iter = StartTrack.end();
                int startHit = *(--iter);                                                                               //StartTrack always has three points, the last is the one with the largest index
                iter = StartTrack.begin();
                for (size_t testHit = startHit+1; testHit < fHits.size(); testHit++){
                        if (CheckHitDistance(*iter, testHit)!= true){fHitsTooClose[trackId].insert(testHit); continue;}
                        if (CheckHitDistance(*(++iter), testHit)!= true){fHitsTooClose[trackId].insert(testHit); continue;}
                        if (CheckHitDistance(*(++iter), testHit)!= true){fHitsTooClose[trackId].insert(testHit); continue;}

                        PndRiemannHit actHit(fHits[testHit], testHit);                                                  //Create a Riemann Hit from a FairHit

                        if (fVerbose > 1) std::cout << "Point " << testHit ;
                        if (CheckRiemannHit(&actTrack, &actHit) != true) continue;

                        StartTrack.insert(testHit);

                        actTrack.addHit(actHit);
                        actTrack.refit();
                        actTrack.szFit();

                        TVectorD orig = actTrack.orig();
                        if (fVerbose > 1) std::cout << "actHit added: " << testHit  << " r: " << actTrack.r()
                                                                                << " orig: " << orig[0] << " " << orig[1] << std::endl;
                }

                if ((int)actTrack.getNumHits() > (fMinNumberOfHits-1))          //if you have a track match
                {
                        std::set<int> hits = fHitsTooClose[trackId];
                        for (iter = hits.begin(); iter != hits.end(); iter++){
                                PndRiemannHit actHit(fHits[*iter]);
                                if (CheckRiemannHit(&actTrack, &actHit)!= true) continue;
                                StartTrack.insert(*iter);
                                actTrack.addHit(actHit);
                                actTrack.refit();
                                actTrack.szFit();
                        }

                        fTracks.push_back(actTrack);
                        fHitsInTracks.push_back(StartTrack);
                        if (fVerbose > 1){
                                TVectorD orig = actTrack.orig();
                                iter = StartTrack.begin();
                                std::cout << "Track added! " << *iter << " " << *(++iter)
                                        << " " << *(++iter) << " r: " << actTrack.r()
                                        << " orig: " << orig[0] << " " << orig[1]
                                        << " sz-m: " << actTrack.getSZm() << " sz-t: " << actTrack.getSZt()
                                        << " dip: " << actTrack.dip()
                                        << std::endl;
                        }

                        if (fVerbose > 0){
                                std::cout << "Hits in Track: ";
                                for (iter = StartTrack.begin(); iter != StartTrack.end(); iter++)
                                {
                                        std::cout << " " << fMapHitToID[*iter];
                                }
                                TVectorD myOrig = actTrack.orig();
                                std::cout << " numHits: " << actTrack.getNumHits() << std::endl;
                                std::cout << " curv: " << 1/actTrack.r() << "+/-" << actTrack.dR()/(actTrack.r() * actTrack.r())
                                                  << " dip: " << actTrack.dip() << "+/-" << actTrack.dDip()
                                                  << " orig: " << myOrig[0] << "+/-" << actTrack.dX()
                                                  << " " << myOrig[1] << "+/-" << actTrack.dY() << std::endl;
                        }
                }
        }

        for (unsigned int n = 0; n < fTracks.size(); n++){
                PndTrackCand myTrackCand;
                std::vector<PndRiemannHit> TrackHits = fTracks[n].getHits();

                for (unsigned int p = 0; p < TrackHits.size(); p++){
                        myTrackCand.AddHit(fMapHitToID[TrackHits[p].hitID()], TrackHits[p].s());
                }
                fTrackCand.push_back(myTrackCand);

                std::pair<double,double> CurvDip(1/fTracks[n].r(),fTracks[n].dip());
                fCurvAndDipOfCand.push_back(CurvDip);
        }


//      MergeTracks();
//      fTrackCand.clear();
//      fTrackCand = fMergedTrackCand;
//      if (fVerbose > 0) {
//              std::cout << "Tracks after merging:" << std::endl;
//              for (int p = 0; p < fTrackCand.size(); p++){
//                      fTrackCand[p].Print();
//              }
//      }

}

std::vector< int > PndRiemannTrackFinder::FindTracksWithSimilarHits ( std::vector< int > &  TracksToTest, std::vector< PndTrackCand >  tempTrCnd, std::vector< int > &  tempKillAfter  )

protected

---------—added by me

Definition at line 448 of file PndRiemannTrackFinder.cxx.

References fVerbose, PndTrackCandHit::GetDetId(), PndTrackCandHit::GetHitId(), PndTrackCand::GetNHits(), PndTrackCand::GetSortedHit(), i, m, and RemoveTrack().

Referenced by MergeTracks().

{
        std::vector<int> result;
        std::map<std::pair<unsigned int,unsigned int>, int > hitCount;
        int TrackInd = TracksToTest[0];

        PndTrackCand testTrack = tempTrCnd[TrackInd];

        result.push_back(TrackInd);
        RemoveTrack(TrackInd, TracksToTest);
        unsigned int detId, hitId;
        for (size_t i = 0; i < testTrack.GetNHits(); i++)
        {
                detId=testTrack.GetSortedHit(i).GetDetId();
                hitId=testTrack.GetSortedHit(i).GetHitId();
                std::pair<unsigned int, unsigned int> hitPair(detId, hitId);
                hitCount[hitPair] = 1;
        }
        int tracksToTestSize = TracksToTest.size();
        for (int j = 0; j < tracksToTestSize; j++){
                PndTrackCand myTrack = tempTrCnd[TracksToTest[j]];

                int NHits = 0;
                unsigned int myTrackDetId, myTrackHitId;
                for (size_t k = 0; k < myTrack.GetNHits(); k++){
                        myTrackDetId=myTrack.GetSortedHit(k).GetDetId();
                        myTrackHitId=myTrack.GetSortedHit(k).GetHitId();
                        std::pair<unsigned int, unsigned int> testPair(myTrackDetId, myTrackHitId);
                        if (hitCount[testPair] > 0){
                                hitCount[testPair]++;
                                NHits++;
                        }
                }
                if (NHits > 2){
                        result.push_back(TracksToTest[j]);
            tempKillAfter.push_back(TracksToTest[j]);
                }
        }
        if (fVerbose > 1){
                std::cout << "Tracks with similar hits: " << std::endl;
                for (size_t m = 0; m < result.size(); m++){
                        tempTrCnd[result[m]].Print();
                }
        }
        return result;
}

std::vector< int > PndRiemannTrackFinder::FindTracksWithSimilarParameters ( int  TrackInd, std::vector< int > &  TracksToTest, double  curvDiff, double  dipDiff  )

protected

Definition at line 412 of file PndRiemannTrackFinder.cxx.

References Double_t, fabs(), fCurvAndDipOfCand, fTrackCand, fVerbose, i, and RemoveTrack().

Referenced by MergeTracks().

{
        std::vector<int> result;
        Double_t testCurv=fCurvAndDipOfCand[TrackInd].first;
        Double_t testDip=fCurvAndDipOfCand[TrackInd].second;
        result.push_back(TrackInd);
        RemoveTrack(TrackInd, TracksToTest);
        int tracksToTestSize = TracksToTest.size();
        if(fVerbose > 1){
                std::cout << std::endl;
                std::cout << "TrackInd: " << TrackInd << " tracksToTest: " << tracksToTestSize << std::endl;
        }

        for (int i = 0; i < tracksToTestSize; i++){             
                Double_t checkCurv=fCurvAndDipOfCand[TracksToTest[i]].first;
                Double_t checkDip=fCurvAndDipOfCand[TracksToTest[i]].second;
                if ((fabs(2*(testCurv - checkCurv)/(testCurv + checkCurv)) < curvDiff) &&
                        (fabs(2*(testDip - checkDip)/(testDip + checkDip )) < dipDiff))
                {
                        result.push_back(TracksToTest[i]);
                        RemoveTrack(TracksToTest[i], TracksToTest);
                        tracksToTestSize = TracksToTest.size();
                        i--;
                }
        }
        if (fVerbose > 1 && result.size() > 1){
                std::cout << "Tracks with similar parameters: curv: " << testCurv <<
                                  " dip: " << testDip << std::endl;
                for(size_t j = 0; j < result.size();  j++){
                        fTrackCand[result[j]].Print();

                }
        }
        return result;
}

std::vector<PndTrackCand> PndRiemannTrackFinder::GetMergedTrackCands ( )

inline

Definition at line 33 of file PndRiemannTrackFinder.h.

References fMergedTrackCand.

{return fMergedTrackCand;}

PndTrack PndRiemannTrackFinder::GetPndTrack ( int  i, double  B  )

inline

Returns the track with the index i.

Definition at line 30 of file PndRiemannTrackFinder.h.

References fTracks, and i.

Referenced by PndMvdSttGemRiemannTrackFinderTask::Exec(), and PndMvdRiemannTrackFinderTask::Exec().

{return fTracks[i].getPndTrack(B);};

std::vector< std::set< Int_t > > PndRiemannTrackFinder::GetStartTracks ( )

protected

Definition at line 176 of file PndRiemannTrackFinder.cxx.

References PndRiemannTrack::addHit(), CheckHitDistance(), CheckHitInSameSensor(), CheckSZ(), fHits, fHitsTooClose, fVerbose, i, PndRiemannTrack::orig(), PndRiemannTrack::r(), PndRiemannTrack::refit(), and TrackExists().

Referenced by FindTracks().

{
        std::set<int> actCandidates;
        std::vector<std::set<int> > Tracks;
        std::set<int> tooCloseFirst;
        std::set<int> tooCloseSecond;
        std::set<int>::iterator iter;

        if (fHits.size() > 3){
                for (size_t first = 0; first < fHits.size()-3; first++){                                //take three points and create a riemann plane - get first hit
                        tooCloseFirst.clear();
                        for (size_t second = first+1; second < fHits.size()-2; second++){// get second hit
                                tooCloseSecond.clear();
                                if (CheckHitDistance(first, second) != true){ tooCloseFirst.insert(second); continue;}
                                if (CheckHitInSameSensor(first, second) == true) continue;
                                for (size_t third = second+1; third < fHits.size()-1; third++){
                                        if (fVerbose > 1) std::cout << "Checking Points: " << first << " " << second << " " << third << std::endl;
                                        if (CheckHitDistance(first, third)!= true){tooCloseFirst.insert(third); continue;}
                                        if (CheckHitDistance(second, third)!= true){tooCloseSecond.insert(third); continue;}

                                        if (CheckHitInSameSensor(first, third)==true)continue;
                                        if (CheckHitInSameSensor(second, third)==true)continue;

                                        actCandidates.clear();
                                        actCandidates.insert(first);
                                        actCandidates.insert(second);
                                        actCandidates.insert(third);

                                        if (!TrackExists(actCandidates)){                       //checks if the combination of three points was used before in a track
                                                PndRiemannTrack actTrack;// = new PndRiemannTrack();
                                                PndRiemannHit hit1(fHits[first]);
                                                PndRiemannHit hit2(fHits[second]);
                                                PndRiemannHit hit3(fHits[third]);
                                                actTrack.addHit(hit1);
                                                actTrack.addHit(hit2);
                                                actTrack.addHit(hit3);
                                                actTrack.refit();
                                                if (CheckSZ(actTrack)!= true) continue;
                                                TVectorT<double> orig = actTrack.orig();
                                                if (fVerbose > 1) std::cout << "Base plane from Points: " << first << " " << second << " " << third << " r: " << actTrack.r() << " orig: " << orig[0] << " " << orig[1] << std::endl;
                                                Tracks.push_back(actCandidates);
                                                std::set<int> combHits = tooCloseFirst;
                                                combHits.insert(tooCloseSecond.begin(), tooCloseSecond.end());
                                                fHitsTooClose.push_back(combHits);
                                        }
                                }
                        }
                }
        }
        if (fVerbose > 1) {
                std::cout << "Start Tracks are: " << std::endl;
                for (size_t i = 0; i < Tracks.size(); i++){
                        std::set<int> aTrack = Tracks[i];
                        for (iter = aTrack.begin(); iter != aTrack.end();iter++){
                                std::cout << *iter << " ";
                        }
                        std::cout << std::endl;
                }
        }
        return Tracks;
}

PndRiemannTrack PndRiemannTrackFinder::GetTrack ( int  i )

inline

Returns the number of found tracks.

Definition at line 29 of file PndRiemannTrackFinder.h.

References fTracks, and i.

Referenced by PndMvdSttGemRiemannTrackFinderTask::Exec().

{return fTracks[i];};                                   

std::vector<PndTrackCand> PndRiemannTrackFinder::GetTrackCand ( )

inline

Returns the hits belonging to track i.

Definition at line 32 of file PndRiemannTrackFinder.h.

References fTrackCand.

Referenced by PndMvdSttGemRiemannTrackFinderTask::Exec(), and PndMvdRiemannTrackFinderTask::Exec().

{return fTrackCand;}

PndTrackCand PndRiemannTrackFinder::GetTrackCand ( int  i )

inline

Definition at line 34 of file PndRiemannTrackFinder.h.

References fTrackCand, and i.

{return fTrackCand[i];}

std::set<Int_t> PndRiemannTrackFinder::GetTrackCandidates ( int  i )

inline

Definition at line 31 of file PndRiemannTrackFinder.h.

References fHitsInTracks, and i.

{return fHitsInTracks[i];};     

double PndRiemannTrackFinder::HitDistance	(	FairHit *	h1,
		FairHit *	h2
	)

Calculates the distance between two hits.

Definition at line 537 of file PndRiemannTrackFinder.cxx.

Referenced by CheckHitDistance(), and HitTooClose().

{
        TVector3 vH1, vH2, result;
        h1->Position(vH1);
        h2->Position(vH2);

        result = vH1 -vH2;
        return result.Mag();
}

int PndRiemannTrackFinder::HitTooClose	(	std::set< Int_t >	hitsInUse,
		FairHit *	newHit,
		double	threshold
	)

returns if and which hit was too close to the hit which is tested

Definition at line 547 of file PndRiemannTrackFinder.cxx.

References fabs(), fHits, fVerbose, h1, HitDistance(), and i.

{
        int i = 0;
        for (std::set<int>::iterator iter = hitsInUse.begin(); iter != hitsInUse.end(); iter++){
                i++;
                FairHit* h1 = fHits[*iter];
                if (fVerbose > 2) std::cout << "Point Distance: " << HitDistance(h1, newHit) << std::endl;
                if (fabs(HitDistance(h1, newHit)) < threshold)
                        return i;
        }
        return -1;
}

void PndRiemannTrackFinder::MergeTracks

(

)

Definition at line 354 of file PndRiemannTrackFinder.cxx.

References counter, CreateOneTrackCand(), fCurvDiff, fDipDiff, FindTracksWithSimilarHits(), FindTracksWithSimilarParameters(), fMergedTrackCand, fTrackCand, fVerbose, i, and RemoveTrack().

{
        std::vector<int> RemainingTracks;
        std::vector<int> SelectedTracks;
        std::vector<int> TracksToMerge;
        if (fVerbose > 1) std::cout << "fTrackCand size: " << fTrackCand.size() << std::endl;
        for (size_t i = 0; i < fTrackCand.size(); i++){
                RemainingTracks.push_back(i);
        }
        int remainingTracksSize = RemainingTracks.size();
        if (fVerbose > 1) std::cout << "RemainingTracks: " << RemainingTracks.size() << std::endl;
        while(remainingTracksSize != 0){
                SelectedTracks = FindTracksWithSimilarParameters(RemainingTracks[0], RemainingTracks, fCurvDiff, fDipDiff);
                remainingTracksSize=RemainingTracks.size();
                if (fVerbose > 1) std::cout << "RemainingTracks: " << RemainingTracks.size() << std::endl;
                if (SelectedTracks.size() > 1){
                        //int selectedTracksSize = SelectedTracks.size(); //[R.K. 01/2017] unused variable
                        std::vector<PndTrackCand> tempTrCnd;
                        std::vector<int> tempST;
                        std::vector<int> tempKillAfter;

                           for(size_t k=0;k<SelectedTracks.size();k++){
                                   tempTrCnd.push_back(fTrackCand[SelectedTracks[k]]);
                                   tempST.push_back(k);
                           }
            //int tempSize0=tempTrCnd.size(); //[R.K. 01/2017] unused variable?
                        int tempSize=tempTrCnd.size();
            bool checkMerge=true;
                        while (checkMerge){
                                int counter=0;
                                for(int j=0;j<tempSize;j++){
                                        TracksToMerge = FindTracksWithSimilarHits(tempST,tempTrCnd,tempKillAfter);
                                        //selectedTracksSize = SelectedTracks.size(); //[R.K. 01/2017] unused variable
                                        PndTrackCand newCand = CreateOneTrackCand(TracksToMerge,tempTrCnd);
                                        tempTrCnd.push_back(newCand);
                                        tempST.push_back(tempTrCnd.size()-1);
                                        if (TracksToMerge.size()>1) counter++;
                                }
                                if (counter>0)
                                checkMerge=true;
                                else checkMerge=false;

                                for(size_t k=0;k<tempKillAfter.size();k++){
                                        for(size_t i=0;i<tempST.size();i++){
                                                if (tempST[i]==tempKillAfter[k]){
                                                        RemoveTrack(tempKillAfter[k], tempST);
                                                }
                                        }
                                }
                        }
                        for(size_t k=0;k<tempST.size();k++){
                                fMergedTrackCand.push_back(tempTrCnd[tempST[k]]);
                        }
                }
                else fMergedTrackCand.push_back(fTrackCand[SelectedTracks[0]]);
        }
}

int PndRiemannTrackFinder::NTracks ( )

inline

Definition at line 28 of file PndRiemannTrackFinder.h.

References fTrackCand.

Referenced by PndMvdSttGemRiemannTrackFinderTask::Exec(), and PndMvdRiemannTrackFinderTask::Exec().

{return fTrackCand.size();};                                                            

void PndRiemannTrackFinder::RemoveTrack ( int  TrackInd, std::vector< int > &  TrackList  )

protected

Definition at line 495 of file PndRiemannTrackFinder.cxx.

References i.

Referenced by FindTracksWithSimilarHits(), FindTracksWithSimilarParameters(), and MergeTracks().

{
        int trackListSize = TrackList.size();
        for(int i = 0; i < trackListSize; i++){
                if (TrackList[i] == TrackInd){
                        TrackList.erase(TrackList.begin()+i);
                        trackListSize = TrackList.size();
                }
        }
}

void PndRiemannTrackFinder::SetCurvDiff ( double  val )

inline

Definition at line 44 of file PndRiemannTrackFinder.h.

References fCurvDiff, and val.

{fCurvDiff = val;}

void PndRiemannTrackFinder::SetDipDiff ( double  val )

inline

Definition at line 45 of file PndRiemannTrackFinder.h.

References fDipDiff, and val.

{fDipDiff = val;}

void PndRiemannTrackFinder::SetHits ( std::vector< FairHit * >  hits )

inline

Definition at line 23 of file PndRiemannTrackFinder.h.

References fHits, and hits.

{fHits = hits;};                                

void PndRiemannTrackFinder::SetMaxPlaneDistance ( double  val )

inline

Definition at line 38 of file PndRiemannTrackFinder.h.

References fMaxPlaneDist, and val.

Referenced by PndMvdSttGemRiemannTrackFinderTask::Exec(), and PndMvdRiemannTrackFinderTask::Exec().

{fMaxPlaneDist = val;}

void PndRiemannTrackFinder::SetMaxSZChi2 ( double  val )

inline

Definition at line 40 of file PndRiemannTrackFinder.h.

References fMaxSZChi2, and val.

Referenced by PndMvdSttGemRiemannTrackFinderTask::Exec(), and PndMvdRiemannTrackFinderTask::Exec().

{fMaxSZChi2 = val;}

void PndRiemannTrackFinder::SetMaxSZDist ( double  val )

inline

Definition at line 39 of file PndRiemannTrackFinder.h.

References fMaxSZDist, and val.

Referenced by PndMvdSttGemRiemannTrackFinderTask::Exec(), and PndMvdRiemannTrackFinderTask::Exec().

{fMaxSZDist = val;}

void PndRiemannTrackFinder::SetMinNumberOfHits ( int  val )

inline

Definition at line 43 of file PndRiemannTrackFinder.h.

References fMinNumberOfHits, and val.

Referenced by PndMvdSttGemRiemannTrackFinderTask::Exec(), and PndMvdRiemannTrackFinderTask::Exec().

{fMinNumberOfHits = val;}

void PndRiemannTrackFinder::SetMinPointDist ( double  val )

inline

Definition at line 41 of file PndRiemannTrackFinder.h.

References fMinPointDist, and val.

Referenced by PndMvdSttGemRiemannTrackFinderTask::Exec(), and PndMvdRiemannTrackFinderTask::Exec().

{fMinPointDist = val;}

void PndRiemannTrackFinder::SetUseZeroPos ( bool  val )

inline

Definition at line 42 of file PndRiemannTrackFinder.h.

References fUseZeroPos, and val.

{fUseZeroPos = val;}

void PndRiemannTrackFinder::SetVerbose ( int  val )

inline

Adds one new hit to the array of hits.

Definition at line 27 of file PndRiemannTrackFinder.h.

References fVerbose, and val.

Referenced by PndMvdSttGemRiemannTrackFinderTask::Exec(), and PndMvdRiemannTrackFinderTask::Exec().

{fVerbose = val;}

bool PndRiemannTrackFinder::TrackExists ( std::set< Int_t >  hitsInTrack )

protected

Definition at line 506 of file PndRiemannTrackFinder.cxx.

References fHitsInTracks, fVerbose, and i.

Referenced by FindTracks(), PndMvdSttGemRiemannTrackFinder::FindTracks(), and GetStartTracks().

                                                                {
        bool result = true;
        bool oneNumberEqual = false;

        //if (fVerbose > 2) std::cout << "TrackExists: fHitsInTrack.size: " << fHitsInTracks.size() << std::endl;
        unsigned int i = 0;
        for (i = 0; (i < fHitsInTracks.size()); i++){                                                                                                           //run through tracks in trackList
                for (std::set<int>::iterator k = hitsInTrack.begin(); (k != hitsInTrack.end()&&(result == true)); k++){                                                                 //run through all hits in test track
                        for (std::set<int>::iterator j = fHitsInTracks[i].begin(); (j != fHitsInTracks[i].end()) && (oneNumberEqual == false); j++){                            //run through all hits in selected track
                                //if (fVerbose > 2) std::cout << hitsInTrack[k] << " ?= " << fHitsInTracks[i][j] << std::endl;
                                if (*k == *j)
                                        oneNumberEqual = true;
                                else oneNumberEqual = false;
                        }
                        result &= oneNumberEqual;
                        oneNumberEqual = false;
                }
                if (result == true) {
                        if (fVerbose > 1){
                                std::cout << "Track exists already!" << std::endl;
                                for (std::set<int>::iterator l = fHitsInTracks[i].begin(); l != fHitsInTracks[i].end(); l++)
                                        std::cout << " " << *l;
                                std::cout << std::endl;
                        }
                        return true;
                }
                result = true;
        }
        return false;
}

Member Data Documentation

std::vector< std::pair<double,double> > PndRiemannTrackFinder::fCurvAndDipOfCand

protected

Curvature and dip of fPndTrackCand.

Definition at line 52 of file PndRiemannTrackFinder.h.

Referenced by FindTracks(), PndMvdSttGemRiemannTrackFinder::FindTracks(), and FindTracksWithSimilarParameters().

double PndRiemannTrackFinder::fCurvDiff

protected

TrackMerger parameter.

Definition at line 62 of file PndRiemannTrackFinder.h.

Referenced by MergeTracks(), and SetCurvDiff().

double PndRiemannTrackFinder::fDipDiff

protected

TrackMerger parameter.

Definition at line 63 of file PndRiemannTrackFinder.h.

Referenced by MergeTracks(), and SetDipDiff().

std::vector<FairHit*> PndRiemannTrackFinder::fHits

protected

Vector of all FairHits used for track finding (fitting)

Definition at line 48 of file PndRiemannTrackFinder.h.

Referenced by AddHit(), PndMvdSttGemRiemannTrackFinder::AddHits(), AddHits(), PndMvdSttGemRiemannTrackFinder::CheckBoarderHitsStt(), CheckHitDistance(), CheckHitInSameSensor(), CheckZeroPassing(), CreateRiemannTrack(), FindTracks(), PndMvdSttGemRiemannTrackFinder::FindTracks(), PndMvdSttGemRiemannTrackFinder::GetStartTracks(), GetStartTracks(), PndMvdSttGemRiemannTrackFinder::GetStrawSector(), HitTooClose(), PndRiemannTrackFinder(), SetHits(), and ~PndRiemannTrackFinder().

std::vector<std::set<Int_t> > PndRiemannTrackFinder::fHitsInTracks

protected

Vector of indizes which hits where used in which track.

Definition at line 50 of file PndRiemannTrackFinder.h.

Referenced by FindTracks(), PndMvdSttGemRiemannTrackFinder::FindTracks(), GetTrackCandidates(), and TrackExists().

std::vector< std::set<int> > PndRiemannTrackFinder::fHitsTooClose

protected

matrix of TrackNr and hits which are too close to one of the three starting points

Definition at line 54 of file PndRiemannTrackFinder.h.

Referenced by FindTracks(), PndMvdSttGemRiemannTrackFinder::FindTracks(), PndMvdSttGemRiemannTrackFinder::GetStartTracks(), and GetStartTracks().

double PndRiemannTrackFinder::fMagField

protected

size of the magnetic field in Tesla

Definition at line 64 of file PndRiemannTrackFinder.h.

std::map<int, FairLink > PndRiemannTrackFinder::fMapHitToID

protected

map to convert the list of hits back into a FairLink

Definition at line 55 of file PndRiemannTrackFinder.h.

Referenced by PndMvdSttGemRiemannTrackFinder::AddHits(), AddHits(), CheckZeroPassing(), FindTracks(), PndMvdSttGemRiemannTrackFinder::FindTracks(), PndMvdSttGemRiemannTrackFinder::GetStartTracks(), PndMvdSttGemRiemannTrackFinder::GetStrawSector(), and PndRiemannTrackFinder().

std::map<FairLink, int > PndRiemannTrackFinder::fMapIDtoHit

protected

map to convert the list of detID/hitID hits into the list of hits for track finding

Definition at line 56 of file PndRiemannTrackFinder.h.

Referenced by PndMvdSttGemRiemannTrackFinder::AddHits(), AddHits(), PndMvdSttGemRiemannTrackFinder::AssignGemHits(), PndMvdSttGemRiemannTrackFinder::AssignSkewedSttHits(), PndMvdSttGemRiemannTrackFinder::AssignSttHits(), PndMvdSttGemRiemannTrackFinder::CheckBoarderHitsStt(), PndMvdSttGemRiemannTrackFinder::GetStrawSector(), and PndRiemannTrackFinder().

double PndRiemannTrackFinder::fMaxPlaneDist

protected

Distance cut between new point and riemann plane.

Definition at line 57 of file PndRiemannTrackFinder.h.

Referenced by CheckRiemannHit(), PndMvdSttGemRiemannTrackFinder::GetMaxPlaneDist(), and SetMaxPlaneDistance().

double PndRiemannTrackFinder::fMaxSZChi2

protected

Maximum allowed Chi2 in an sz fit.

Definition at line 60 of file PndRiemannTrackFinder.h.

Referenced by CheckRiemannHit(), CheckSZ(), PndMvdSttGemRiemannTrackFinder::GetMaxSZChi2(), and SetMaxSZChi2().

double PndRiemannTrackFinder::fMaxSZDist

protected

Distance cut between s-z coordinate of a new point and the sz-fit of the hits in the track.

Definition at line 58 of file PndRiemannTrackFinder.h.

Referenced by CheckRiemannHit(), PndMvdSttGemRiemannTrackFinder::CheckRiemannHitMvd(), and SetMaxSZDist().

std::vector<PndTrackCand> PndRiemannTrackFinder::fMergedTrackCand

protected

Definition at line 53 of file PndRiemannTrackFinder.h.

Referenced by GetMergedTrackCands(), and MergeTracks().

int PndRiemannTrackFinder::fMinNumberOfHits

protected

Minimum number of hits in track necessary for a match.

Definition at line 61 of file PndRiemannTrackFinder.h.

Referenced by FindTracks(), PndMvdSttGemRiemannTrackFinder::FindTracks(), and SetMinNumberOfHits().

double PndRiemannTrackFinder::fMinPointDist

protected

Minimum distance between two points to use them as point for the base plane.

Definition at line 59 of file PndRiemannTrackFinder.h.

Referenced by CheckHitDistance(), and SetMinPointDist().

std::vector<PndTrackCand> PndRiemannTrackFinder::fTrackCand

protected

List of track candidates.

Definition at line 51 of file PndRiemannTrackFinder.h.

Referenced by FindTracks(), PndMvdSttGemRiemannTrackFinder::FindTracks(), FindTracksWithSimilarParameters(), GetTrackCand(), MergeTracks(), and NTracks().

std::vector<PndRiemannTrack> PndRiemannTrackFinder::fTracks

protected

Resulting Riemann Tracks.

Definition at line 49 of file PndRiemannTrackFinder.h.

Referenced by FindTracks(), PndMvdSttGemRiemannTrackFinder::FindTracks(), GetPndTrack(), and GetTrack().

bool PndRiemannTrackFinder::fUseZeroPos

protected

Definition at line 67 of file PndRiemannTrackFinder.h.

Referenced by PndMvdSttGemRiemannTrackFinder::GetStartTracks(), PndMvdSttGemRiemannTrackFinder::PndMvdSttGemRiemannTrackFinder(), PndRiemannTrackFinder(), SetUseZeroPos(), and ~PndRiemannTrackFinder().

int PndRiemannTrackFinder::fVerbose

protected

Definition at line 66 of file PndRiemannTrackFinder.h.

Referenced by PndMvdSttGemRiemannTrackFinder::AddHits(), PndMvdSttGemRiemannTrackFinder::AssignGemHits(), PndMvdSttGemRiemannTrackFinder::AssignSkewedSttHits(), PndMvdSttGemRiemannTrackFinder::AssignSttHits(), PndMvdSttGemRiemannTrackFinder::CheckBoarderHitsStt(), CheckHitDistance(), CheckHitInTrack(), CheckRiemannHit(), PndMvdSttGemRiemannTrackFinder::CheckRiemannHitGem(), PndMvdSttGemRiemannTrackFinder::CheckRiemannHitMvd(), PndMvdSttGemRiemannTrackFinder::CheckRiemannHitSkewedStt(), PndMvdSttGemRiemannTrackFinder::CheckRiemannHitStt(), PndMvdSttGemRiemannTrackFinder::CheckSZ(), CheckSZ(), CheckZeroPassing(), FindTracks(), PndMvdSttGemRiemannTrackFinder::FindTracks(), FindTracksWithSimilarHits(), FindTracksWithSimilarParameters(), PndMvdSttGemRiemannTrackFinder::GetStartTracks(), GetStartTracks(), PndMvdSttGemRiemannTrackFinder::GetStrawSector(), HitTooClose(), MergeTracks(), SetVerbose(), and TrackExists().

---

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

• PndRiemannTrackFinder.h
• PndRiemannTrackFinder.cxx