#include <HelixForwardPlaneCrossing.h>

Inheritance diagram for HelixForwardPlaneCrossing:

Public Member Functions
DirectionType	direction (double s) const override

	HelixForwardPlaneCrossing (const PositionType &point, const DirectionType &direction, const float curvature, const PropagationDirection propDir=alongMomentum)

std::pair< bool, double >	pathLength (const Plane &plane) override

PositionType	position (double s) const override

	~HelixForwardPlaneCrossing () override

Public Member Functions inherited from HelixPlaneCrossing
virtual	~HelixPlaneCrossing ()=default

Private Types
typedef Basic3DVector< double >	DirectionTypeDouble

typedef Basic3DVector< double >	PositionTypeDouble

Private Attributes
double	theCachedCDPhi

double	theCachedDPhi

double	theCachedS

double	theCachedSDPhi

double	theCosPhi0

double	theCosTheta

const PropagationDirection	thePropDir

const double	theRho

double	theSinPhi0

double	theSinTheta

const double	theX0

const double	theY0

const double	theZ0

Static Private Attributes
static const float	theNumericalPrecision = 5.e-7

Additional Inherited Members
Public Types inherited from HelixPlaneCrossing
typedef Basic3DVector< float >	DirectionType

typedef Basic3DVector< float >	PositionType
	the helix is passed to the constructor and does not appear in the interface More...

Detailed Description

Calculates intersections of a helix with planes perpendicular to the z-axis.

Definition at line 14 of file HelixForwardPlaneCrossing.h.

Member Typedef Documentation

typedef Basic3DVector<double> HelixForwardPlaneCrossing::DirectionTypeDouble

private

Definition at line 56 of file HelixForwardPlaneCrossing.h.

typedef Basic3DVector<double> HelixForwardPlaneCrossing::PositionTypeDouble

private

Definition at line 55 of file HelixForwardPlaneCrossing.h.

Constructor & Destructor Documentation

HelixForwardPlaneCrossing::HelixForwardPlaneCrossing	(	const PositionType &	point,
		const DirectionType &	direction,
		const float	curvature,
		const PropagationDirection	propDir = `alongMomentum`
	)

Constructor using point, direction and (transverse!) curvature.

Definition at line 6 of file HelixForwardPlaneCrossing.cc.

References fireworks::p2, mathSSE::sqrt(), theCosPhi0, theCosTheta, theSinPhi0, theSinTheta, Basic3DVector< T >::x(), Basic3DVector< T >::y(), and Basic3DVector< T >::z().

     : theX0(point.x()),
       theY0(point.y()),
       theZ0(point.z()),
       theRho(curvature),
       thePropDir(propDir),
       theCachedS(0),
       theCachedDPhi(0.),
       theCachedSDPhi(0.),
       theCachedCDPhi(1.) {
   //
   // Components of direction vector (with correct normalisation)
   //
   double px = direction.x();
   double py = direction.y();
   double pz = direction.z();
   double pt2 = px * px + py * py;
   double p2 = pt2 + pz * pz;
   double pI = 1. / sqrt(p2);
   double ptI = 1. / sqrt(pt2);
   theCosPhi0 = px * ptI;
   theSinPhi0 = py * ptI;
   theCosTheta = pz * pI;
   theSinTheta = pt2 * ptI * pI;
 }

HelixForwardPlaneCrossing::~HelixForwardPlaneCrossing ( )

inlineoverride

Definition at line 23 of file HelixForwardPlaneCrossing.h.

23 {}

Member Function Documentation

HelixPlaneCrossing::DirectionType HelixForwardPlaneCrossing::direction ( double s ) const

overridevirtual

Direction at pathlength s from the starting point.

Implements HelixPlaneCrossing.

Definition at line 68 of file HelixForwardPlaneCrossing.cc.

References alignCSCRings::e, alignCSCRings::s, theCachedCDPhi, theCachedDPhi, theCachedS, theCachedSDPhi, theCosPhi0, theCosTheta, theRho, theSinPhi0, and theSinTheta.

                                                                                    {
   //
   // Calculate delta phi (if not already available)
   //
   if (s != theCachedS) {
     theCachedS = s;
     theCachedDPhi = theCachedS * theRho * theSinTheta;
     vdt::fast_sincos(theCachedDPhi, theCachedSDPhi, theCachedCDPhi);
   }
 
   if (fabs(theCachedDPhi) > 1.e-4) {
     // full helix formula
     return DirectionType(theCosPhi0 * theCachedCDPhi - theSinPhi0 * theCachedSDPhi,
                          theSinPhi0 * theCachedCDPhi + theCosPhi0 * theCachedSDPhi,
                          theCosTheta / theSinTheta);
   } else {
     // 2nd order
     double dph = theCachedS * theRho * theSinTheta;
     return DirectionType(theCosPhi0 - (theSinPhi0 + 0.5 * theCosPhi0 * dph) * dph,
                          theSinPhi0 + (theCosPhi0 - 0.5 * theSinPhi0 * dph) * dph,
                          theCosTheta / theSinTheta);
   }
 }

std::pair<bool, double> HelixForwardPlaneCrossing::pathLength ( const Plane & plane )

inlineoverridevirtual

Propagation status (true if valid) and (signed) path length along the helix from the starting point to the plane.

Implements HelixPlaneCrossing.

Definition at line 28 of file HelixForwardPlaneCrossing.h.

References funct::abs(), alongMomentum, edm::isNotFinite(), min(), oppositeToMomentum, GloballyPositioned< T >::position(), theCosTheta, thePropDir, theZ0, UNLIKELY, and Basic3DVector< T >::z().

Referenced by CompositeTECWedge::computeCrossings(), TIDRing::computeCrossings(), and CompositeTECPetal::computeCrossings().

                                                                 {
     //
     // Protect against p_z=0 and calculate path length
     //
     if UNLIKELY (std::abs(theCosTheta) < std::numeric_limits<float>::min())
       return std::pair<bool, double>(false, 0);
 
     double dS = (plane.position().z() - theZ0) / theCosTheta;
 
     // negative logic to avoid checking for anyDirection...
     return std::make_pair(!(((thePropDir == alongMomentum) & (dS < 0.)) |
                             ((thePropDir == oppositeToMomentum) & (dS > 0.)) | edm::isNotFinite(dS)),
                           dS);
   }

HelixPlaneCrossing::PositionType HelixForwardPlaneCrossing::position ( double s ) const

overridevirtual

Position at pathlength s from the starting point.

Implements HelixPlaneCrossing.

Definition at line 38 of file HelixForwardPlaneCrossing.cc.

References funct::abs(), alignCSCRings::e, class-composition::o, alignCSCRings::s, theCachedCDPhi, theCachedDPhi, theCachedS, theCachedSDPhi, theCosPhi0, theCosTheta, theRho, theSinPhi0, theSinTheta, theX0, theY0, and theZ0.

Referenced by CompositeTECWedge::computeCrossings(), TIDRing::computeCrossings(), and CompositeTECPetal::computeCrossings().

                                                                                  {
   //
   // Calculate delta phi (if not already available)
   //
   if (s != theCachedS) {
     theCachedS = s;
     theCachedDPhi = theCachedS * theRho * theSinTheta;
     vdt::fast_sincos(theCachedDPhi, theCachedSDPhi, theCachedCDPhi);
   }
   //
   // Calculate with appropriate formulation of full helix formula or with
   //   2nd order approximation.
   //
   if (std::abs(theCachedDPhi) > 1.e-4) {
     // "standard" helix formula
     double o = 1. / theRho;
     return PositionTypeDouble(theX0 + (-theSinPhi0 * (1. - theCachedCDPhi) + theCosPhi0 * theCachedSDPhi) * o,
                               theY0 + (theCosPhi0 * (1. - theCachedCDPhi) + theSinPhi0 * theCachedSDPhi) * o,
                               theZ0 + theCachedS * theCosTheta);
   } else {
     // 2nd order
     double st = theCachedS * theSinTheta;
     return PositionType(theX0 + (theCosPhi0 - st * 0.5 * theRho * theSinPhi0) * st,
                         theY0 + (theSinPhi0 + st * 0.5 * theRho * theCosPhi0) * st,
                         theZ0 + st * theCosTheta / theSinTheta);
   }
 }