#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
virtual DirectionType	direction (double s) const

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)

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

virtual PositionType	position (double s) const

PositionTypeDouble	positionInDouble (double s) const

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

virtual	~HelixArbitraryPlaneCrossing2Order ()

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

typedef Basic3DVector<double> HelixArbitraryPlaneCrossing2Order::DirectionTypeDouble

Definition at line 53 of file HelixArbitraryPlaneCrossing2Order.h.

typedef Basic3DVector<double> HelixArbitraryPlaneCrossing2Order::PositionTypeDouble

Definition at line 52 of file HelixArbitraryPlaneCrossing2Order.h.

Constructor & Destructor Documentation

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 10 of file HelixArbitraryPlaneCrossing2Order.cc.

References p2, 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::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 22 of file HelixArbitraryPlaneCrossing2Order.h.

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

virtual HelixArbitraryPlaneCrossing2Order::~HelixArbitraryPlaneCrossing2Order ( )

inlinevirtual

Definition at line 34 of file HelixArbitraryPlaneCrossing2Order.h.

34 {}

Member Function Documentation

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

virtual

Direction at pathlength s from the starting point.

Implements HelixPlaneCrossing.

Definition at line 122 of file HelixArbitraryPlaneCrossing2Order.cc.

References dir, directionInDouble(), Basic3DVector< T >::x(), Basic3DVector< T >::y(), and Basic3DVector< T >::z().

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

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

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

Definition at line 131 of file HelixArbitraryPlaneCrossing2Order.cc.

References 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);
 }

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

virtual

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 40 of file HelixArbitraryPlaneCrossing2Order.cc.

References funct::abs(), alignCSCRings::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);
 }

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

virtual

Position at pathlength s from the starting point.

Implements HelixPlaneCrossing.

Definition at line 102 of file HelixArbitraryPlaneCrossing2Order.cc.

References positionInDouble(), Basic3DVector< T >::x(), Basic3DVector< T >::y(), and Basic3DVector< T >::z().

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

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

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

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

Definition at line 111 of file HelixArbitraryPlaneCrossing2Order.cc.

References 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);
 }

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

inline

Pathlength to closest solution.

Definition at line 65 of file HelixArbitraryPlaneCrossing2Order.h.

Referenced by solutionByDirection().

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

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 142 of file HelixArbitraryPlaneCrossing2Order.cc.

References alongMomentum, anyDirection, cmsHarvester::path, indexGen::s2, smallestPathLength(), std::swap(), thePropDir, and TrackValidation_HighPurity_cff::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;
     }
   }
   return std::pair<bool,double>(valid,path);
 }