#include <HelixArbitraryPlaneCrossing2Order.h>

Inheritance diagram for HelixArbitraryPlaneCrossing2Order:

Public Types
typedef Basic3DVector< double >	DirectionTypeDouble

typedef Basic3DVector< double >	PositionTypeDouble

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...

Public Member Functions
DirectionType	direction (double s) const override

DirectionTypeDouble	directionInDouble (double s) const

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

	HelixArbitraryPlaneCrossing2Order (const double &x0, const double &y0, const double &z0, const double &cosPhi0, const double &sinPhi0, const double &cosTheta, const double &sinTheta, const double &rho, const PropagationDirection propDir=alongMomentum)

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

PositionType	position (double s) const override

PositionTypeDouble	positionInDouble (double s) const

double	smallestPathLength (const double firstPathLength, const double secondPathLength) const

	~HelixArbitraryPlaneCrossing2Order () override

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

Private Member Functions
std::pair< bool, double >	solutionByDirection (const double dS1, const double dS2) const

Private Attributes
double	theCosPhi0

double	theCosTheta

const PropagationDirection	thePropDir

const double	theRho

double	theSinPhi0

double	theSinThetaI

const double	theX0

const double	theY0

const double	theZ0

Detailed Description

Calculates intersections of a helix with planes of any orientation using a parabolic approximation.

Definition at line 10 of file HelixArbitraryPlaneCrossing2Order.h.

Member Typedef Documentation

◆ DirectionTypeDouble

typedef Basic3DVector<double> HelixArbitraryPlaneCrossing2Order::DirectionTypeDouble

Definition at line 59 of file HelixArbitraryPlaneCrossing2Order.h.

◆ PositionTypeDouble

typedef Basic3DVector<double> HelixArbitraryPlaneCrossing2Order::PositionTypeDouble

Definition at line 58 of file HelixArbitraryPlaneCrossing2Order.h.

Constructor & Destructor Documentation

◆ HelixArbitraryPlaneCrossing2Order() [1/2]

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

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

Definition at line 11 of file HelixArbitraryPlaneCrossing2Order.cc.

References direction(), SiStripOfflineCRack_cfg::p2, HLT_2024v12_cff::pt2, multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, mathSSE::sqrt(), theCosPhi0, theCosTheta, theSinPhi0, theSinThetaI, Basic3DVector< T >::x(), Basic3DVector< T >::y(), and Basic3DVector< T >::z().

     : theX0(point.x()), theY0(point.y()), theZ0(point.z()), theRho(curvature), thePropDir(propDir) {
   //
   // 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;
   theSinThetaI = p2 * pI * ptI;  //  (1/(pt/p)) = p/pt = p*ptI and p = p2/p = p2*pI
 }

◆ HelixArbitraryPlaneCrossing2Order() [2/2]

HelixArbitraryPlaneCrossing2Order::HelixArbitraryPlaneCrossing2Order	(	const double &	x0,
		const double &	y0,
		const double &	z0,
		const double &	cosPhi0,
		const double &	sinPhi0,
		const double &	cosTheta,
		const double &	sinTheta,
		const double &	rho,
		const PropagationDirection	propDir = `alongMomentum`
	)

inline

Fast constructor (for use by HelixArbitraryPlaneCrossing).

Definition at line 20 of file HelixArbitraryPlaneCrossing2Order.h.

       : theX0(x0),
         theY0(y0),
         theZ0(z0),
         theCosPhi0(cosPhi0),
         theSinPhi0(sinPhi0),
         theCosTheta(cosTheta),
         theSinThetaI(1. / sinTheta),
         theRho(rho),
         thePropDir(propDir) {}

◆ ~HelixArbitraryPlaneCrossing2Order()

HelixArbitraryPlaneCrossing2Order::~HelixArbitraryPlaneCrossing2Order ( )

inlineoverride

Definition at line 40 of file HelixArbitraryPlaneCrossing2Order.h.

40 {}

Member Function Documentation

◆ direction()

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

overridevirtual

Direction at pathlength s from the starting point.

Implements HelixPlaneCrossing.

Definition at line 114 of file HelixArbitraryPlaneCrossing2Order.cc.

References DeadROC_duringRun::dir, directionInDouble(), and alignCSCRings::s.

Referenced by HelixArbitraryPlaneCrossing2Order().

                                                                                            {
   // use double precision result
   DirectionTypeDouble dir = directionInDouble(s);
   return DirectionType(dir.x(), dir.y(), dir.z());
 }

◆ directionInDouble()

HelixArbitraryPlaneCrossing2Order::DirectionTypeDouble HelixArbitraryPlaneCrossing2Order::directionInDouble ( double s ) const

Direction at pathlength s from the starting point in double precision.

Definition at line 122 of file HelixArbitraryPlaneCrossing2Order.cc.

References alignCSCRings::s, theCosPhi0, theCosTheta, theRho, theSinPhi0, and theSinThetaI.

Referenced by direction(), and HelixArbitraryPlaneCrossing::directionInDouble().

                     {
   // based on delta phi
   double dph = s * theRho / theSinThetaI;
   return DirectionTypeDouble(theCosPhi0 - (theSinPhi0 + 0.5 * dph * theCosPhi0) * dph,
                              theSinPhi0 + (theCosPhi0 - 0.5 * dph * theSinPhi0) * dph,
                              theCosTheta * theSinThetaI);
 }

◆ pathLength()

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

overridevirtual

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

Implements HelixPlaneCrossing.

Definition at line 35 of file HelixArbitraryPlaneCrossing2Order.cc.

References funct::abs(), MillePedeFileConverter_cfg::e, LIKELY, Plane::localZ(), Plane::normalVector(), solutionByDirection(), mathSSE::sqrt(), theCosPhi0, theCosTheta, theRho, theSinPhi0, theSinThetaI, theX0, theY0, theZ0, UNLIKELY, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by PixelForwardLayer::computeCrossings(), PixelForwardLayerPhase1::computeCrossings(), and HelixArbitraryPlaneCrossing::pathLength().

                                                                                       {
   //
   // get local z-vector in global co-ordinates and
   // distance to starting point
   //
   GlobalVector normalToPlane = plane.normalVector();
   double nPx = normalToPlane.x();
   double nPy = normalToPlane.y();
   double nPz = normalToPlane.z();
   double cP = plane.localZ(GlobalPoint(theX0, theY0, theZ0));
   //
   // coefficients of 2nd order equation to obtain intersection point
   // in approximation (without curvature-related factors).
   //
   double ceq1 = theRho * (nPx * theSinPhi0 - nPy * theCosPhi0);
   double ceq2 = nPx * theCosPhi0 + nPy * theSinPhi0 + nPz * theCosTheta * theSinThetaI;
   double ceq3 = cP;
   //
   // Check for degeneration to linear equation (zero
   //   curvature, forward plane or direction perp. to plane)
   //
   double dS1, dS2;
   if LIKELY (std::abs(ceq1) > FLT_MIN) {
     double deq1 = ceq2 * ceq2;
     double deq2 = ceq1 * ceq3;
     if (std::abs(deq1) < FLT_MIN || std::abs(deq2 / deq1) > 1.e-6) {
       //
       // Standard solution for quadratic equations
       //
       double deq = deq1 + 2 * deq2;
       if UNLIKELY (deq < 0.)
         return std::pair<bool, double>(false, 0);
       double ceq = ceq2 + std::copysign(std::sqrt(deq), ceq2);
       dS1 = (ceq / ceq1) * theSinThetaI;
       dS2 = -2. * (ceq3 / ceq) * theSinThetaI;
     } else {
       //
       // Solution by expansion of sqrt(1+deq)
       //
       double ceq = (ceq2 / ceq1) * theSinThetaI;
       double deq = deq2 / deq1;
       deq *= (1 - 0.5 * deq);
       dS1 = -ceq * deq;
       dS2 = ceq * (2 + deq);
     }
   } else {
     //
     // Special case: linear equation
     //
     dS1 = dS2 = -(ceq3 / ceq2) * theSinThetaI;
   }
   //
   // Choose and return solution
   //
   return solutionByDirection(dS1, dS2);
 }

◆ position()

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

overridevirtual

Position at pathlength s from the starting point.

Implements HelixPlaneCrossing.

Definition at line 95 of file HelixArbitraryPlaneCrossing2Order.cc.

References positionInDouble(), and alignCSCRings::s.

Referenced by PixelForwardLayer::computeCrossings(), and PixelForwardLayerPhase1::computeCrossings().

                                                                                          {
   // use double precision result
   PositionTypeDouble pos = positionInDouble(s);
   return PositionType(pos.x(), pos.y(), pos.z());
 }

◆ positionInDouble()

HelixArbitraryPlaneCrossing2Order::PositionTypeDouble HelixArbitraryPlaneCrossing2Order::positionInDouble ( double s ) const

Position at pathlength s from the starting point in double precision.

Definition at line 103 of file HelixArbitraryPlaneCrossing2Order.cc.

References alignCSCRings::s, theCosPhi0, theCosTheta, theRho, theSinPhi0, theSinThetaI, theX0, theY0, and theZ0.

Referenced by position(), and HelixArbitraryPlaneCrossing::positionInDouble().

                     {
   // based on path length in the transverse plane
   double st = s / theSinThetaI;
   return PositionTypeDouble(theX0 + (theCosPhi0 - (st * 0.5 * theRho) * theSinPhi0) * st,
                             theY0 + (theSinPhi0 + (st * 0.5 * theRho) * theCosPhi0) * st,
                             theZ0 + st * theCosTheta * theSinThetaI);
 }

◆ smallestPathLength()

double HelixArbitraryPlaneCrossing2Order::smallestPathLength	(	const double	firstPathLength,
		const double	secondPathLength
	)		const

inline

Pathlength to closest solution.

Definition at line 71 of file HelixArbitraryPlaneCrossing2Order.h.

Referenced by solutionByDirection().

                                                                                                       {
     return fabs(firstPathLength) < fabs(secondPathLength) ? firstPathLength : secondPathLength;
   }

◆ solutionByDirection()

std::pair< bool, double > HelixArbitraryPlaneCrossing2Order::solutionByDirection	(	const double	dS1,
		const double	dS2
	)		const

private

Choice of one of two solutions according to the propagation direction.

Definition at line 133 of file HelixArbitraryPlaneCrossing2Order.cc.

References alongMomentum, anyDirection, edm::isNotFinite(), castor_dqm_sourceclient_file_cfg::path, smallestPathLength(), edm::swap(), thePropDir, and validateGeometry_cfg::valid.

Referenced by pathLength().

                                                                                                        {
   bool valid = false;
   double path = 0;
   if (thePropDir == anyDirection) {
     valid = true;
     path = smallestPathLength(dS1, dS2);
   } else {
     // use same logic for both directions (invert if necessary)
     double propSign = thePropDir == alongMomentum ? 1 : -1;
     double s1(propSign * dS1);
     double s2(propSign * dS2);
     // sort
     if (s1 > s2)
       std::swap(s1, s2);
     // choose solution (if any with positive sign)
     if ((s1 < 0) & (s2 >= 0)) {
       // First solution in backward direction: choose second one.
       valid = true;
       path = propSign * s2;
     } else if (s1 >= 0) {
       // First solution in forward direction: choose it (s2 is further away!).
       valid = true;
       path = propSign * s1;
     }
   }
   if (edm::isNotFinite(path))
     valid = false;
   return std::pair<bool, double>(valid, path);
 }