Predicate class to check for the containment of hits in a p q hough space part. More...

#include <HitInQuadraticBox.h>

Public Types
using	HoughBox = PQBox
	Use a PQBox.

Public Member Functions
Weight	operator() (const CDCRecoHit3D &recoHit, const HoughBox *pqBox)
	Checks if the wire hit is contained in a p q hough space.

Static Public Member Functions
static bool	compareDistances (const HoughBox &pqBox, const CDCRecoHit3D &lhsRecoHit, const CDCRecoHit3D &rhsRecoHit)
	Compares distances from two hits to the track represented by the given box.

static const char *	debugLine ()
	ROOT-compatible formula for z(s) = (p + 4q)s - q/25 s^2.

Detailed Description

Predicate class to check for the containment of hits in a p q hough space part.

FIXME physical names of parameters? z(s) = 0 + (p + 4q)*s - q/25 * s^2 p - z coordinate of track in outer layers of CDC (in units of 100cm //CDC radius is 113) q - divergence of track from straight line in the middle of CDC (in units of 100cm) Note this part this code defines the performance of the search in the hough plain quite significantly and there is probably room for improvement.

Definition at line 28 of file HitInQuadraticBox.h.

Member Typedef Documentation

◆ HoughBox

using HoughBox = PQBox

Use a PQBox.

Definition at line 32 of file HitInQuadraticBox.h.

Member Function Documentation

◆ compareDistances()

static bool compareDistances	(	const HoughBox &	pqBox,
		const CDCRecoHit3D &	lhsRecoHit,
		const CDCRecoHit3D &	rhsRecoHit
	)

inlinestatic

Compares distances from two hits to the track represented by the given box.

The comparison is done based on reconstructed Z coordinates of hits and track Z position.

Definition at line 68 of file HitInQuadraticBox.h.

      {
        const double pMean = (pqBox.getLowerP() + pqBox.getUpperP()) / 2.0;
        const double qMean = (pqBox.getLowerQ() + pqBox.getUpperQ()) / 2.0;
 
        const double lhsZ = lhsRecoHit.getRecoZ();
        const double rhsZ = rhsRecoHit.getRecoZ();
 
        const double lhsS = lhsRecoHit.getArcLength2D();
        const double rhsS = rhsRecoHit.getArcLength2D();
 
        const double lhsZDistance = (pMean + 4 * qMean) * lhsS - qMean / 25 * lhsS * lhsS - lhsZ;
        const double rhsZDistance = (pMean + 4 * qMean) * rhsS - qMean / 25 * rhsS * rhsS - rhsZ;
 
        return lhsZDistance < rhsZDistance;
      }

◆ debugLine()

static const char * debugLine ( )

inlinestatic

ROOT-compatible formula for z(s) = (p + 4q)*s - q/25 * s^2.

Definition at line 86 of file HitInQuadraticBox.h.

86{ return "([0] + 4*[1])*x - [1] / 25 * x * x";}

◆ operator()()

Weight operator()	(	const CDCRecoHit3D &	recoHit,
		const HoughBox *	pqBox
	)

inline

Checks if the wire hit is contained in a p q hough space.

Returns 1.0 if it is contained, returns NAN if it is not contained.

Definition at line 38 of file HitInQuadraticBox.h.

      {
        float lowerP = pqBox->getLowerP();
        float upperP = pqBox->getUpperP();
 
        float lowerQ = pqBox->getLowerQ();
        float upperQ = pqBox->getUpperQ();
 
        float perpS = recoHit.getArcLength2D();
        float reconstructedZ = recoHit.getRecoZ();
 
        float distLowerPLowerQ = (lowerP + 4 * lowerQ) * perpS - lowerQ / 25 * perpS * perpS - reconstructedZ;
        float distUpperPLowerQ = (upperP + 4 * lowerQ) * perpS - lowerQ / 25 * perpS * perpS - reconstructedZ;
        float distLowerPUpperQ = (lowerP + 4 * upperQ) * perpS - upperQ / 25 * perpS * perpS - reconstructedZ;
        float distUpperPUpperQ = (upperP + 4 * upperQ) * perpS - upperQ / 25 * perpS * perpS - reconstructedZ;
 
        const bool sameSign = SameSignChecker::sameSign(distLowerPLowerQ, distUpperPLowerQ,
                                                        distLowerPUpperQ, distUpperPUpperQ);
        if (not sameSign) {
          return 1.0;
        } else {
          return NAN;
        }
      }

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

tracking/trackFindingCDC/hough/algorithms/include/HitInQuadraticBox.h

Public Types

Public Member Functions