PndMvdSttGemRiemannTrackFinder Class Reference

#include <PndMvdSttGemRiemannTrackFinder.h>

Inheritance diagram for PndMvdSttGemRiemannTrackFinder:

Public Member Functions
	PndMvdSttGemRiemannTrackFinder ()
virtual	~PndMvdSttGemRiemannTrackFinder ()
	PndMvdSttGemRiemannTrackFinder (const PndMvdSttGemRiemannTrackFinder &)=delete
PndMvdSttGemRiemannTrackFinder &	operator= (const PndMvdSttGemRiemannTrackFinder &)=delete
void	FindTracks ()
	Main function to start the riemann track finding. More...
void	AddHits (TClonesArray *hits, Int_t branchId)
void	SetCutDistH (TH2F *hist)
void	SetCutChi2H (TH2F *hist)
void	SetSttTubeArray (TClonesArray *SttTubeArray)
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	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...
PndTrackCand	GetTrackCand (int i)
std::vector< PndTrackCand >	GetMergedTrackCands ()
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
bool	CheckHitDistance (int hit1, int hit2)
	Tests if the distance is larger than fMinPointDistance. 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

Private Member Functions
std::vector< std::set< Int_t > >	GetStartTracks ()
bool	CheckSZ (PndRiemannTrack aTrack)
	Tests the results of the sz fit. More...
bool	CheckRiemannHit (PndRiemannTrack *track, PndRiemannHit *hit, FairHit *fairHit)
bool	CheckRiemannHitMvd (PndRiemannTrack *track, PndRiemannHit *hit, FairHit *fairHit)
bool	CheckRiemannHitGem (PndRiemannTrack *track, PndRiemannHit *hit, FairHit *fairHit)
bool	CheckRiemannHitStt (PndRiemannTrack *track, PndRiemannHit *hit, FairHit *fairHit)
bool	CheckRiemannHitSkewedStt (PndRiemannTrack *track, PndRiemannHit *hit, FairHit *fairHit)
void	AssignSttHits (PndRiemannTrack &actTrack, std::set< Int_t > &startTrack)
void	AssignSkewedSttHits (PndRiemannTrack &actTrack, std::set< Int_t > &startTrack)
void	AssignGemHits (PndRiemannTrack &actTrack, std::set< Int_t > &startTrack)
bool	CheckBoarderHitsStt (PndTrackCand *track)
int	GetStrawSector (PndRiemannTrack &track)
int	GetLayerGem (FairHit *hit)
int	GetLayerMvd (FairHit *hit)
int	GetLayer (TString identifier)
void	InitLayerMap ()
void	InitLayerMapMvd ()
void	InitLayerMapGem ()
double	GetMaxPlaneDist (double radius, double dip, bool sign)
double	GetMaxSZChi2 (double radius, double dip, bool sign)
std::set< int >	GetTooCloseHitsInLayer (int LayerNumber, int HitNumber)

Private Attributes
PndGeoHandling *	fGeoH
TH2F *	fCutDistH
	cutting histograms More...
TH2F *	fCutChi2H
TClonesArray *	fSttHits
TClonesArray *	fSkewedSttHits
TClonesArray *	fGemHits
PndSttStrawMap	fStrawMap
std::vector< std::vector < PndSttHit * > >	fSttHitsInSectors
std::vector< std::vector < FairHit * > >	fSttSkewedHitsInSectors
double	fZClosePar
	parameter to separate forward and backward tracks More...
std::vector< std::vector< int > >	fLayers
	contains layer information of hits More...
std::map< TString, int >	fLayerMap
	identifier string, assigned layer id More...
int	fLastLayerId
	last layer Id assigned More...
int	fNLayers
	number of Layers More...

Detailed Description

Definition at line 14 of file PndMvdSttGemRiemannTrackFinder.h.

Constructor & Destructor Documentation

PndMvdSttGemRiemannTrackFinder::PndMvdSttGemRiemannTrackFinder

(

)

Definition at line 15 of file PndMvdSttGemRiemannTrackFinder.cxx.

References fGeoH, fLayers, fSttHitsInSectors, fSttSkewedHitsInSectors, PndRiemannTrackFinder::fUseZeroPos, InitLayerMap(), and PndGeoHandling::Instance().

                                                              :PndRiemannTrackFinder(), fSttHits(0), fGemHits(0),fZClosePar(0.1), fLastLayerId(0)
{
        fLayers.resize(22);
        if (fUseZeroPos)
                fLayers[0].push_back(0);
        fGeoH = PndGeoHandling::Instance();
        fSttHitsInSectors.resize(6);
        fSttSkewedHitsInSectors.resize(6);
        InitLayerMap();
}

PndMvdSttGemRiemannTrackFinder::~PndMvdSttGemRiemannTrackFinder ( )

virtual

Definition at line 26 of file PndMvdSttGemRiemannTrackFinder.cxx.

{}

PndMvdSttGemRiemannTrackFinder::PndMvdSttGemRiemannTrackFinder ( const PndMvdSttGemRiemannTrackFinder &  )

delete

Member Function Documentation

void PndRiemannTrackFinder::AddHit ( FairHit *  hit )

inlineinherited

Definition at line 26 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fHits.

{fHits.push_back(hit);};                                                

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

Definition at line 95 of file PndMvdSttGemRiemannTrackFinder.cxx.

References fGemHits, PndRiemannTrackFinder::fHits, PndSttStrawMap::FindPhiSector(), fLayers, PndRiemannTrackFinder::fMapHitToID, PndRiemannTrackFinder::fMapIDtoHit, fNLayers, fSkewedSttHits, fStrawMap, fSttHits, fSttHitsInSectors, fSttSkewedHitsInSectors, PndRiemannTrackFinder::fVerbose, GetLayerGem(), GetLayerMvd(), PndSttStrawMap::GetSector(), PndSttHit::GetTubeID(), hits, i, phi, Pi, push_back(), and CAMath::Sqrt().

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

{
//      SetVerbose(3);
        FairRootManager* man = FairRootManager::Instance();
  //    PndRiemannTrackFinder::AddHits(hits, branchId);
        if (branchId == man->GetBranchId("STTHit")){
                fSttHits = hits;
                for (int i = 0; i < fSttHits->GetEntries(); i++){
                        PndSttHit* myHit = (PndSttHit*)(fSttHits->At(i));
                        myHit->SetEntryNr(FairLink(man->GetBranchId("SttHit"), i));
                        fHits.push_back(myHit);
                        myHit->SetPositionError(TVector3(0.5/TMath::Sqrt(12), 0.5/TMath::Sqrt(12), 200));
                        TVector3 sttPos;
                        myHit->Position(sttPos);
                        FairLink myID;

                        if (myHit->GetEntryNr().GetIndex() < 0 || myHit->GetEntryNr().GetType() < 0){
                                myID = FairLink(branchId, i);
                                myHit->SetEntryNr(myID);
                        }
                        else
                                myID = myHit->GetEntryNr();
                        double phi = 0;
//                      if  (sttPos.Phi() < 0)
//                              phi = sttPos.Phi() + TMath::Pi() * 2;
//                      else
//                              phi = sttPos.Phi();
                        if (fVerbose > 1) std::cout << "PndMvdSttGemRiemannTrackFinder::AddHits StrawMap Sector: " << myHit->GetEntryNr() << " " << myHit->GetTubeID() << ": Phi: " << sttPos.x() << "/" << sttPos.y() << " " << phi << " Sector: " << fStrawMap.GetSector(myHit->GetTubeID())<< std::endl;
                        fSttHitsInSectors[fStrawMap.GetSector(myHit->GetTubeID())].push_back(myHit);

                        fMapHitToID[fHits.size()-1]=myID;
                        fMapIDtoHit[myID] = fHits.size()-1;
                }
                return;
        }

        if(branchId == man->GetBranchId("STTCombinedSkewedHits")){
                if (hits == 0){
                        std::cout << "PndMvdSttGemRiemannTrackFinder::AddHits: no SkewedHits Branch" << std::endl;
                        return;
                }
                std::cout << "PndMvdSttGemRiemannTrackFinder::AddHits: SkewedHits " << hits->GetEntriesFast() << std::endl;
                fSkewedSttHits = hits;
                for (int i = 0; i < fSkewedSttHits->GetEntries(); i++){
                        FairHit* myHit = (FairHit*)(fSkewedSttHits->At(i));
                        myHit->SetEntryNr(FairLink(man->GetBranchId("STTCombinedSkewedHits"), i));
                        fHits.push_back(myHit);
                        myHit->SetPositionError(TVector3(0.5/TMath::Sqrt(12), 0.5/TMath::Sqrt(12), 200));
                        TVector3 sttPos;
                        myHit->Position(sttPos);
                        FairLink myID;

                        if (myHit->GetEntryNr().GetIndex() < 0 || myHit->GetEntryNr().GetType() < 0){
                                myID = FairLink(branchId, i);
                                myHit->SetEntryNr(myID);
                        }
                        else
                                myID = myHit->GetEntryNr();
                        double phi = 0;
                        if  (sttPos.Phi() < 0)
                                phi = sttPos.Phi() + TMath::Pi() * 2;
                        else
                                phi = sttPos.Phi();
//                      if (fVerbose > 1)
                                std::cout << "PndMvdSttGemRiemannTrackFinder::AddHits StrawMap Sector: " << myHit->GetEntryNr() <<  ": Phi: " << sttPos.x() << "/" << sttPos.y() << " " << phi << " Sector: " << fStrawMap.FindPhiSector(phi)<< std::endl;
                        fSttSkewedHitsInSectors[fStrawMap.FindPhiSector(phi)].push_back(myHit);

                        fMapHitToID[fHits.size()-1]=myID;
                        fMapIDtoHit[myID] = fHits.size()-1;
                }
                return;
        }

        if (branchId == man->GetBranchId("GEMHit")){
                fGemHits = hits;
                if (fVerbose > 1) std::cout << "PndMvdSttGemRiemannTrackFinder::AddHits GEMHitsAdded: " << hits->GetEntries() << std::endl;
                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(branchId, i);
                                myHit->SetEntryNr(myID);
                        }
                        else
                                myID = myHit->GetEntryNr();
                        fMapHitToID[fHits.size()-1]=myID;
                        fMapIDtoHit[myID] = fHits.size()-1;
                }
                return;
        }

        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(branchId, i);
                        myHit->SetEntryNr(myID);
                }
                else
                        myID = myHit->GetEntryNr();
                fMapHitToID[fHits.size()-1]=myID;
                fMapIDtoHit[myID] = fHits.size()-1;

                int Layer = 0;
                if (branchId == man->GetBranchId("MVDHitsStrip") || branchId == man->GetBranchId("MVDHitsPixel")){
                        Layer = GetLayerMvd(myHit);
                } else if (branchId == man->GetBranchId("GEMHit")) {
                        Layer = GetLayerGem(myHit);
                }

                fNLayers = fLayers.size();
                while (fNLayers < Layer+1){
                        std::vector<int> dummy;
                        fLayers.push_back(dummy);
                        fNLayers = fLayers.size();
                }

    
                if (fVerbose > 1) std::cout << "fMapHitToId: " << fHits.size() -1 << " : " << myID << " "
                                                                        << myHit->GetX() << "/" << myHit->GetY() << "/" << myHit->GetZ()
                                                                        << " Layer: " << Layer << std::endl;

                if (Layer > 0)
                        fLayers[Layer].push_back(fHits.size()-1);  //putting hit in layers array
        }
        fNLayers = fLayers.size();
}

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

inherited

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 PndRiemannTrackFinder::fHits, PndRiemannTrackFinder::fMapHitToID, PndRiemannTrackFinder::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 PndMvdSttGemRiemannTrackFinder::AssignGemHits ( PndRiemannTrack &  actTrack, std::set< Int_t > &  startTrack  )

private

Definition at line 776 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrack::addHit(), CheckRiemannHitGem(), fGemHits, PndRiemannTrackFinder::fMapIDtoHit, PndRiemannTrackFinder::fVerbose, and i.

Referenced by FindTracks().

                                                                                                   {

        if (fVerbose > 1) std::cout << "NGemHits: " << fGemHits->GetEntriesFast() << std::endl;
        for (int i = 0; i < fGemHits->GetEntriesFast(); i++){
                FairHit* fairGemHit = (FairHit*)fGemHits->At(i);
                PndRiemannHit actHit(fairGemHit, fMapIDtoHit[fairGemHit->GetEntryNr()]);

                if (CheckRiemannHitGem(&actTrack, &actHit,fairGemHit) != true) continue;

                if (fVerbose > 1 )
                        std::cout << "-I- PndMvdSttGemRiemannTrackFinder SearchSector: GemHit add to Track!" << std::endl;

                actTrack.addHit(actHit);
                startTrack.insert(fMapIDtoHit[actHit.hit()->GetEntryNr()]);
        }
}

void PndMvdSttGemRiemannTrackFinder::AssignSkewedSttHits ( PndRiemannTrack &  actTrack, std::set< Int_t > &  startTrack  )

private

Definition at line 726 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrack::addHit(), CheckRiemannHitSkewedStt(), PndRiemannTrackFinder::fMapIDtoHit, fStrawMap, fSttSkewedHitsInSectors, PndRiemannTrackFinder::fVerbose, PndSttStrawMap::GetLeftSector(), PndSttStrawMap::GetRightSector(), GetStrawSector(), i, and PndRiemannTrack::refit().

Referenced by FindTracks().

{
        int startSector = GetStrawSector(actTrack);
        int searchSector = startSector;
        int nHitsStt = -1;

//      SetVerbose(3);

        if (fVerbose > 2)
                                        std::cout << "StartSector: " << searchSector << std::endl;

        std::vector<FairHit*> sttHits = fSttSkewedHitsInSectors[searchSector];
        int leftSector = fStrawMap.GetLeftSector(startSector);
        int rightSector = fStrawMap.GetRightSector(startSector);
        sttHits.insert(sttHits.end(), fSttSkewedHitsInSectors[leftSector].begin(),  fSttSkewedHitsInSectors[leftSector].end());
        sttHits.insert(sttHits.end(), fSttSkewedHitsInSectors[rightSector].begin(), fSttSkewedHitsInSectors[rightSector].end());

        if (fVerbose > 2)
                std::cout << "-I- PndMvdSttGemRiemannTrackFinder SearchSector: Actual searchSector: "  << searchSector << std::endl;

        for (size_t i = 0; i < sttHits.size(); i++){

                if (nHitsStt < 0) nHitsStt = 0;

                FairHit* fairSttHit = sttHits[i];

                PndRiemannHit actHit(fairSttHit, fMapIDtoHit[fairSttHit->GetEntryNr()]);



                if (fVerbose > 2) {
                        std::cout << std::endl;
                        std::cout << "-I- PndMvdSttGemRiemannTrackFinder SearchSector: Act Hit: " << fairSttHit->GetEntryNr() << std::endl;
                }

                if (CheckRiemannHitSkewedStt(&actTrack, &actHit,fairSttHit) != true) continue;

                if (fVerbose > 2 )
                        std::cout << "-I- PndMvdSttGemRiemannTrackFinder SearchSector: STTHit add to Track!" << std::endl;

                actTrack.addHit(actHit);
                startTrack.insert(fMapIDtoHit[actHit.hit()->GetEntryNr()]);
                actTrack.refit(kFALSE);
//                      actTrack.szFit(kFALSE);
                nHitsStt++;

        }
//      SetVerbose(0);
}

void PndMvdSttGemRiemannTrackFinder::AssignSttHits ( PndRiemannTrack &  actTrack, std::set< Int_t > &  startTrack  )

private

Definition at line 636 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrack::addHit(), CheckRiemannHitStt(), PndRiemannTrackFinder::fMapIDtoHit, fStrawMap, fSttHitsInSectors, PndRiemannTrackFinder::fVerbose, PndSttStrawMap::GetLeftSector(), PndSttStrawMap::GetRightSector(), PndSttStrawMap::GetSector(), GetStrawSector(), PndSttHit::GetTubeID(), i, PndSttStrawMap::IsSectorBorderStraw(), PndSttStrawMap::IsSkewedStraw(), and PndRiemannTrack::refit().

Referenced by FindTracks().

{
        int startSector = GetStrawSector(actTrack);
        int searchSector = startSector;
        bool continueSearch = true;
        int nextSectorDirection = 0;
        int nHitsStt = -1;

        if (fVerbose > 2)
                                        std::cout << "StartSector: " << searchSector << std::endl;

        while (continueSearch){
                if (nHitsStt == 0){                                                                                                     //check if you have found any Stt hits in the selected startSector. If this is not the case take the left one. If there are still no Stt hits take the right one
                        if (startSector == searchSector){
                                searchSector = fStrawMap.GetRightSector(startSector);
                        }
                        else {
                                searchSector = fStrawMap.GetLeftSector(startSector);
                        }
                }

                std::vector<PndSttHit*> sttHits = fSttHitsInSectors[searchSector];
                continueSearch = false;
                if (fVerbose > 2)
                        std::cout << "-I- PndMvdSttGemRiemannTrackFinder SearchSector: Actual searchSector: "  << searchSector << std::endl;

                for (size_t i = 0; i < sttHits.size(); i++){

                        if (nHitsStt < 0) nHitsStt = 0;

                        PndSttHit* fairSttHit = sttHits[i];

                        if (fStrawMap.IsSkewedStraw(fairSttHit->GetTubeID())){
//                              actTrack.correctSttSkewedHit(fairSttHit, fStrawMap.GetTube(fairSttHit->GetTubeID()));
                                continue;
                        }


//                      PndSttHit* correctedSttHit = new PndSttHit(CalculateCorrectedSTTHit(*fairSttHit, actTrack));
//                      correctedSttHit->SetDxyz(fairSttHit->GetDx(), fairSttHit->GetDy(), fairSttHit->GetDz());
//                      correctedSttHit->SetEntryNr(FairLink(FairRootManager::Instance()->GetBranchId("STTHit"), i));
                        PndRiemannHit actHit(fairSttHit, fMapIDtoHit[fairSttHit->GetEntryNr()]);



                        if (fVerbose > 2) {
                                std::cout << std::endl;
                                std::cout << "-I- PndMvdSttGemRiemannTrackFinder SearchSector: Act Hit: " << fairSttHit->GetEntryNr() << std::endl;
                        }

//                      if (CheckRiemannHitStt(&actTrack, &actHit,(FairHit*)fSttHits->At(i)) != true) continue;
                        if (CheckRiemannHitStt(&actTrack, &actHit,fairSttHit) != true) continue;

                        if (fVerbose > 2 )
                                std::cout << "-I- PndMvdSttGemRiemannTrackFinder SearchSector: STTHit add to Track!" << std::endl;

                        actTrack.addHit(actHit);
                        startTrack.insert(fMapIDtoHit[actHit.hit()->GetEntryNr()]);
                        actTrack.refit(kFALSE);
//                      actTrack.szFit(kFALSE);
                        nHitsStt++;
                        if (fStrawMap.IsSectorBorderStraw(fairSttHit->GetTubeID()) != 0){
                                if (fVerbose > 2)
                                        std::cout << " TubeID: " << fairSttHit->GetTubeID() << " Sector: " << fStrawMap.GetSector(fairSttHit->GetTubeID()) << std::endl;
                                if (nextSectorDirection == 0){
                                        nextSectorDirection = fStrawMap.IsSectorBorderStraw(fairSttHit->GetTubeID());
                                } else if(nextSectorDirection != fStrawMap.IsSectorBorderStraw(fairSttHit->GetTubeID())){
                                        continue;
                                }
                                searchSector = fStrawMap.GetSector(fairSttHit->GetTubeID()) + fStrawMap.IsSectorBorderStraw(fairSttHit->GetTubeID());
                                searchSector %= 6;
                                if (searchSector < 0)
                                        searchSector = 5;

                                if (fVerbose > 2 )
                                        std::cout << "-I- PndMvdSttGemRiemannTrackFinder SearchSector: Next Sector: " << searchSector << " " << fStrawMap.IsSectorBorderStraw(fairSttHit->GetTubeID())<< std::endl;

                                continueSearch = true;
                        }

                }
                if (nHitsStt == 0){                                                                                                             //if you have not found any sttHits and you have not looked yet into the left sector from the start sector continue otherwise stop.
                        if (searchSector != fStrawMap.GetLeftSector(startSector))
                                continueSearch = true;
                        else
                                continueSearch = false;
                }
        }
}

bool PndMvdSttGemRiemannTrackFinder::CheckBoarderHitsStt ( PndTrackCand *  track )

private

Definition at line 983 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrackFinder::fHits, PndRiemannTrackFinder::fMapIDtoHit, fStrawMap, PndRiemannTrackFinder::fVerbose, PndSttStrawMap::GetRow(), PndSttHit::GetTubeID(), and i.

Referenced by FindTracks().

{
        FairMultiLinkedData sttHitsInTrack = track->GetLinksWithType(FairRootManager::Instance()->GetBranchId("STTHit"));

        for (int i = 0; i < sttHitsInTrack.GetNLinks(); i++){
                PndSttHit* mySttHit = (PndSttHit*)fHits[fMapIDtoHit[sttHitsInTrack.GetLink(i)]];
                if (fVerbose > 1) std::cout << "-I- PndMvdSttGemRiemannTrackFinder::CheckBoarderHitsStt Stt Index: " << mySttHit->GetTubeID() << std::endl;
                if (fStrawMap.GetRow(mySttHit->GetTubeID()) == 0)
                        return true;
        }
        return false;
}

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

protectedinherited

Tests if the distance is larger than fMinPointDistance.

Definition at line 238 of file PndRiemannTrackFinder.cxx.

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

Referenced by PndRiemannTrackFinder::FindTracks(), FindTracks(), GetStartTracks(), PndRiemannTrackFinder::GetStartTracks(), and 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  )

protectedinherited

Tests if hits in the same sensor are selected.

Definition at line 305 of file PndRiemannTrackFinder.cxx.

References PndRiemannTrackFinder::fHits.

Referenced by GetStartTracks(), and PndRiemannTrackFinder::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  )

protectedinherited

Check if this HitId is used in the track already.

Definition at line 320 of file PndRiemannTrackFinder.cxx.

References PndRiemannTrackFinder::fVerbose.

Referenced by 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 PndMvdSttGemRiemannTrackFinder::CheckRiemannHit ( PndRiemannTrack *  track, PndRiemannHit *  hit, FairHit *  fairHit  )

private

Definition at line 809 of file PndMvdSttGemRiemannTrackFinder.cxx.

References CheckRiemannHitGem(), CheckRiemannHitMvd(), and CheckRiemannHitStt().

Referenced by FindTracks().

{
        if (fairHit->GetEntryNr().GetType() == FairRootManager::Instance()->GetBranchId("MVDHitsStrip") ||
                fairHit->GetEntryNr().GetType() == FairRootManager::Instance()->GetBranchId("MVDHitsPixel")     ){
                return CheckRiemannHitMvd(track, hit, fairHit);
        } else if (fairHit->GetEntryNr().GetType() == FairRootManager::Instance()->GetBranchId("GEMHit")) {
                return CheckRiemannHitGem(track, hit, fairHit);
        } else if (fairHit->GetEntryNr().GetType() == FairRootManager::Instance()->GetBranchId("STTHit")) {
                return CheckRiemannHitStt(track, hit, fairHit);
        } else {
                std::cout << "-E- PndMvdRIemannTrackFinder::CheckRiemannHit: Detector " << FairRootManager::Instance()->GetBranchName(fairHit->GetEntryNr().GetType()) <<
                                " not supported!" << std::endl;
        }
        return false;
}

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

protectedinherited

Definition at line 331 of file PndRiemannTrackFinder.cxx.

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

Referenced by PndRiemannTrackFinder::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 PndMvdSttGemRiemannTrackFinder::CheckRiemannHitGem ( PndRiemannTrack *  track, PndRiemannHit *  hit, FairHit *  fairHit  )

private

Definition at line 913 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrack::calcSZChi2(), PndRiemannTrack::dist(), fabs(), PndRiemannTrackFinder::fVerbose, and PndRiemannTrack::szDist().

Referenced by AssignGemHits(), and CheckRiemannHit().

{
        double dist = track->dist(hit);
        double maxDist = 2;
        double szDist = track->szDist(hit);
        double maxSZDist = 10;
        double szChi2 = track->calcSZChi2(hit);
        double maxSZChi2 = 25;
        //double r = track->r(); //[R.K. 01/2017] unused variable?
        //double dip=track->dip(); //[R.K. 01/2017] unused variable?
        //bool sign; //[R.K.02/2017] Unused variable?
        //if ((track->getHit(1)->z())>0 ) //[R.K.02/2017] Unused variable?
                //sign=true; //[R.K.02/2017] Unused variable?
        //else sign=false; //[R.K.02/2017] Unused variable?
        if (fVerbose > 1) std::cout << "Checking GemHit: " << fairHit->GetEntryNr() << std::endl;
        if (fVerbose > 1) std::cout << ": dist " << dist << " szDist " << szDist << " szChi2 " << szChi2 << std::endl;
  
        if (fabs(dist) > maxDist){
                if (fVerbose > 1) std::cout << "dist larger than " << maxDist << std::endl;
                return false;
        }

        if (szChi2 > maxSZChi2){
                if (fVerbose > 1) std::cout << " SZ Chi2 too big! Cut at: " << maxSZChi2 << std::endl;
                return false;
        }
        if (fabs(szDist) > maxSZDist){
                if (fVerbose > 1) std::cout << "SZ Dist too big! Cut at: " << maxSZDist << std::endl;
                return false;
        }
        return true;
}

bool PndMvdSttGemRiemannTrackFinder::CheckRiemannHitMvd ( PndRiemannTrack *  track, PndRiemannHit *  hit, FairHit *  fairHit  )

private

Definition at line 946 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrack::calcSZChi2(), PndRiemannTrack::dip(), PndRiemannTrack::dist(), fabs(), PndRiemannTrackFinder::fMaxSZDist, PndRiemannTrackFinder::fVerbose, PndRiemannTrack::getHit(), GetMaxPlaneDist(), r, PndRiemannTrack::r(), sign(), PndRiemannTrack::szDist(), and PndRiemannHit::z().

Referenced by CheckRiemannHit().

{
        //double oldSZChi2 = track->szChi2(); //[R.K. 01/2017] unused variable?
        double dist = track->dist(hit);
        double szDist = track->szDist(hit);
        double szChi2 = track->calcSZChi2(hit);
        double r = track->r();
        double dip=track->dip();
        bool sign;
        if ((track->getHit(1)->z())>0 )
                sign=true;
        else sign=false;
        if (fVerbose > 1) std::cout << ": dist " << dist << " szDist " << szDist << " szChi2 " << szChi2 << std::endl;

        if (fabs(dist) > GetMaxPlaneDist(r,dip,sign)){
                if (fVerbose > 1) std::cout << "dist larger than " << GetMaxPlaneDist(r,dip,sign) << std::endl;
                return false;
        }

//      if (fVerbose > 1) std::cout << "CheckRiemannHitMvd oldSZChi2 " << oldSZChi2 << " new SZChi2 " << szChi2 << std::endl;

//      if (oldSZChi2 < szChi2){
//              if (fVerbose > 1) std::cout << " SZ Chi2 " << szChi2 << " bigger than before!  " << oldSZChi2 << std::endl;
//              return false;
//      }

//      if (szChi2 > GetMaxSZChi2(r,dip,sign)){
//              if (fVerbose > 1) std::cout << " SZ Chi2 too big! Cut at: " << GetMaxSZChi2(r,dip,sign) << 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 PndMvdSttGemRiemannTrackFinder::CheckRiemannHitSkewedStt ( PndRiemannTrack *  track, PndRiemannHit *  hit, FairHit *  fairHit  )

private

Definition at line 872 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrack::dist(), fabs(), and PndRiemannTrackFinder::fVerbose.

Referenced by AssignSkewedSttHits().

{


//      std::cout << "CheckRiemannHit PndRiemannHit: " << hit->x().X() << "/" << hit->x().Y() << "/" << hit->x().Z() << " " << hit->z() << std::endl;

        double dist = track->dist(hit);
//      std::cout << "CheckRiemannHit PndRiemannHit:Dist " << dist << std::endl;

        double maxDist = 1;
//      double szDist = track->szDist(hit);
//      double maxSZDist = 10;
//      double szChi2 = track->calcSZChi2(hit);
//      double maxSZChi2 = 25;
        //double r = track->r(); //[R.K. 01/2017] unused variable?
        //bool sign; //[R.K.02/2017] Unused variable?
        //if ((track->getHit(1)->z())>0 ) //[R.K.02/2017] Unused variable?
                //sign=true; //[R.K.02/2017] Unused variable?
        //else sign=false; //[R.K.02/2017] Unused variable?
        if (fVerbose > 1) std::cout << "STTHit: dist " << dist << std::endl;

        if (fabs(dist) > maxDist){
                if (fVerbose > 1)
                        std::cout << "dist larger than " << maxDist << std::endl;
                return false;
        } else {

//              std::cout << "PndMvdSttGemRiemannTrackFinder::CheckRiemannHitStt Hit taken! Dist: " << dist << " < " << maxDist << std::endl << std::endl;
        }
//
//      if (szChi2 > maxSZChi2){
//              if (fVerbose > 1) std::cout << " SZ Chi2 too big! Cut at: " << maxSZChi2 << std::endl;
//              return false;
//      }
//      if (fabs(szDist) > maxSZDist){
//              if (fVerbose > 1) std::cout << "SZ Dist too big! Cut at: " << maxSZDist << std::endl;
//              return false;
//      }
        return true;
}

bool PndMvdSttGemRiemannTrackFinder::CheckRiemannHitStt ( PndRiemannTrack *  track, PndRiemannHit *  hit, FairHit *  fairHit  )

private

Definition at line 825 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrack::correctSttHit(), PndRiemannTrack::dist(), fabs(), PndRiemannTrackFinder::fVerbose, PndRiemannHit::setDXYZ(), PndRiemannHit::setXYZ(), PndRiemannHit::sigmaX(), PndRiemannHit::sigmaY(), and PndRiemannHit::x().

Referenced by AssignSttHits(), and CheckRiemannHit().

{
        PndRiemannHit tempHit = track->correctSttHit((PndSttHit*)fairHit);

//      std::cout << "CheckRiemannHit PndRiemannHit: " << fairHit->GetEntryNr() << " : " << hit->x().X() << "/" << hit->x().Y() << "/" << hit->x().Z() << " " << hit->z() << std::endl;
//      std::cout << "CheckRiemannHit PndRiemannHit: " << tempHit.x().X() << "/" << tempHit.x().Y() << "/" << tempHit.x().Z() << " " << tempHit.z() << std::endl;

        hit->setXYZ(tempHit.x().X(), tempHit.x().Y(), tempHit.x().Z());
        hit->setDXYZ(tempHit.sigmaX(), tempHit.sigmaY(), 200);

//      std::cout << "CheckRiemannHit PndRiemannHit: " << hit->x().X() << "/" << hit->x().Y() << "/" << hit->x().Z() << " " << hit->z() << std::endl;

        double dist = track->dist(hit);
//      std::cout << "CheckRiemannHit PndRiemannHit:Dist " << dist << std::endl;

        double maxDist = 1;
//      double szDist = track->szDist(hit);
//      double maxSZDist = 10;
//      double szChi2 = track->calcSZChi2(hit);
//      double maxSZChi2 = 25;
        //double r = track->r(); //[R.K. 01/2017] unused variable?
        //bool sign; //[R.K.02/2017] Unused variable?
        //if ((track->getHit(1)->z())>0 ) //[R.K.02/2017] Unused variable?
                //sign=true; //[R.K.02/2017] Unused variable?
        //else sign=false; //[R.K.02/2017] Unused variable?
        if (fVerbose > 1) std::cout << "STTHit: dist " << dist << std::endl;

        if (fabs(dist) > maxDist){
                if (fVerbose > 1)
                        std::cout << "dist larger than " << maxDist << std::endl;
                return false;
        } else {

//              std::cout << "PndMvdSttGemRiemannTrackFinder::CheckRiemannHitStt Hit taken! Dist: " << dist << " < " << maxDist << std::endl << std::endl;
        }
//
//      if (szChi2 > maxSZChi2){
//              if (fVerbose > 1) std::cout << " SZ Chi2 too big! Cut at: " << maxSZChi2 << std::endl;
//              return false;
//      }
//      if (fabs(szDist) > maxSZDist){
//              if (fVerbose > 1) std::cout << "SZ Dist too big! Cut at: " << maxSZDist << std::endl;
//              return false;
//      }
        return true;
}

bool PndMvdSttGemRiemannTrackFinder::CheckSZ ( PndRiemannTrack  aTrack )

private

Tests the results of the sz fit.

Definition at line 793 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrack::dip(), PndRiemannTrackFinder::fVerbose, PndRiemannTrack::getHit(), GetMaxSZChi2(), r, PndRiemannTrack::r(), sign(), PndRiemannTrack::szChi2(), PndRiemannTrack::szFit(), and PndRiemannHit::z().

Referenced by GetStartTracks().

{
        aTrack.szFit(false);
        double r = aTrack.r();
        double dip=aTrack.dip();
        bool sign;
        if ((aTrack.getHit(0)->z())>0 )
                sign=true;
        else sign=false;
        if (aTrack.szChi2() > GetMaxSZChi2(r,dip,sign) || aTrack.szChi2() < 0){
                if (fVerbose > 1) std::cout << "sz-Fit does not match, Chi2: " << aTrack.szChi2() << " max: " << GetMaxSZChi2(r,dip,sign) << std::endl;
                return false;
        }
        return true;
}

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

protectedinherited

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 PndRiemannTrackFinder::fHits, PndRiemannTrackFinder::fMapHitToID, PndRiemannTrackFinder::fVerbose, and hit.

Referenced by FindTracks(), and 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  )

protectedinherited

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 PndRiemannTrackFinder::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 )

protectedinherited

Creates a PndRiemannTrack from an array of indices of Hits.

Definition at line 292 of file PndRiemannTrackFinder.cxx.

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

Referenced by PndRiemannTrackFinder::FindTracks(), and 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 PndMvdSttGemRiemannTrackFinder::FindTracks

(

)

Main function to start the riemann track finding.

< finding layer's number of start hit

Definition at line 259 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndTrackCand::AddHit(), PndRiemannTrack::addHit(), AssignGemHits(), AssignSkewedSttHits(), AssignSttHits(), CheckBoarderHitsStt(), PndRiemannTrackFinder::CheckHitDistance(), PndRiemannTrackFinder::CheckHitInTrack(), CheckRiemannHit(), PndRiemannTrackFinder::CheckZeroPassing(), PndRiemannTrack::correctSttHits(), PndRiemannTrackFinder::CreateRiemannTrack(), PndRiemannTrack::dip(), PndRiemannTrackFinder::fCurvAndDipOfCand, fGemHits, PndRiemannTrackFinder::fHits, PndRiemannTrackFinder::fHitsInTracks, PndRiemannTrackFinder::fHitsTooClose, fLayers, PndRiemannTrackFinder::fMapHitToID, PndRiemannTrackFinder::fMinNumberOfHits, fNLayers, fSkewedSttHits, fSttHits, PndRiemannTrackFinder::fTrackCand, PndRiemannTrackFinder::fTracks, PndRiemannTrackFinder::fVerbose, PndTrackCand::GetNHits(), PndRiemannTrack::getNumHits(), GetStartTracks(), PndRiemannTrack::getSZm(), PndRiemannTrack::getSZt(), GetTooCloseHitsInLayer(), hits, i, n, PndRiemannTrack::orig(), p, PndTrackCand::Print(), r, PndRiemannTrack::r(), PndRiemannTrack::refit(), s, PndRiemannTrack::szFit(), PndRiemannTrackFinder::TrackExists(), and TrackHits().

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

{

//      SetVerbose(3);

        std::vector<std::set<Int_t> > Tracks = GetStartTracks();                                //Get the possible track seeds

        std::set<int> tooClose;
        std::set<int>::iterator iter;

        fTracks.clear();
        fTrackCand.clear();
        for (unsigned int trackId = 0; trackId < Tracks.size(); trackId++){                             //Go through all track seeds and search for additional points
    
                if (Tracks[trackId].size() != 3)
                        if (fVerbose > 1) std::cout << "-E- PndMVDRiemannTrackFinder::FindTracks: Start points: " << Tracks[trackId].size()
                                          << " in Track: " << trackId << std::endl;
    
                std::set<Int_t> StartTrack = Tracks[trackId];
    
                if (fVerbose > 1){
                        if (fVerbose > 1)
                        {
                                std::cout << "------------------------------------" << std::endl;

                                iter = StartTrack.begin();
                                std::cout << "Start Plane from Points: " << fMapHitToID[*iter] << " "
                                          << fMapHitToID[*(++iter)] << " "  << fMapHitToID[*(++iter)] << std::endl;
                                iter = StartTrack.begin();
                                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);
                int startLayer=0;
                int startHit=*(StartTrack.begin());
    
                bool flag=false;
                for(int i=1;i<fNLayers;i++){                                                                    
                        for(unsigned int j=0;j<fLayers[i].size();j++){
                                if(fLayers[i][j]==startHit){
                                        startLayer=i;
                                        flag=true;
                                        break;
                                }
                        }
                        if (flag) break;
                }
    
                int testHit;
                for (int Layer=startLayer;Layer<fNLayers;Layer++){
                        //if ((fHits[startHit]->GetZ()<(-fZClosePar)) && (Layer==2 or Layer==3 or Layer==5 or Layer==6 or Layer==8 or Layer==10)) continue;  /// < in case of backward tracks disk layers can't contain hits
                        for(unsigned int testHitInLayer=0; testHitInLayer<fLayers[Layer].size();testHitInLayer++){
                                testHit=fLayers[Layer][testHitInLayer];
        
                                if (fVerbose > 2) if (fVerbose > 1) std::cout << "Layer: " << Layer << " hitInLayer: " << testHitInLayer << " hitID " << testHit << " ";
                                if (fVerbose > 1) std::cout << "Point " << fMapHitToID[testHit] << " ";

                                if (CheckHitInTrack(StartTrack, testHit)) continue;
                                iter = StartTrack.begin();
                                if (CheckHitDistance(*(iter)  , testHit)!=true) continue;
                                if (CheckHitDistance(*(++iter), testHit)!=true) continue;
                                if (CheckHitDistance(*(++iter), testHit)!=true) continue;
                                if (CheckZeroPassing(StartTrack, testHit)== true) continue;
        
        
                                //if ((fHits[startHit]->GetZ())*(fHits[testHit]->GetZ())<0 && fabs(fHits[startHit]->GetZ())>fZClosePar && fabs(fHits[testHit]->GetZ())>fZClosePar)  continue; //check the same direction on z axis
        
                                PndRiemannHit actHit(fHits[testHit], testHit);
                                if (CheckRiemannHit(&actTrack, &actHit, fHits[testHit]) != true) continue;
        
                                StartTrack.insert(testHit);
        
                                actTrack.addHit(actHit);
                                actTrack.refit(false);
                                actTrack.szFit(false);
        
                                TVectorD orig = actTrack.orig();
                                if (fVerbose > 1) std::cout << "actHit added: " << testHit  << " r: " << actTrack.r() << " orig: " << orig[0] << " " << orig[1] << std::endl;
                                tooClose=GetTooCloseHitsInLayer(Layer,testHit);
                                fHitsTooClose[trackId].insert(tooClose.begin(),tooClose.end());
                                //break;
                        }
                }

                if (fVerbose > 1) {
                        std::cout << std::endl;
                        std::cout << "PndMvdSttGemRiemannTrackFinder::FindTracks ActTrack for Assignment: ";
                        for (iter = StartTrack.begin(); iter != StartTrack.end(); iter++){
                                int hitId = *iter;
                                std::cout << fMapHitToID[hitId] << " ";
                        }
                        std::cout << std::endl;
                }

                if (fVerbose > 1) std::cout << "Track before STT: " << actTrack << std::endl;

                if (fSttHits != NULL){                                                                                                                  //assign STTHits to Mvd track
                        if (fVerbose > 1 )
                                std::cout << "PndMvdSttGemRiemannTrackFinder::FindTracks AssignSttHits" << std::endl;
                        AssignSttHits(actTrack, StartTrack);
                        if (fVerbose > 1 )
                                std::cout << "ActTrack size with Stt: " << actTrack.getNumHits() << " " << StartTrack.size() << std::endl;
                        actTrack.refit(false);
                        actTrack.szFit(false);
                        actTrack.correctSttHits();
                        actTrack.refit(false);
                        actTrack.szFit(false);
                        actTrack.correctSttHits();
                        actTrack.refit(false);
                        actTrack.szFit(false);


                }

                if (fSkewedSttHits != NULL){
                        if (fVerbose > 1 )
                                std::cout << "PndMvdSttGemRiemannTrackFinder::FindTracks AssignSkewedSttHits" << std::endl;
                        AssignSkewedSttHits(actTrack, StartTrack);
                        if (fVerbose > 1 )
                                std::cout << "ActTrack size with Stt: " << actTrack.getNumHits() << " " << StartTrack.size() << std::endl;
                        actTrack.refit(false);
                        actTrack.szFit(false);
                }

                if (fVerbose > 1) std::cout << "Track after STT: " << actTrack << std::endl;

                if (fGemHits != NULL){
                        if (fVerbose > 1 )
                                if (fVerbose > 1) std::cout << "PndMvdSttGemRiemannTrackFinder::FindTracks AssignGemHits" << std::endl;
                        AssignGemHits(actTrack, StartTrack);
                        if (fVerbose > 1 )
                                if (fVerbose > 1) std::cout << "ActTrack size with Gem: " << actTrack.getNumHits() << " " << StartTrack.size() << std::endl;
                        actTrack.refit(false);
                        actTrack.szFit(false);

                }

                if (fVerbose > 1) std::cout << "Track after GEM: " << actTrack << std::endl;


                if ((int)actTrack.getNumHits() > (fMinNumberOfHits-1))          //if you have a track match check hits which were to close
                {
                        std::set<int> hits = fHitsTooClose[trackId];
                        if (fVerbose > 1) std::cout << "HitsTooClose Test for Track: " << actTrack << std::endl;
                        for (iter = hits.begin(); iter != hits.end(); iter++){
                                if (fVerbose > 1) std::cout << "Too Close Point " << *iter << ": " << fMapHitToID[*iter];
                                if (CheckHitInTrack(StartTrack, *iter)) continue;
                                PndRiemannHit actHit(fHits[*iter]);
                                if (CheckRiemannHit(&actTrack, &actHit, fHits[*iter])!= true) continue;
                                StartTrack.insert(*iter);
                                actTrack.addHit(actHit);
        
                        }
      
//                      actTrack.refit(false);
//                      actTrack.szFit(false);
      
                        if (fVerbose > 1) std::cout << "Hits in Track: " << StartTrack.size() << std::endl;

                        fTracks.push_back(actTrack);
                        fHitsInTracks.push_back(StartTrack);

                        if (fVerbose > 1){
                                TVectorD orig = actTrack.orig();
                                if (fVerbose > 1)
                                        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 > 1) {
                                for (iter = StartTrack.begin(); iter != StartTrack.end(); iter++)
                                {
                                                 std::cout << " " << fMapHitToID[*iter];
                                }
                        }
                }
        }
  
  //    if (fVerbose > 1) std::cout << "In PndMvdRiemannTrackFinder are: " << fTracks.size() << " tracks" << std::endl;
        for (unsigned int n = 0; n < fTracks.size(); n++){
                PndTrackCand myTrackCand;
                bool trackFound = false;
                std::vector<PndRiemannHit> TrackHits = fTracks[n].getHits();
    
                for (unsigned int p = 0; p < TrackHits.size(); p++){
                        if (fVerbose > 1) std::cout << "HitID: " << TrackHits[p].hitID() << std::endl;
                        if (TrackHits[p].hitID() > -1){
                                myTrackCand.AddHit(fMapHitToID[TrackHits[p].hitID()], TrackHits[p].s());
                        }

                }
                if (fVerbose > 1) std::cout << "NPoints TrackCand: " << myTrackCand.GetNHits() << std::endl;
                if (fVerbose > 1) myTrackCand.Print();
                FairMultiLinkedData gemHits = myTrackCand.GetLinksWithType(FairRootManager::Instance()->GetBranchId("GEMHit"));
                FairMultiLinkedData sttHits = myTrackCand.GetLinksWithType(FairRootManager::Instance()->GetBranchId("STTHit"));
                if (gemHits.GetNLinks() > 3){
                        fTrackCand.push_back(myTrackCand);
                        trackFound = true;
                }
                else if (sttHits.GetNLinks() > 3 && CheckBoarderHitsStt(&myTrackCand)) {
                        fTrackCand.push_back(myTrackCand);
                        trackFound = true;
//              } else if (gemHits.GetNLinks() == 0 && sttHits.GetNLinks() == 0) {
//                      fTrackCand.push_back(myTrackCand);
//                      trackFound = true;
                } else {
                        fTracks.erase(fTracks.begin()+n);
                        n--;
                }
                if (trackFound) {
//                      fTracks[n].refit(false);
//                      fTracks[n].szFit(false);
                        std::pair<double,double> CurvDip(1/fTracks[n].r(),fTracks[n].dip());
                        fCurvAndDipOfCand.push_back(CurvDip);

                        if (fVerbose > 0){
                                std::cout << "PndMvdSttGemRiemannTrackFinder::FindTracks TrackFound: " << myTrackCand << std::endl;
                        }
                        if (fVerbose > 1) std::cout << " numHits: " << fTracks[n].getNumHits() << std::endl;
//                      if (fVerbose > 1)
                        {
                                TVectorD myOrig = fTracks[n].orig();
                                std::cout << "Track: " << fTracks[n] << std::endl;
                                std::cout << " curv: " << 1/fTracks[n].r() << "+/-" << fTracks[n].dR()/(fTracks[n].r() * fTracks[n].r())
                                        << " dip: " << fTracks[n].dip() << "+/-" << fTracks[n].dDip()
                                        << " orig: " << myOrig[0] << "+/-" << fTracks[n].dX()
                                        << " " << myOrig[1] << "+/-" << fTracks[n].dY() << std::endl;
                                std::cout << "PlaneChiSquare: " << fTracks[n].calcChi2Plane() << std::endl;
                        }
                }
        }
  
  //    if (fVerbose > 1) std::cout << "Hits before merging: " << fTrackCand.size() << std::endl;
  //    MergeTracks();
  //    fTrackCand.clear();
  //    fTrackCand = fMergedTrackCand;
  //    if (fVerbose > 0) {
  //            if (fVerbose > 1) std::cout << "Tracks after merging:" << fMergedTrackCand.size() << std::endl;
  //            for (unsigned int p = 0; p < fTrackCand.size(); p++){
  //                    fTrackCand[p].Print();
  //            }                                                                                       ///todo Create RiemannTracks out of PndTrackCands
  //    }
  
}

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

protectedinherited

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

Definition at line 448 of file PndRiemannTrackFinder.cxx.

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

Referenced by PndRiemannTrackFinder::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  )

protectedinherited

Definition at line 412 of file PndRiemannTrackFinder.cxx.

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

Referenced by PndRiemannTrackFinder::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;
}

int PndMvdSttGemRiemannTrackFinder::GetLayer ( TString  identifier )

private

Definition at line 226 of file PndMvdSttGemRiemannTrackFinder.cxx.

References fLayerMap.

Referenced by GetLayerGem(), and GetLayerMvd().

{
        std::map<TString, int>::iterator layerIter;
        for (layerIter = fLayerMap.begin(); layerIter != fLayerMap.end(); layerIter++){
                if(identifier.Contains(layerIter->first)){
                        return layerIter->second;
                }
        }
        return 0;
}

int PndMvdSttGemRiemannTrackFinder::GetLayerGem ( FairHit *  hit )

private

Definition at line 237 of file PndMvdSttGemRiemannTrackFinder.cxx.

References GetLayer(), PndGemHit::GetSensorNr(), PndGemHit::GetStationNr(), and TString.

Referenced by AddHits().

{
        PndGemHit* gemHit = (PndGemHit*)hit;

        TString prefix("Gem_");
        prefix+=(gemHit->GetStationNr());
        prefix+=("_");
        prefix+=(gemHit->GetSensorNr());

        return GetLayer(prefix);

}

int PndMvdSttGemRiemannTrackFinder::GetLayerMvd ( FairHit *  hit )

private

Definition at line 250 of file PndMvdSttGemRiemannTrackFinder.cxx.

References fGeoH, GetLayer(), PndGeoHandling::GetPath(), PndSdsHit::GetSensorID(), and TString.

Referenced by AddHits().

{
        PndSdsHit* tempHit = (PndSdsHit*) (hit);
        TString geoPath = fGeoH->GetPath(tempHit->GetSensorID());

        return GetLayer(geoPath);

}

double PndMvdSttGemRiemannTrackFinder::GetMaxPlaneDist ( double  radius, double  dip, bool  sign  )

private

calc Theta from dip

Definition at line 1046 of file PndMvdSttGemRiemannTrackFinder.cxx.

References fabs(), fCutDistH, PndRiemannTrackFinder::fMaxPlaneDist, Pi, and CAMath::Tan().

Referenced by CheckRiemannHitMvd().

{
        double Pt=((radius/100)*2*3*1E8)/1E9;
        double Theta;
        if (fabs(TMath::ACos(dip)) < 1E-100){
                Theta = 0;
        }
        else {
          if (sign) Theta=(TMath::ATan(TMath::Power(TMath::Tan(TMath::ACos(dip)),-1)))*180/TMath::Pi(); 
          else Theta=(TMath::Pi()-TMath::ATan(TMath::Power(TMath::Tan(TMath::ACos(dip)),-1)))*180/TMath::Pi();
        }
  
  if(fCutDistH!=NULL){
    double minPt=fCutDistH->GetXaxis()->GetXmin();
    double maxPt=fCutDistH->GetXaxis()->GetXmax();
    double minTh=fCutDistH->GetYaxis()->GetXmin();
    double maxTh=fCutDistH->GetYaxis()->GetXmax();
    
    int binPt=int(floor((Pt-minPt)*fCutDistH->GetXaxis()->GetNbins()/(maxPt-minPt)))+1;
    int binTh=int(floor((Theta-minTh)*fCutDistH->GetYaxis()->GetNbins()/(maxTh-minTh)))+1;
    
    if (binPt<1) binPt=1;
    if (binPt>fCutDistH->GetXaxis()->GetNbins()) binPt=fCutDistH->GetXaxis()->GetNbins();
    if (binTh<1) binTh=1;
    if (binTh>fCutDistH->GetYaxis()->GetNbins()) binTh=fCutDistH->GetYaxis()->GetNbins();
    return fCutDistH->GetBinContent(binPt,binTh);
    
  }
  else
    return fMaxPlaneDist;
}

double PndMvdSttGemRiemannTrackFinder::GetMaxSZChi2 ( double  radius, double  dip, bool  sign  )

private

calc Theta from dip

Definition at line 1078 of file PndMvdSttGemRiemannTrackFinder.cxx.

References fabs(), fCutChi2H, PndRiemannTrackFinder::fMaxSZChi2, Pi, and CAMath::Tan().

Referenced by CheckSZ().

{
        double Pt=((radius/100)*2*3*1E8)/1E9;
        double Theta;
        if (fabs(TMath::ACos(dip)) < 1E-100){
                Theta = 0;
        }
        else {
          if (sign) Theta=(TMath::ATan(TMath::Power(TMath::Tan(TMath::ACos(dip)),-1)))*180/TMath::Pi();   
          else Theta=(TMath::Pi()-TMath::ATan(TMath::Power(TMath::Tan(TMath::ACos(dip)),-1)))*180/TMath::Pi();
        }
        if(fCutChi2H!=NULL){
    double minPt=fCutChi2H->GetXaxis()->GetXmin();
    double maxPt=fCutChi2H->GetXaxis()->GetXmax();
    double minTh=fCutChi2H->GetYaxis()->GetXmin();
    double maxTh=fCutChi2H->GetYaxis()->GetXmax();
    
    int binPt=int(floor((Pt-minPt)*fCutChi2H->GetXaxis()->GetNbins()/(maxPt-minPt)))+1;
    int binTh=int(floor((Theta-minTh)*fCutChi2H->GetYaxis()->GetNbins()/(maxTh-minTh)))+1;
    
    if (binPt<1) binPt=1;
    if (binPt>fCutChi2H->GetXaxis()->GetNbins()) binPt=fCutChi2H->GetXaxis()->GetNbins();
    if (binTh<1) binTh=1;
    if (binTh>fCutChi2H->GetYaxis()->GetNbins()) binTh=fCutChi2H->GetYaxis()->GetNbins();
    return fCutChi2H->GetBinContent(binPt,binTh);
    
  }
  else
    return fMaxSZChi2;
}

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

inlineinherited

Definition at line 33 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fMergedTrackCand.

{return fMergedTrackCand;}

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

inlineinherited

Returns the track with the index i.

Definition at line 30 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fTracks, and i.

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

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

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

private

going through layers : first, second and third

Definition at line 514 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrack::addHit(), PndRiemannTrackFinder::CheckHitDistance(), PndRiemannTrackFinder::CheckHitInSameSensor(), CheckSZ(), PndRiemannTrackFinder::CheckZeroPassing(), PndRiemannTrackFinder::fHits, PndRiemannTrackFinder::fHitsTooClose, fLayers, PndRiemannTrackFinder::fMapHitToID, fNLayers, PndRiemannTrackFinder::fUseZeroPos, PndRiemannTrackFinder::fVerbose, GetTooCloseHitsInLayer(), i, PndRiemannTrack::orig(), and PndRiemannTrack::refit().

Referenced by FindTracks().

{
        std::set<Int_t> actCandidates;
        std::vector<std::set<Int_t> > Tracks;
        std::set<int> tooCloseFirst;
        std::set<int> tooCloseSecond;
        std::set<int> tooCloseThird;
        if (fHits.size() > 3) {
                int shift = 0;
                if (fUseZeroPos)
                        shift = 1;
                for (int FirstLayer = 1 - shift; FirstLayer < fNLayers - 2;     FirstLayer++) { 
                        for (int SecondLayer = FirstLayer + 1; SecondLayer < fNLayers - 1; SecondLayer++) {
//                              for (int ThirdLayer = SecondLayer + 1; ThirdLayer < fNLayers; ThirdLayer++) {
                                for (int ThirdLayer = fNLayers - 1; ThirdLayer > SecondLayer; ThirdLayer--) {

                                        for (unsigned int firstInLayer = 0; firstInLayer < fLayers[FirstLayer].size(); firstInLayer++) {
                                                int first = fLayers[FirstLayer][firstInLayer];
                                                // if ((fHits[first]->GetZ()<(-fZClosePar)) && (SecondLayer==2 or SecondLayer==3 or SecondLayer==5 or SecondLayer==6 or SecondLayer==8 or SecondLayer==10)) continue;
                                                for (unsigned int secondInLayer = 0; secondInLayer < fLayers[SecondLayer].size(); secondInLayer++) {
                                                        int second = fLayers[SecondLayer][secondInLayer];
                                                        // if ((fHits[second]->GetZ()<(-fZClosePar)) && (ThirdLayer==2 or ThirdLayer==3 or ThirdLayer==5 or ThirdLayer==6 or ThirdLayer==8 or ThirdLayer==10)) continue;
                                                        // if ((fHits[first]->GetZ())*(fHits[second]->GetZ())<0 && fabs(fHits[first]->GetZ())>fZClosePar && fabs(fHits[second]->GetZ())>fZClosePar) {/*printf("Diff Sign of Points  z1=%e  z2=%e \n",fHits[first]->GetZ(),fHits[second]->GetZ()); */continue;} //my// check the same direction on z axis

                                                        for (unsigned int thirdInLayer = 0;     thirdInLayer < fLayers[ThirdLayer].size(); thirdInLayer++) {
                                                                int third = fLayers[ThirdLayer][thirdInLayer];
                                                                //if ((fHits[second]->GetZ())*(fHits[third]->GetZ())<0 && fabs(fHits[second]->GetZ())>fZClosePar && fabs(fHits[third]->GetZ())>fZClosePar) {/*printf("Diff Sign of Points  z1=%e  z2=%e \n",fHits[first]->GetZ(),fHits[second]->GetZ());*/ continue;} //my// check the same direction on z axis
                                                                if (fVerbose > 2)
                                                                        std::cout
                                                                                        << "Checking Points for Start Triplet: "
                                                                                        << first << " " << second << " "
                                                                                        << third << std::endl;
                                                                if (fVerbose > 2)
                                                                        std::cout
                                                                                        << "Checking Points for Start Triplet: "
                                                                                        << fMapHitToID[first] << " "
                                                                                        << fMapHitToID[second] << " "
                                                                                        << fMapHitToID[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);

                                                                if (CheckZeroPassing(actCandidates, third)== true)      continue;

                                                                actCandidates.insert(third);

                                                                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(false);
                                                                if (CheckSZ(actTrack) != true)
                                                                        continue;
                                                                TVectorT<double> orig = actTrack.orig();
//                                                              if (fVerbose > 1)
                                                                {
                                                                        std::set<Int_t>::iterator iter = actCandidates.begin();
                                                                        std::cout << "Base plane from Points: "
                                                                                        << *(iter) << " " << *(iter++) << " "
                                                                                        << *(iter++) << std::endl;
                                                                        std::cout << "TrackParameter: " << actTrack << std::endl;
                                                                }
                                                                Tracks.push_back(actCandidates);
                                                                tooCloseFirst = GetTooCloseHitsInLayer(
                                                                                FirstLayer, first);
                                                                tooCloseSecond = GetTooCloseHitsInLayer(
                                                                                SecondLayer, second);
                                                                tooCloseThird = GetTooCloseHitsInLayer(
                                                                                ThirdLayer, third);
                                                                std::set<int> combHits = tooCloseFirst;
                                                                combHits.insert(tooCloseSecond.begin(), tooCloseSecond.end());
                                                                combHits.insert(tooCloseThird.begin(), tooCloseThird.end());
                                                                fHitsTooClose.push_back(combHits);

                                                        }

                                                }

                                        }

                                }
                        }
                }
        }

        if (fVerbose > 1) {
                std::cout << "Start Tracks are: " << std::endl;
                for (unsigned int i = 0; i < Tracks.size(); i++) {
                        std::set<int> aTrack = Tracks[i];
                        for (std::set<int>::iterator iter = aTrack.begin(); iter != aTrack.end(); iter++) {
                                std::cout << *iter << " ";
                        }
                        std::cout << std::endl;
                        for(std::set<int>::iterator iter = aTrack.begin(); iter != aTrack.end(); iter++) {
                                std::cout << fMapHitToID[*iter] << " ";
                        }
                                std::cout << std::endl;
                }
                        std::cout << std::endl;
        }
        return Tracks;
}

int PndMvdSttGemRiemannTrackFinder::GetStrawSector ( PndRiemannTrack &  track )

private

Definition at line 996 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrackFinder::fHits, PndSttStrawMap::FindPhiSector(), PndRiemannTrackFinder::fMapHitToID, PndRiemannTrackFinder::fMapIDtoHit, fStrawMap, PndRiemannTrackFinder::fVerbose, PndRiemannTrack::getHits(), and i.

Referenced by AssignSkewedSttHits(), and AssignSttHits().

{
        double radiusSq(.0), oldRadiusSq(.0);
        int indexHitMaxRadius(-1);


        std::vector<PndRiemannHit> riemannHits = track.getHits();

        for (size_t i = 0; i < riemannHits.size(); i++){
                FairLink hitLink = fMapHitToID[riemannHits[i].hitID()];
                if (fVerbose > 1) std::cout << "HitID Track : " << i << " : " << riemannHits[i].hitID() << " " << hitLink << std::endl;
                int branchId = hitLink.GetType();
                FairRootManager* man = FairRootManager::Instance();
                if (branchId == man->GetBranchId("MVDHitsStrip") || branchId == man->GetBranchId("MVDHitsPixel")){
                        FairHit* FairHit = (PndSdsHit*)fHits[fMapIDtoHit[hitLink]];
                        radiusSq = FairHit->GetX()*FairHit->GetX() + FairHit->GetY()*FairHit->GetY();
                        if (fVerbose > 1) std::cout << "-I- PndMvdSttGemRiemannTrackFinder::GetStrawSector FairHit: " << i << " : " << radiusSq << " " << *FairHit << std::endl;

                        if (radiusSq > oldRadiusSq){
                                oldRadiusSq = radiusSq;
                                indexHitMaxRadius = fMapIDtoHit[hitLink];
                        }
                }
        }
        if (indexHitMaxRadius > -1){
                if (fVerbose > 1) std::cout << "-I- PndMvdSttGemRiemannTrackFinder::GetStrawSector IndexHitMaxRadius: " << indexHitMaxRadius << " Link: " << fMapHitToID[indexHitMaxRadius] << std::endl;
                FairHit* FairHit = (PndSdsHit*)fHits[indexHitMaxRadius];
                TVector3 hitPos(FairHit->GetX(), FairHit->GetY(), FairHit->GetZ());
                if (fVerbose > 1) std::cout << "-I- PndMvdSttGemRiemannTrackFinder::GetStrawSector Phi: " << hitPos.Phi() << " PhiSector: " << fStrawMap.FindPhiSector(hitPos.Phi()) << std::endl;
                return fStrawMap.FindPhiSector(hitPos.Phi());
        }
        return -1;
}

std::set< int > PndMvdSttGemRiemannTrackFinder::GetTooCloseHitsInLayer ( int  LayerNumber, int  HitNumber  )

private

Definition at line 1030 of file PndMvdSttGemRiemannTrackFinder.cxx.

References PndRiemannTrackFinder::CheckHitDistance(), fLayers, and i.

Referenced by FindTracks(), and GetStartTracks().

{
        std::set<int> result;
        int testN;
        for(unsigned int i=0;i<fLayers[LayerNumber].size();i++){
                testN=fLayers[LayerNumber][i];
                if (CheckHitDistance(HitNumber, testN)!= true){
                        if (testN != HitNumber){
                                result.insert(testN);
                        }
                }
        }
        return result;
  
}

PndRiemannTrack PndRiemannTrackFinder::GetTrack ( int  i )

inlineinherited

Returns the number of found tracks.

Definition at line 29 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fTracks, and i.

Referenced by PndMvdSttGemRiemannTrackFinderTask::Exec().

{return fTracks[i];};                                   

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

inlineinherited

Returns the hits belonging to track i.

Definition at line 32 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fTrackCand.

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

{return fTrackCand;}

PndTrackCand PndRiemannTrackFinder::GetTrackCand ( int  i )

inlineinherited

Definition at line 34 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fTrackCand, and i.

{return fTrackCand[i];}

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

inlineinherited

Definition at line 31 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fHitsInTracks, and i.

{return fHitsInTracks[i];};     

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

inherited

Calculates the distance between two hits.

Definition at line 537 of file PndRiemannTrackFinder.cxx.

Referenced by PndRiemannTrackFinder::CheckHitDistance(), and PndRiemannTrackFinder::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  )

inherited

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

Definition at line 547 of file PndRiemannTrackFinder.cxx.

References fabs(), PndRiemannTrackFinder::fHits, PndRiemannTrackFinder::fVerbose, h1, PndRiemannTrackFinder::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 PndMvdSttGemRiemannTrackFinder::InitLayerMap ( )

private

Definition at line 28 of file PndMvdSttGemRiemannTrackFinder.cxx.

References InitLayerMapGem(), and InitLayerMapMvd().

Referenced by PndMvdSttGemRiemannTrackFinder().

{
        InitLayerMapMvd();
        InitLayerMapGem();
}

void PndMvdSttGemRiemannTrackFinder::InitLayerMapGem ( )

private

Definition at line 79 of file PndMvdSttGemRiemannTrackFinder.cxx.

References fLastLayerId, and fLayerMap.

Referenced by InitLayerMap().

{
        fLayerMap["Gem_1_1"] = fLastLayerId     + 1;
        fLayerMap["Gem_1_2"] = fLastLayerId     + 2;

        fLayerMap["Gem_2_1"] = fLastLayerId     + 3;
        fLayerMap["Gem_2_2"] = fLastLayerId     + 4;

        fLayerMap["Gem_3_1"] = fLastLayerId     + 5;
        fLayerMap["Gem_3_2"] = fLastLayerId     + 6;

        fLastLayerId += 6;

}

void PndMvdSttGemRiemannTrackFinder::InitLayerMapMvd ( )

private

Definition at line 34 of file PndMvdSttGemRiemannTrackFinder.cxx.

References fLastLayerId, and fLayerMap.

Referenced by InitLayerMap().

{
        fLayerMap["PixeloBlo1"] = fLastLayerId                                          + 1;
        fLayerMap["PixeloSdko(Silicon)_1"] = fLastLayerId                       + 2;       //naming after MVD2.2
        fLayerMap["PixeloSdkoco(Silicon)_1"] = fLastLayerId             + 2;
        fLayerMap["PixeloSdko(Silicon)_2"] = fLastLayerId                       + 3;       //naming after MVD2.2
        fLayerMap["PixeloSdkoco(Silicon)_2"] = fLastLayerId             + 3;
        fLayerMap["PixeloSdko(Silicon)_3"] = fLastLayerId                       + 4;       //naming after MVD2.2
        fLayerMap["PixeloSdkoco(Silicon)_3"] = fLastLayerId             + 4;
        fLayerMap["PixeloSdko(Silicon)_4"] = fLastLayerId                       + 5;       //naming after MVD2.2
        fLayerMap["PixeloSdkoco(Silicon)_4"] = fLastLayerId             + 5;
        fLayerMap["PixeloBlo2"] = fLastLayerId                                          + 6;
        fLayerMap["PixeloLdkoio(Silicon)_1"] = fLastLayerId             + 7;       //naming after MVD2.2
        fLayerMap["PixeloLdkoco(Silicon)_1"] = fLastLayerId             + 7;
        fLayerMap["PixeloLdkoiio(Silicon)_1"] = fLastLayerId            + 8;       //naming after MVD2.2
        fLayerMap["PixeloLdkoco(Silicon)_2"] = fLastLayerId             + 8;
        fLayerMap["PixeloLdkoiiio(Silicon)_1"] = fLastLayerId           + 9;       //naming after MVD2.2
        fLayerMap["PixeloLdkoco(Silicon)_3"] = fLastLayerId             + 9;
        fLayerMap["PixeloLdkoiiio(Silicon)_2"] = fLastLayerId           + 10;      //naming after MVD2.2
        fLayerMap["PixeloLdkoco(Silicon)_4"] = fLastLayerId             + 10;
        fLayerMap["PixeloLdkoiio(Silicon)_2"] = fLastLayerId            + 11;      //naming after MVD2.2
        fLayerMap["PixeloLdkoco(Silicon)_5"] = fLastLayerId             + 11;
        fLayerMap["PixeloLdkoio(Silicon)_2"] = fLastLayerId             + 12;      //naming after MVD2.2
        fLayerMap["PixeloLdkoco(Silicon)_6"] = fLastLayerId             + 12;
        fLayerMap["PixeloLdkoiiio(Silicon)_3"] = fLastLayerId           + 13;      //naming after MVD2.2
        fLayerMap["PixeloLdkoco(Silicon)_7"] = fLastLayerId             + 13;
        fLayerMap["PixeloLdkoiiio(Silicon)_4"] = fLastLayerId           + 14;      //naming after MVD2.2
        fLayerMap["PixeloLdkoco(Silicon)_8"] = fLastLayerId             + 14;

        fLayerMap["StripoBl3o(Silicon)"] = fLastLayerId                         + 15;
        fLayerMap["Fwdo(Silicon)_1"] = fLastLayerId                             + 16;
        fLayerMap["StripoBl4o(Silicon)"] = fLastLayerId                         + 17;
        //fLayerMap["Fwdo(Silicon)_2")){Layer=10;flag=false;}

        fLayerMap["StripoLdkoTrapSoRingAoSilicon_1"] = fLastLayerId + 18;
        fLayerMap["StripoLdkoTrapSoRingAoSilicon_2"] = fLastLayerId + 19;
        fLayerMap["StripoLdkoTrapSoRingBoSilicon_1"] = fLastLayerId + 18;
        fLayerMap["StripoLdkoTrapSoRingBoSilicon_2"] = fLastLayerId + 19;
        fLayerMap["StripoLdko5-6oTrapSo(Silicon)_1"] = fLastLayerId + 20;

        fLayerMap["LambdaDisk_1"] = fLastLayerId                                        + 21;
        fLayerMap["LambdaDisk_2"] = fLastLayerId                                        + 22;
        fLastLayerId += 22;
}

void PndRiemannTrackFinder::MergeTracks ( )

inherited

Definition at line 354 of file PndRiemannTrackFinder.cxx.

References counter, PndRiemannTrackFinder::CreateOneTrackCand(), PndRiemannTrackFinder::fCurvDiff, PndRiemannTrackFinder::fDipDiff, PndRiemannTrackFinder::FindTracksWithSimilarHits(), PndRiemannTrackFinder::FindTracksWithSimilarParameters(), PndRiemannTrackFinder::fMergedTrackCand, PndRiemannTrackFinder::fTrackCand, PndRiemannTrackFinder::fVerbose, i, and PndRiemannTrackFinder::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 ( )

inlineinherited

Definition at line 28 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fTrackCand.

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

{return fTrackCand.size();};                                                            

PndMvdSttGemRiemannTrackFinder& PndMvdSttGemRiemannTrackFinder::operator= ( const PndMvdSttGemRiemannTrackFinder &  )

delete

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

protectedinherited

Definition at line 495 of file PndRiemannTrackFinder.cxx.

References i.

Referenced by PndRiemannTrackFinder::FindTracksWithSimilarHits(), PndRiemannTrackFinder::FindTracksWithSimilarParameters(), and PndRiemannTrackFinder::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 )

inlineinherited

Definition at line 44 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fCurvDiff, and val.

{fCurvDiff = val;}

void PndMvdSttGemRiemannTrackFinder::SetCutChi2H ( TH2F *  hist )

inline

Definition at line 27 of file PndMvdSttGemRiemannTrackFinder.h.

References fCutChi2H, and hist.

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

{fCutChi2H=hist;}

void PndMvdSttGemRiemannTrackFinder::SetCutDistH ( TH2F *  hist )

inline

Definition at line 26 of file PndMvdSttGemRiemannTrackFinder.h.

References fCutDistH, and hist.

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

{fCutDistH=hist;}

void PndRiemannTrackFinder::SetDipDiff ( double  val )

inlineinherited

Definition at line 45 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fDipDiff, and val.

{fDipDiff = val;}

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

inlineinherited

Definition at line 23 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fHits, and hits.

{fHits = hits;};                                

void PndRiemannTrackFinder::SetMaxPlaneDistance ( double  val )

inlineinherited

Definition at line 38 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fMaxPlaneDist, and val.

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

{fMaxPlaneDist = val;}

void PndRiemannTrackFinder::SetMaxSZChi2 ( double  val )

inlineinherited

Definition at line 40 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fMaxSZChi2, and val.

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

{fMaxSZChi2 = val;}

void PndRiemannTrackFinder::SetMaxSZDist ( double  val )

inlineinherited

Definition at line 39 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fMaxSZDist, and val.

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

{fMaxSZDist = val;}

void PndRiemannTrackFinder::SetMinNumberOfHits ( int  val )

inlineinherited

Definition at line 43 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fMinNumberOfHits, and val.

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

{fMinNumberOfHits = val;}

void PndRiemannTrackFinder::SetMinPointDist ( double  val )

inlineinherited

Definition at line 41 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fMinPointDist, and val.

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

{fMinPointDist = val;}

void PndMvdSttGemRiemannTrackFinder::SetSttTubeArray ( TClonesArray *  SttTubeArray )

inline

Definition at line 29 of file PndMvdSttGemRiemannTrackFinder.h.

References fStrawMap, and PndSttStrawMap::GenerateStrawMap().

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

{fStrawMap.GenerateStrawMap(SttTubeArray);}

void PndRiemannTrackFinder::SetUseZeroPos ( bool  val )

inlineinherited

Definition at line 42 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fUseZeroPos, and val.

{fUseZeroPos = val;}

void PndRiemannTrackFinder::SetVerbose ( int  val )

inlineinherited

Adds one new hit to the array of hits.

Definition at line 27 of file PndRiemannTrackFinder.h.

References PndRiemannTrackFinder::fVerbose, and val.

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

{fVerbose = val;}

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

protectedinherited

Definition at line 506 of file PndRiemannTrackFinder.cxx.

References PndRiemannTrackFinder::fHitsInTracks, PndRiemannTrackFinder::fVerbose, and i.

Referenced by PndRiemannTrackFinder::FindTracks(), FindTracks(), and PndRiemannTrackFinder::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

protectedinherited

Curvature and dip of fPndTrackCand.

Definition at line 52 of file PndRiemannTrackFinder.h.

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

double PndRiemannTrackFinder::fCurvDiff

protectedinherited

TrackMerger parameter.

Definition at line 62 of file PndRiemannTrackFinder.h.

Referenced by PndRiemannTrackFinder::MergeTracks(), and PndRiemannTrackFinder::SetCurvDiff().

TH2F* PndMvdSttGemRiemannTrackFinder::fCutChi2H

private

Definition at line 59 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by GetMaxSZChi2(), and SetCutChi2H().

TH2F* PndMvdSttGemRiemannTrackFinder::fCutDistH

private

cutting histograms

Definition at line 58 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by GetMaxPlaneDist(), and SetCutDistH().

double PndRiemannTrackFinder::fDipDiff

protectedinherited

TrackMerger parameter.

Definition at line 63 of file PndRiemannTrackFinder.h.

Referenced by PndRiemannTrackFinder::MergeTracks(), and PndRiemannTrackFinder::SetDipDiff().

TClonesArray* PndMvdSttGemRiemannTrackFinder::fGemHits

private

Definition at line 63 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by AddHits(), AssignGemHits(), and FindTracks().

PndGeoHandling* PndMvdSttGemRiemannTrackFinder::fGeoH

private

Definition at line 32 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by GetLayerMvd(), and PndMvdSttGemRiemannTrackFinder().

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

protectedinherited

Vector of all FairHits used for track finding (fitting)

Definition at line 48 of file PndRiemannTrackFinder.h.

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

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

protectedinherited

Vector of indizes which hits where used in which track.

Definition at line 50 of file PndRiemannTrackFinder.h.

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

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

protectedinherited

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 PndRiemannTrackFinder::FindTracks(), FindTracks(), GetStartTracks(), and PndRiemannTrackFinder::GetStartTracks().

int PndMvdSttGemRiemannTrackFinder::fLastLayerId

private

last layer Id assigned

Definition at line 72 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by InitLayerMapGem(), and InitLayerMapMvd().

std::map<TString, int> PndMvdSttGemRiemannTrackFinder::fLayerMap

private

identifier string, assigned layer id

Definition at line 71 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by GetLayer(), InitLayerMapGem(), and InitLayerMapMvd().

std::vector< std::vector<int> > PndMvdSttGemRiemannTrackFinder::fLayers

private

contains layer information of hits

Definition at line 70 of file PndMvdSttGemRiemannTrackFinder.h.

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

double PndRiemannTrackFinder::fMagField

protectedinherited

size of the magnetic field in Tesla

Definition at line 64 of file PndRiemannTrackFinder.h.

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

protectedinherited

map to convert the list of hits back into a FairLink

Definition at line 55 of file PndRiemannTrackFinder.h.

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

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

protectedinherited

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 AddHits(), PndRiemannTrackFinder::AddHits(), AssignGemHits(), AssignSkewedSttHits(), AssignSttHits(), CheckBoarderHitsStt(), GetStrawSector(), and PndRiemannTrackFinder::PndRiemannTrackFinder().

double PndRiemannTrackFinder::fMaxPlaneDist

protectedinherited

Distance cut between new point and riemann plane.

Definition at line 57 of file PndRiemannTrackFinder.h.

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

double PndRiemannTrackFinder::fMaxSZChi2

protectedinherited

Maximum allowed Chi2 in an sz fit.

Definition at line 60 of file PndRiemannTrackFinder.h.

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

double PndRiemannTrackFinder::fMaxSZDist

protectedinherited

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 PndRiemannTrackFinder::CheckRiemannHit(), CheckRiemannHitMvd(), and PndRiemannTrackFinder::SetMaxSZDist().

std::vector<PndTrackCand> PndRiemannTrackFinder::fMergedTrackCand

protectedinherited

Definition at line 53 of file PndRiemannTrackFinder.h.

Referenced by PndRiemannTrackFinder::GetMergedTrackCands(), and PndRiemannTrackFinder::MergeTracks().

int PndRiemannTrackFinder::fMinNumberOfHits

protectedinherited

Minimum number of hits in track necessary for a match.

Definition at line 61 of file PndRiemannTrackFinder.h.

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

double PndRiemannTrackFinder::fMinPointDist

protectedinherited

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

Definition at line 59 of file PndRiemannTrackFinder.h.

Referenced by PndRiemannTrackFinder::CheckHitDistance(), and PndRiemannTrackFinder::SetMinPointDist().

int PndMvdSttGemRiemannTrackFinder::fNLayers

private

number of Layers

Definition at line 86 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by AddHits(), FindTracks(), and GetStartTracks().

TClonesArray* PndMvdSttGemRiemannTrackFinder::fSkewedSttHits

private

Definition at line 62 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by AddHits(), and FindTracks().

PndSttStrawMap PndMvdSttGemRiemannTrackFinder::fStrawMap

private

Definition at line 64 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by AddHits(), AssignSkewedSttHits(), AssignSttHits(), CheckBoarderHitsStt(), GetStrawSector(), and SetSttTubeArray().

TClonesArray* PndMvdSttGemRiemannTrackFinder::fSttHits

private

Definition at line 61 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by AddHits(), and FindTracks().

std::vector<std::vector<PndSttHit*> > PndMvdSttGemRiemannTrackFinder::fSttHitsInSectors

private

Definition at line 65 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by AddHits(), AssignSttHits(), and PndMvdSttGemRiemannTrackFinder().

std::vector<std::vector<FairHit*> > PndMvdSttGemRiemannTrackFinder::fSttSkewedHitsInSectors

private

Definition at line 66 of file PndMvdSttGemRiemannTrackFinder.h.

Referenced by AddHits(), AssignSkewedSttHits(), and PndMvdSttGemRiemannTrackFinder().

std::vector<PndTrackCand> PndRiemannTrackFinder::fTrackCand

protectedinherited

List of track candidates.

Definition at line 51 of file PndRiemannTrackFinder.h.

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

std::vector<PndRiemannTrack> PndRiemannTrackFinder::fTracks

protectedinherited

Resulting Riemann Tracks.

Definition at line 49 of file PndRiemannTrackFinder.h.

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

bool PndRiemannTrackFinder::fUseZeroPos

protectedinherited

Definition at line 67 of file PndRiemannTrackFinder.h.

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

int PndRiemannTrackFinder::fVerbose

protectedinherited

Definition at line 66 of file PndRiemannTrackFinder.h.

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

double PndMvdSttGemRiemannTrackFinder::fZClosePar

private

parameter to separate forward and backward tracks

Definition at line 68 of file PndMvdSttGemRiemannTrackFinder.h.

---

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

• PndMvdSttGemRiemannTrackFinder.h
• PndMvdSttGemRiemannTrackFinder.cxx