Implementation of the Hough transform based FTS PR. Creates Hough spaces, finds peaks (=tracklets) and combines them to track candidates. More...

#include <PndFtsHoughTrackFinder.h>

Inheritance diagram for PndFtsHoughTrackFinder:

Public Member Functions
	PndFtsHoughTrackFinder (PndFtsHoughTrackerTask *trackerTask)
	Set pointer to tracker task (super important as it provides an I/O interface to PandaRoot) More...

virtual	~PndFtsHoughTrackFinder ()
	Destructor. More...

void	OverwriteTrackFinderParams (PndFtsHoughTrackFinderParams newParams)

virtual void	FindTracks ()
	Performs the track finding. More...

Int_t	NTracks () const

PndTrack	GetPndTrack (int i)
	Returns the number of found tracks. More...

PndTrackCand	GetPndTrackCand (int i)
	Returns the track cand. with index i. More...

PndFtsHoughTrackCand	GetHoughTrack (int i) const
	Returns the track cand. with index i. More...

Int_t	getNLinesBeforeDipoleFound () const

Int_t	getNLinesBehindDipoleFound () const

Int_t	getNParabolasFound () const

Int_t	getNTracksFound () const

Protected Member Functions
void	throwError (const TString s) const
	For error reporting. More...

Bool_t	FilterTrackletsBasedOnSharedHits (UInt_t maxAcceptableSharedHits, std::vector< PndFtsHoughTracklet > &tracklets)
	Filters a vector of tracklets based on the number of shared hits. More...

std::vector< PndFtsHoughTracklet >	FindLinesBehindDipoleZx ()

std::vector< PndFtsHoughTracklet >	FindLinesBeforeDipoleZx ()

void	FindMatchingParabolaToLineBeforeDipoleZxAndAddLineBehindDipole (const std::vector< PndFtsHoughTracklet > &trackletsLineBeforeDipole, const std::vector< PndFtsHoughTracklet > &trackletsLineBehindDipole)

Bool_t	LineBehindDipoleMatchesToLinePlusParabola (const PndFtsHoughTrackCand &lineParabola, const PndFtsHoughTracklet &lineBehindDipole) const

void	FindZyLineMatchingToLineParabolaLineInZx ()

Protected Attributes
PndFtsHoughTrackerTask *	fTrackerTask
	Task which handles PandaRoot input/output and provides settings for FTS PR. Has to be set using the constructor. More...

PndFtsHoughTrackFinderParams	fParams

std::vector< PndFtsHoughTrackCand >	fHoughTrackCandsComplete
	For internal storing of complete track cands. More...

std::vector< PndFtsHoughTrackCand >	fHoughTrackCandsZxPlaneOnly
	For internal storing of track cands. (zx plane track model only) More...

const UInt_t	fMinPeakHeightZxLineBeforeDipole
	Minimum required height for peaks in Hough spaces. More...

const UInt_t	fMinPeakHeightZxParabola
	Minimum required height for peaks in Hough spaces. More...

const UInt_t	fMinPeakHeightZxLineBehindDipole
	Minimum required height for peaks in Hough spaces. More...

const UInt_t	fMinPeakHeightZyLine
	zy line More...

Int_t	fNLinesBeforeDipoleFound

Int_t	fNLinesBehindDipoleFound

Int_t	fNParabolasFound

Int_t	fNTracksFound

Static Protected Attributes
static const Double_t	fThetaRadLineBehindDipoleMatchesToParabolaIfBelow = 5*TMath::DegToRad()
	Minimum required height for peaks in Hough spaces. More...

Private Member Functions
	ClassDef (PndFtsHoughTrackFinder, 1)

Detailed Description

Implementation of the Hough transform based FTS PR. Creates Hough spaces, finds peaks (=tracklets) and combines them to track candidates.

Author: Martin J. Galuska <martin [dot] j [dot] galuska (at) physik [dot] uni (minus) giessen [dot] de>

This is a class version of the HoughTest.C macro PR test implementation minus all the plotting stuff. Take a look at the notes of the macro version for further details.

Recent Changes Major code cleanup and deletion of test code / unneeded code use PndFtsHoughTrackCand to store information about track candidates and Hough transforms Find all peaks with a minimum height, analysing peak shapes. Moved all Hough space related code to PndFtsHoughSpace -> Major code simplification, better maintainability Fill PndTrackCands and PndTrack for output

This class is loosely modeled after the mvd/MvdTracking/PndRiemannTrackFinder sttmvdtracking/PndMvdSttGemRiemannTrackFinder classes

TODO Match straight line for stations 5+6 to parabola Add skewed hits Add drift circles Adaptive Hough

Created: 18.06.2013

Definition at line 69 of file PndFtsHoughTrackFinder.h.

Constructor & Destructor Documentation

PndFtsHoughTrackFinder::PndFtsHoughTrackFinder ( PndFtsHoughTrackerTask * trackerTask )

Set pointer to tracker task (super important as it provides an I/O interface to PandaRoot)

Definition at line 10 of file PndFtsHoughTrackFinder.cxx.

References fTrackerTask, and PndFtsHoughTrackerTask::GetVerbose().

 : fTrackerTask(trackerTask),
   fParams(),
 
   // min peak heights
   fMinPeakHeightZxLineBeforeDipole(6),
   fMinPeakHeightZxParabola(8),
   fMinPeakHeightZxLineBehindDipole(6),
   fMinPeakHeightZyLine(8),
 
   // event statistics
   fNLinesBeforeDipoleFound(0),
   fNLinesBehindDipoleFound(0),
   fNParabolasFound(0),
   fNTracksFound(0)
 {
         if (0==fTrackerTask){
                 std::cout << "PndFtsHoughTrackFinder FATAL ERROR Tracker task not set.\n";
         } else {
                 if(3<fTrackerTask->GetVerbose()) std::cout << "PndFtsHoughTrackFinder called with tracker ptr " << fTrackerTask << '\n';
         }
 }

PndFtsHoughTrackFinder::~PndFtsHoughTrackFinder ( )

virtual

Destructor.

Definition at line 34 of file PndFtsHoughTrackFinder.cxx.

References PndFtsHoughTrackerTask::fLogger, fTrackerTask, and PndFtsHoughTrackerTask::GetVerbose().

 {
         if(3<fTrackerTask->GetVerbose()) fTrackerTask->fLogger->Info(MESSAGE_ORIGIN,"Destructor of PndFtsHoughTrackFinder");
 }

Member Function Documentation

PndFtsHoughTrackFinder::ClassDef	(	PndFtsHoughTrackFinder	,
		1
	)

private

Bool_t PndFtsHoughTrackFinder::FilterTrackletsBasedOnSharedHits	(	UInt_t	maxAcceptableSharedHits,
		std::vector< PndFtsHoughTracklet > &	tracklets
	)

protected

Filters a vector of tracklets based on the number of shared hits.

It will only keep the heighest peaks if 2 or more peaks share more than maxAcceptableSharedHits hits. If two peaks have the same height, both are kept.

Parameters

	maxAcceptableSharedHits	Defines how many hits two tracklets / peaks are allowed to share.
[in,out]	tracklets	Vector containing tracklets which are supposed to be filtered. The vector will be modified.

Returns

Definition at line 372 of file PndFtsHoughTrackFinder.cxx.

References Double_t, fTrackerTask, PndFtsHoughTracklet::getNSharedHits(), PndFtsHoughTracklet::getPeakHeightFromPeakFinder(), and PndFtsHoughTrackerTask::GetVerbose().

 {
         // to store indices that I want to "delete"
         std::set<UInt_t> indicesToDelete;
         std::set<UInt_t>::iterator findIndex;
 
         // for all tracklets that share more than maxAcceptableSharedHits hits keep only the heighest peak
         // compare all tracklets with each other, keep track of which tracklets should be "deleted"
         for (UInt_t iTrackletLeft = 0; iTrackletLeft < tracklets.size(); ++iTrackletLeft)
         {
                 for (UInt_t iTrackletRight = iTrackletLeft+1; iTrackletRight < tracklets.size(); ++iTrackletRight)
                 {
                         // check if two tracks share more than maxAcceptableSharedHits hits
                         PndFtsHoughTracklet trackletLeft = tracklets[iTrackletLeft];
                         PndFtsHoughTracklet trackletRight = tracklets[iTrackletRight];
                         const UInt_t nSharedHits = trackletLeft.getNSharedHits(trackletRight);
                         if (nSharedHits>maxAcceptableSharedHits){
                                 // mark the peak with the lower "height" for deletion
                                 const Double_t heightLeft = trackletLeft.getPeakHeightFromPeakFinder();
                                 const Double_t heightRight = trackletRight.getPeakHeightFromPeakFinder();
                                 if (heightLeft>heightRight){
                                         indicesToDelete.insert(iTrackletRight);
                                 } else if (heightLeft<heightRight){
                                         indicesToDelete.insert(iTrackletLeft);
                                 } else if (heightLeft==heightRight){
                                         std::cout << "WARNING: Found two peaks of the same height that share " <<  nSharedHits << " hits.\n";
                                         std::cout << "The max. number of shared hits was set to " <<  maxAcceptableSharedHits << " hits.\n";
                                         std::cout << "Both peaks / tracklets will be kept. \n";
                                 }
                         }
 
                 }
         } // end for loop: compare all tracklets with each other
 
         // if we have no tracklets to "delete", we don't need to do anything
         if (0==indicesToDelete.size()){
                 if (1<fTrackerTask->GetVerbose()) {  std::cout << "FilterTrackletsBasedOnSharedHits: No tracklets are marked for deletion.\n"; }
                 return kTRUE;
         }
 
         // create new tracklets vector and copy all entries from input vector to it which are not marked for deletion
         std::vector<PndFtsHoughTracklet> filteredTracklets;
         for (UInt_t iTracklet = 0; iTracklet < tracklets.size(); ++iTracklet)
         {
                 // check if the index is marked for "deletion"
                 findIndex = indicesToDelete.find(iTracklet);
                 if (findIndex == indicesToDelete.end()){
                         // index was not found -> entry is not marked for deletion -> I should copy it
                         filteredTracklets.push_back(tracklets[iTracklet]);
                 }
         }
         // replace input tracklets with filtered ones
         tracklets = filteredTracklets;
         return kTRUE;
 }

std::vector< PndFtsHoughTracklet > PndFtsHoughTrackFinder::FindLinesBeforeDipoleZx ( )

protected

Definition at line 82 of file PndFtsHoughTrackFinder.cxx.

References Double_t, PndFtsHoughSpace::FillHoughSpace(), fMinPeakHeightZxLineBeforeDipole, fParams, fTrackerTask, and PndFtsHoughTrackFinderParams::getZLineParabola().

Referenced by FindTracks().

                                                                                {
         //----------------------------------
         // zx plane: Straight line Hough transform before dipole
 
         // parameters: for hits with MC truth coordinates with 6 min peak height
         // stepsPerThetaDeg = 16
         // binsInSecVal = 1000;
 
 
         // parameters: for hits with center of straws coordinates with 6 min peak height
         // stepsPerThetaDeg = 16
         // binsInSecVal = 1000;
 
 
         // the following parameters are valid at z position fZLineParabola
 
         // min. and max. theta angles (in zx plane) for lines
         static const Int_t thetaDegLowHigh = 25; // - for low, + for high (in degree)
 
         // min. and max. distance from z axis in x direction
         static const Double_t xLowHigh = 80; // - for low, + for high (in cm)
 
         static const Int_t stepsPerThetaDeg = 8; // greater number means finer scanning in theta
         static const Int_t nBinsInSecVal = 160; // greater number means more bins for second value of Hough space
 
 
         PndFtsHoughSpaceBinning binningZxLineBeforeDipole(
                         stepsPerThetaDeg,
                         thetaDegLowHigh,
                         nBinsInSecVal,
                         xLowHigh
         );
         PndFtsHoughSpace houghSpaceZxLineBeforeDipole("lineBeforeDipole", -1,
                         binningZxLineBeforeDipole,
                         fParams.getZLineParabola(), 0., 0, fTrackerTask);
 
         // Do straight line Hough transform on non-skewed hits from stations 1+2
         try { houghSpaceZxLineBeforeDipole.FillHoughSpace(); }
         catch (std::runtime_error& e) {
                 std::cerr
                 << "Hough Space could not be created! \n";
                 std::cerr << "runtime_error: " << e.what() << '\n';
         }
         // find peaks for line Hough space and store in vector
         //      std::vector<PndFtsHoughTracklet> trackletsLineBeforeDipole = houghSpaceZxLineBeforeDipole.FindAllPeaksBinsWoMergingWithSearchWindow(fMinPeakHeightZxLineBeforeDipole);
         std::vector<PndFtsHoughTracklet> trackletsLineBeforeDipole = houghSpaceZxLineBeforeDipole.FindAllPeaksScanPathsMergeBins(fMinPeakHeightZxLineBeforeDipole);
         return trackletsLineBeforeDipole;
 }

std::vector< PndFtsHoughTracklet > PndFtsHoughTrackFinder::FindLinesBehindDipoleZx ( )

protected

Definition at line 40 of file PndFtsHoughTrackFinder.cxx.

References Double_t, PndFtsHoughSpace::FillHoughSpace(), fMinPeakHeightZxLineBehindDipole, fParams, fTrackerTask, and PndFtsHoughTrackFinderParams::getZParabolaLine().

Referenced by FindTracks().

                                                                                {
         // zx plane: Straight line Hough transform behind dipole
 
 
 
 
 
         // the following parameters are valid at z position fZParabolaLine
 
         // min. and max. theta angles (in zx plane) for lines
         static const Int_t thetaDegLowHigh = 80; //  - for low, + for high (in degree)
 
         // min. and max. distance from z axis in x direction
         static const Double_t xLowHigh = 200; //  - for low, + for high (in cm)
 
         static const Int_t stepsPerThetaDeg = 8; // greater number means finer scanning in theta
         static const Int_t nBinsInSecVal = 400; // greater number means more bins for second value of Hough space
 
 
         PndFtsHoughSpaceBinning binningZxLineBehindDipole(
                         stepsPerThetaDeg,
                         thetaDegLowHigh,
                         nBinsInSecVal,
                         xLowHigh
         );
         PndFtsHoughSpace houghSpaceZxLineBehindDipole("lineBehindDipole", -1,
                         binningZxLineBehindDipole,
                         fParams.getZParabolaLine(), 0., 0, fTrackerTask);
 
         // Do straight line Hough transform on non-skewed hits from stations 1+2
         try { houghSpaceZxLineBehindDipole.FillHoughSpace(); }
         catch (std::runtime_error& e) {
                 std::cerr
                 << "Hough Space for zx line behind dipole could not be created! \n";
                 std::cerr << "runtime_error: " << e.what() << '\n';
         }
         // find peaks for line hough space and store in vector
         std::vector<PndFtsHoughTracklet> trackletsLineBehindDipole = houghSpaceZxLineBehindDipole.FindAllPeaksScanPathsMergeBins(
                         fMinPeakHeightZxLineBehindDipole);
         return trackletsLineBehindDipole;
 }

void PndFtsHoughTrackFinder::FindMatchingParabolaToLineBeforeDipoleZxAndAddLineBehindDipole	(	const std::vector< PndFtsHoughTracklet > &	trackletsLineBeforeDipole,
		const std::vector< PndFtsHoughTracklet > &	trackletsLineBehindDipole
	)

protected

Definition at line 131 of file PndFtsHoughTrackFinder.cxx.

References Bool_t, Double_t, fHoughTrackCandsZxPlaneOnly, PndFtsHoughSpace::FillHoughSpace(), fMinPeakHeightZxParabola, fParams, fTrackerTask, PndFtsHoughTrackerTask::GetEventNr(), PndFtsHoughTrackFinderParams::getParabolaHwScan(), PndFtsHoughTrackFinderParams::getParabolaNBinsPzxInv(), PndFtsHoughTrackFinderParams::getParabolaQDivPzxArgMax(), PndFtsHoughTrackFinderParams::getParabolaStepsPerThetaDeg(), PndFtsHoughTrackerTask::GetVerbose(), PndFtsHoughTrackFinderParams::getZLineParabola(), LineBehindDipoleMatchesToLinePlusParabola(), PndFtsHoughTrackCand::SetZxLineBeforeDipole(), PndFtsHoughTrackCand::SetZxLineBehindDipole(), and PndFtsHoughTrackCand::SetZxParabola().

Referenced by FindTracks().

   {
         // loop over all line tracklets which were found by line HT before dipole field and find a matching parabola
         // After that try to match a line after dipole to that track candidate.
         // If that is not possible, accept short track candidate if particle is likely to have left detector acceptance, otherwise discard.
         // LB4D = line before dipole
 
         // loop over lines before dipole
         for (UInt_t iLB4D = 0; iLB4D < linesBeforeDipole.size(); ++iLB4D) {
                 const Double_t peakThetaRadLB4D = linesBeforeDipole[iLB4D].getThetaRadVal();
                 const Double_t peakInterceptLB4D = linesBeforeDipole[iLB4D].getSecondVal();
                 const Double_t peakThetaRadHwLB4D = linesBeforeDipole[iLB4D].getThetaRadHw();
 
                 // determine where to look for parabola
                 const Double_t parabolaStepsPerThetaDeg = fParams.getParabolaStepsPerThetaDeg();
                 const Double_t parabolaHwScan = fParams.getParabolaHwScan();
 
                 const Double_t parabolaThetaRadLow = peakThetaRadLB4D
                                 - parabolaHwScan*peakThetaRadHwLB4D; // in rad
                 const Double_t parabolaThetaRadHigh = peakThetaRadLB4D
                                 + parabolaHwScan*peakThetaRadHwLB4D; // in rad
                 if (parabolaThetaRadHigh == parabolaThetaRadLow) std::cout << "ERROR: low and high are the same for parabola!\n";
                 const Double_t parabolaThetaDegLow = parabolaThetaRadLow*TMath::RadToDeg(); // in deg
                 const Double_t parabolaThetaDegHigh = parabolaThetaRadHigh*TMath::RadToDeg(); // in deg
 
                 UInt_t thetaBins = ceil(parabolaStepsPerThetaDeg * (parabolaThetaDegHigh - parabolaThetaDegLow));
 
                 if (1<fTrackerTask->GetVerbose()) std::cout << "event: " << fTrackerTask->GetEventNr()
                                                           << " Line " << iLB4D
                                                           << "\n thetaRadLowParabola=" << parabolaThetaRadLow
                                                           << " thetaRadHighParabola=" << parabolaThetaRadHigh
                                                           << " thetaBins=" << thetaBins
                                                           << "  peakThetaRadLB4D="
                                                           << peakThetaRadLB4D
                                                           << " peakThetaRadHwLB4D="
                                                           << peakThetaRadHwLB4D
                                                           << " peakInterceptLB4D=" << peakInterceptLB4D
                                                           << " peakThetaRadHwLB4D=" << peakThetaRadHwLB4D
                                                           << '\n';
 
                 const Int_t parabolaNBinsPzxInv = fParams.getParabolaNBinsPzxInv();
                 const Double_t parabolaQDivPzxArgMax = fParams.getParabolaQDivPzxArgMax();
 
 
                 PndFtsHoughSpaceBinning binningZxParabola(
                                 thetaBins,
                                 parabolaThetaRadLow,
                                 parabolaThetaRadHigh,
                                 parabolaNBinsPzxInv,
                                 -1*parabolaQDivPzxArgMax,
                                 parabolaQDivPzxArgMax
                 );
                 PndFtsHoughSpace houghspaceZxParabola("parabola", iLB4D,
                                 binningZxParabola,
                                 fParams.getZLineParabola(), peakInterceptLB4D, 0, fTrackerTask);
 
                 // Do parabola Hough transform for current line before dipole (shifts FTS hits by hitshiftinx) for non-skewed hits in stations 3+4+5
                 try { houghspaceZxParabola.FillHoughSpace(); }
                 catch (std::runtime_error& e) {
                         std::cerr << "Hough Space for zx parabola could not be created! \n";
                         std::cerr << "runtime_error: " << e.what() << '\n';
                 }
 
                 // find peaks for zx parabola Hough space (for current line before dipole)
                 //              std::vector<PndFtsHoughTracklet> zxParabolaTracklets = houghspaceZxParabola.FindAllPeaksScanPathsMergeBins(fMinPeakHeightZxParabola);
                 std::vector<PndFtsHoughTracklet> zxParabolaTracklets = houghspaceZxParabola.FindAllPeaksBinsWoMergingWithSearchWindow(fMinPeakHeightZxParabola);
 
 
 
 
                 // construct newHoughTrackCand from line+parabola+line (in zx)
                 if (1 < fTrackerTask->GetVerbose()) {
                         std::cout
                         << "Create track candidates from line in zx before dipole "
                         << iLB4D << " and all parabolas within dipole.\n"
                         << "And all lines behind dipole which match line+parabola (if exist)\n";
                 }
                 // loop over all parabolas which were found for one line before the dipole
                 for (UInt_t iParabola = 0; iParabola < zxParabolaTracklets.size(); ++iParabola) {
                         // Try to find a matching line behind the dipole
 
                         PndFtsHoughTrackCand lineParabola(fTrackerTask);
                         lineParabola.SetZxLineBeforeDipole(linesBeforeDipole[iLB4D]);
                         lineParabola.SetZxParabola(zxParabolaTracklets[iParabola]);
 
                         // loop over all lines behind dipole
                         // add track cands for each matching line behind dipole (LBhD)
                         Bool_t foundLineBehindDipole = kFALSE;
                         for (UInt_t iLBhD = 0; iLBhD < linesBehindDipole.size(); ++iLBhD) {
                                 if (kTRUE == LineBehindDipoleMatchesToLinePlusParabola( lineParabola,  linesBehindDipole[iLBhD]) ){
                                         PndFtsHoughTrackCand lineParabolaLine(lineParabola); // make a copy
                                         lineParabolaLine.SetZxLineBehindDipole(linesBehindDipole[iLBhD]); // add line behind dipole
                                         fHoughTrackCandsZxPlaneOnly.push_back(lineParabolaLine); // add as track candidate
                                         foundLineBehindDipole = kTRUE;
                                 }
                         }
 
                         // iif no lines behind dipole matched, add track cand without any line behind dipole
                         if (kFALSE == foundLineBehindDipole) fHoughTrackCandsZxPlaneOnly.push_back(lineParabola);
                 }
         } // loop over all line tracklets which were found by line HT before dipole field
 }

void PndFtsHoughTrackFinder::FindTracks ( )

virtual

Performs the track finding.

Reimplemented in PndFtsHoughTrackFinderQA.

Definition at line 295 of file PndFtsHoughTrackFinder.cxx.

References fHoughTrackCandsComplete, fHoughTrackCandsZxPlaneOnly, FindLinesBeforeDipoleZx(), FindLinesBehindDipoleZx(), FindMatchingParabolaToLineBeforeDipoleZxAndAddLineBehindDipole(), FindZyLineMatchingToLineParabolaLineInZx(), fMinPeakHeightZxLineBeforeDipole, fMinPeakHeightZxParabola, fNLinesBeforeDipoleFound, fNLinesBehindDipoleFound, fNParabolasFound, fNTracksFound, fTrackerTask, PndFtsHoughTrackerTask::GetEventNr(), PndFtsHoughTrackerTask::GetNFtsHits(), and PndFtsHoughTrackerTask::GetVerbose().

Referenced by PndFtsHoughTrackerTaskQA::Exec(), and PndFtsHoughTrackFinderQA::FindTracks().

                                         {
 
         if (1<fTrackerTask->GetVerbose()) std::cout << "PndFtsHoughTrackFinder::FindTracks()\n";
 
         // reset
         fHoughTrackCandsZxPlaneOnly.clear();
         fHoughTrackCandsComplete.clear();
 
 
         //--------------------------
         // Do we have enough hits in the FTS?
         Int_t minFtsHits = fMinPeakHeightZxParabola + fMinPeakHeightZxLineBeforeDipole;
         if( minFtsHits > fTrackerTask->GetNFtsHits() ) {
                 if(0<fTrackerTask->GetVerbose()) std::cout << "Skip event " << fTrackerTask->GetEventNr() << " since we have too few hits in FTS. (" << fTrackerTask->GetNFtsHits() << " present, " << minFtsHits << " required)\n";
                 return;
         }
 
 
 
 
         // zx plane: Straight line Hough transform behind dipole
         if(1<fTrackerTask->GetVerbose()) std::cout << "Lines behind dipole:\n";
         std::vector<PndFtsHoughTracklet> linesBehindDipole = FindLinesBehindDipoleZx();
         fNLinesBehindDipoleFound = linesBehindDipole.size();
         if(1<fTrackerTask->GetVerbose()) std::cout << "event " << fTrackerTask->GetEventNr() << ": " << fNLinesBehindDipoleFound << " lines behind dipole found.\n";
 
         // zx plane: Straight line Hough transform before dipole
         if(1<fTrackerTask->GetVerbose()) std::cout << "Lines before dipole:\n";
         std::vector<PndFtsHoughTracklet> linesBeforeDipole = FindLinesBeforeDipoleZx();
         fNLinesBeforeDipoleFound = linesBeforeDipole.size();
         if(1<fTrackerTask->GetVerbose()) std::cout << "event " << fTrackerTask->GetEventNr() << ": " << fNLinesBeforeDipoleFound << " lines before dipole found.\n";
 
         // loop over all line tracklets which were found by line HT before dipole field and find a matching parabola
         if(1<fTrackerTask->GetVerbose()) std::cout << "Matching parabolas to lines before dipole:\n";
         FindMatchingParabolaToLineBeforeDipoleZxAndAddLineBehindDipole(linesBeforeDipole, linesBehindDipole);
         fNParabolasFound = fHoughTrackCandsZxPlaneOnly.size();
         if(0<fTrackerTask->GetVerbose()) std::cout << "event " << fTrackerTask->GetEventNr() << ": " << fNParabolasFound << " parabolas matched!\n";
 
         // loop over line+parabola+line (LPL) from zx plane and do straight line Hough transform in zy plane
         if (1<fTrackerTask->GetVerbose()) std::cout << "Lines in zy plane:\n";
         FindZyLineMatchingToLineParabolaLineInZx();
         fNTracksFound = fHoughTrackCandsComplete.size();
         if(1<fTrackerTask->GetVerbose()) std::cout << "event " << fTrackerTask->GetEventNr() << ": " << fNTracksFound << " tracks found.\n";
 
 
 
         // HIER GEHT ES WEITER!
 
 
 
         // TODO: Convert momenta to physical units
         //      pzinvpeak = 1./pzinvpeak*0.00299792458;
         //      pzinvpeakWithBField = pzinvpeak/BMeanForParabola;
 
 
         //      if(1<fTrackerTask->GetVerbose()) {
         //
         //              // TODO Add missing output
         //
         //
         //
         //
         //              //              if (kTRUE == correctpz)
         //              //              {
         //              //                      std::cout << "Watch out! p_z value in plot is already corrected!!!"  << std::endl;
         //              //              }
         //      }
 }

void PndFtsHoughTrackFinder::FindZyLineMatchingToLineParabolaLineInZx ( )

protected

Definition at line 236 of file PndFtsHoughTrackFinder.cxx.

References fHoughTrackCandsComplete, fHoughTrackCandsZxPlaneOnly, PndFtsHoughSpace::FillHoughSpace(), PndFtsHoughSpace::FindAllPeaksScanPathsMergeBins(), fMinPeakHeightZyLine, fParams, fTrackerTask, PndFtsHoughTrackerTask::GetVerbose(), PndFtsHoughTrackFinderParams::getZLineParabola(), and PndFtsHoughTrackCand::SetZyLine().

Referenced by FindTracks().

                                                                       {
         // loop over line+parabola+line track candidates in zx plane, pass track cand. to Hough space (one Hough transform needed for each line+parabola+line track cand.)
         // Check all skewed hits whether they might belong to any of the track candidates
         // Calculate (x,z) coordinate hypotheses for skewed hits which might belong to track candidates and run line Hough transform on these hypotheses
         //----------------------------------
         // zy plane: Straight line Hough transform
         // loop over line+parabola+line (LPL) from zx plane
         for (UInt_t iLPL = 0; iLPL < fHoughTrackCandsZxPlaneOnly.size(); ++iLPL) {
                 // determine where to look for line in zy plane
                 static const Int_t stepsPerThetaDegZyLine = 4; // greater number means finer scanning in theta
                 static const Int_t thetaDegLowZyLine = -18; // in degree
                 static const Int_t thetaDegHighZyLine = 18; // in degree
                 // create Hough space
                 PndFtsHoughSpaceBinning binningZyLine(
                                 stepsPerThetaDegZyLine * (thetaDegHighZyLine - thetaDegLowZyLine),
                                 thetaDegLowZyLine * TMath::DegToRad(), // in rad
                                 thetaDegHighZyLine * TMath::DegToRad(), // in rad
                                 stepsPerThetaDegZyLine * 16, // TODO: Check values
                                 -80., // in cm // TODO: Check values
                                 80. // in cm
                 );
                 PndFtsHoughSpace houghspaceZyLine("lineZy", iLPL,
                                 binningZyLine,
                                 fParams.getZLineParabola(), 0., &(fHoughTrackCandsZxPlaneOnly[iLPL]),
                                 fTrackerTask);
                 // Do line Hough transform for current line+parabola+line for skewed hits in all stations
                 try {
                         houghspaceZyLine.FillHoughSpace();
                 } catch (std::runtime_error& e) {
                         std::cerr
                         << "Hough Space for zy line before dipole could not be created! \n";
                         std::cerr << "runtime_error: " << e.what() << '\n';
                 }
                 // find peaks for line Hough space and store in vector
                 std::vector<PndFtsHoughTracklet> trackletsZyLine =
                                 houghspaceZyLine.FindAllPeaksScanPathsMergeBins(
                                                 fMinPeakHeightZyLine);
                 // construct newHoughTrackCand by adding zy line to line+parabola+line (in zx)
                 if (1 < fTrackerTask->GetVerbose()) {
                         std::cout
                         << "Create track candidates by adding line in zy to line+parabola+line in zx "
                         << iLPL << "\n"
                         << "If no zy line can be found, delete track candidate.\n";
                 }
                 // loop over all zy lines which were found for line+parabola+line
                 for (UInt_t iZyLine = 0; iZyLine < trackletsZyLine.size(); ++iZyLine) {
                         PndFtsHoughTrackCand fullTrackCand(
                                         fHoughTrackCandsZxPlaneOnly[iLPL]); // make copy
                         fullTrackCand.SetZyLine(trackletsZyLine[iZyLine]); // add zy line
                         fHoughTrackCandsComplete.push_back(fullTrackCand); // add as track candidate
                 }
         } // loop over all line+parabola+line from zx plane
 }

PndFtsHoughTrackCand PndFtsHoughTrackFinder::GetHoughTrack ( int i ) const

inline

Returns the track cand. with index i.

Note: For debugging only.

Parameters

i	Index of requested track cand.

Returns: Track cand. to index i.

Definition at line 103 of file PndFtsHoughTrackFinder.h.

References fHoughTrackCandsComplete, and i.

Referenced by PndFtsHoughTrackerTask::Exec().

103 { return fHoughTrackCandsComplete[i]; };

i

Int_t i

Definition: run_full.C:25

PndFtsHoughTrackFinder::fHoughTrackCandsComplete

std::vector< PndFtsHoughTrackCand > fHoughTrackCandsComplete

For internal storing of complete track cands.

Definition: PndFtsHoughTrackFinder.h:129

Int_t PndFtsHoughTrackFinder::getNLinesBeforeDipoleFound ( ) const

inline

Definition at line 106 of file PndFtsHoughTrackFinder.h.

References fNLinesBeforeDipoleFound.

106 { return fNLinesBeforeDipoleFound; };

PndFtsHoughTrackFinder::fNLinesBeforeDipoleFound

Int_t fNLinesBeforeDipoleFound

Definition: PndFtsHoughTrackFinder.h:148

Int_t PndFtsHoughTrackFinder::getNLinesBehindDipoleFound ( ) const

inline

Definition at line 107 of file PndFtsHoughTrackFinder.h.

References fNLinesBehindDipoleFound.

107 { return fNLinesBehindDipoleFound; };

PndFtsHoughTrackFinder::fNLinesBehindDipoleFound

Int_t fNLinesBehindDipoleFound

Definition: PndFtsHoughTrackFinder.h:149

Int_t PndFtsHoughTrackFinder::getNParabolasFound ( ) const

inline

Definition at line 108 of file PndFtsHoughTrackFinder.h.

References fNParabolasFound.

Referenced by PndFtsHoughTrackerTaskQA::Exec().

108 { return fNParabolasFound; };

PndFtsHoughTrackFinder::fNParabolasFound

Int_t fNParabolasFound

Definition: PndFtsHoughTrackFinder.h:150

Int_t PndFtsHoughTrackFinder::getNTracksFound ( ) const

inline

Definition at line 109 of file PndFtsHoughTrackFinder.h.

References fNTracksFound.

109 { return fNTracksFound; };

PndFtsHoughTrackFinder::fNTracksFound

Int_t fNTracksFound

Definition: PndFtsHoughTrackFinder.h:151

PndTrack PndFtsHoughTrackFinder::GetPndTrack ( int i )

inline

Returns the number of found tracks.

Returns the track cand. with index i.

Note: Method calculates first and last parameters of the PndTrack object, but uses an empty PndTrackCand which has to be set lateron using SetTrackCandRef!

Parameters

i	Index of requested track cand.

Returns: Track cand. to index i.

Definition at line 89 of file PndFtsHoughTrackFinder.h.

References fHoughTrackCandsComplete, and i.

Referenced by PndFtsHoughTrackerTask::Exec().

89 { return fHoughTrackCandsComplete[i].getPndTrack(); };

i

Int_t i

Definition: run_full.C:25

PndFtsHoughTrackFinder::fHoughTrackCandsComplete

std::vector< PndFtsHoughTrackCand > fHoughTrackCandsComplete

For internal storing of complete track cands.

Definition: PndFtsHoughTrackFinder.h:129

PndTrackCand PndFtsHoughTrackFinder::GetPndTrackCand ( int i )

inline

Returns the track cand. with index i.

Note: Use this to add a PndTrackCand to the corresponding PndTrack object with SetTrackCandRef!

Parameters

i	Index of requested track cand.

Returns: Track cand. to index i.

Definition at line 96 of file PndFtsHoughTrackFinder.h.

References fHoughTrackCandsComplete, and i.

Referenced by PndFtsHoughTrackerTask::Exec().

96 { return fHoughTrackCandsComplete[i].getPndTrackCand(); };

i

Int_t i

Definition: run_full.C:25

PndFtsHoughTrackFinder::fHoughTrackCandsComplete

std::vector< PndFtsHoughTrackCand > fHoughTrackCandsComplete

For internal storing of complete track cands.

Definition: PndFtsHoughTrackFinder.h:129

Bool_t PndFtsHoughTrackFinder::LineBehindDipoleMatchesToLinePlusParabola	(	const PndFtsHoughTrackCand &	lineParabola,
		const PndFtsHoughTracklet &	lineBehindDipole
	)		const

inlineprotected

Definition at line 189 of file PndFtsHoughTrackFinder.h.

References Double_t, fabs(), fThetaRadLineBehindDipoleMatchesToParabolaIfBelow, PndFtsHoughTracklet::getThetaRadVal(), PndFtsHoughTrackCand::getThetaZyRad(), and PndFtsHoughTracklet::getZRefLabSys().

Referenced by FindMatchingParabolaToLineBeforeDipoleZxAndAddLineBehindDipole().

         {
 
         // the angles should be compared at the z coordinate where I switch from parabola to line behind dipole
         Double_t zParabolaLine = lineBehindDipole.getZRefLabSys();
         return fabs( lineParabola.getThetaZyRad(zParabolaLine) - lineBehindDipole.getThetaRadVal() ) < fThetaRadLineBehindDipoleMatchesToParabolaIfBelow;
 }