---

HelixArbitraryPlaneCrossing Class Reference

Calculates intersections of a helix with planes of any orientation. More...

#include <TrackingTools/GeomPropagators/interface/HelixArbitraryPlaneCrossing.h>

Inheritance diagram for HelixArbitraryPlaneCrossing:

List of all members.

Public Types
typedef Basic3DVector< double >	DirectionTypeDouble
typedef Basic3DVector< double >	PositionTypeDouble
Public Member Functions
virtual DirectionType	direction (double s) const
	Direction at pathlength s from the starting point.
DirectionTypeDouble	directionInDouble (double s) const
	Direction at pathlength s from the starting point.
	HelixArbitraryPlaneCrossing (const PositionType &point, const DirectionType &direction, const float curvature, const PropagationDirection propDir=alongMomentum)
	Constructor using point, direction and (transverse!) curvature.
virtual std::pair< bool, double >	pathLength (const Plane &plane)
	Propagation status (true if valid) and (signed) path length along the helix from the starting point to the plane.
virtual PositionType	position (double s) const
	Position at pathlength s from the starting point.
PositionTypeDouble	positionInDouble (double s) const
	Position at pathlength s from the starting point.
virtual	~HelixArbitraryPlaneCrossing ()
Private Member Functions
bool	notAtSurface (const Plane &, const PositionTypeDouble &, const float) const
	Iteration control: check for significant distance to plane.
Private Attributes
double	theCachedCDPhi
double	theCachedDPhi
double	theCachedS
double	theCachedSDPhi
double	theCosPhi0
double	theCosTheta
const PropagationDirection	thePropDir
HelixArbitraryPlaneCrossing2Order	theQuadraticCrossingFromStart
const double	theRho
double	theSinPhi0
double	theSinTheta
const double	theX0
const double	theY0
const double	theZ0
Static Private Attributes
static const float	theMaxDistToPlane = 1.e-4
static const float	theNumericalPrecision = 5.e-7

---

Detailed Description

Calculates intersections of a helix with planes of any orientation.

Definition at line 9 of file HelixArbitraryPlaneCrossing.h.

---

Member Typedef Documentation

typedef Basic3DVector<double> HelixArbitraryPlaneCrossing::DirectionTypeDouble

Definition at line 37 of file HelixArbitraryPlaneCrossing.h.

typedef Basic3DVector<double> HelixArbitraryPlaneCrossing::PositionTypeDouble

Definition at line 36 of file HelixArbitraryPlaneCrossing.h.

---

Constructor & Destructor Documentation

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

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

Definition at line 8 of file HelixArbitraryPlaneCrossing.cc.

References p, funct::sqrt(), theCosPhi0, theCosTheta, theSinPhi0, theSinTheta, Basic3DVector< T >::x(), Basic3DVector< T >::y(), and Basic3DVector< T >::z().

00011                                                                                              :
00012   theX0(point.x()),
00013   theY0(point.y()),
00014   theZ0(point.z()),
00015   theRho(curvature),
00016   theQuadraticCrossingFromStart(point,direction,curvature,propDir),
00017   thePropDir(propDir),
00018   theCachedS(0),
00019   theCachedDPhi(0.),
00020   theCachedSDPhi(0.),
00021   theCachedCDPhi(1.)
00022 {
00023   //
00024   // Components of direction vector (with correct normalisation)
00025   //
00026   double px = direction.x();
00027   double py = direction.y();
00028   double pz = direction.z();
00029   double pt = px*px+py*py;
00030   double p = sqrt(pt+pz*pz);
00031   pt = sqrt(pt);
00032   theCosPhi0 = px/pt;
00033   theSinPhi0 = py/pt;
00034   theCosTheta = pz/p;
00035   theSinTheta = pt/p;
00036 }
//

virtual HelixArbitraryPlaneCrossing::~HelixArbitraryPlaneCrossing

(

)

[inline, virtual]

Definition at line 18 of file HelixArbitraryPlaneCrossing.h.

{}

---

Member Function Documentation

HelixPlaneCrossing::DirectionType HelixArbitraryPlaneCrossing::direction

(

double

s

)

const [virtual]

Direction at pathlength s from the starting point.

Implements HelixPlaneCrossing.

Definition at line 163 of file HelixArbitraryPlaneCrossing.cc.

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

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

HelixArbitraryPlaneCrossing::DirectionTypeDouble HelixArbitraryPlaneCrossing::directionInDouble

(

double

s

)

const

Direction at pathlength s from the starting point.

Definition at line 172 of file HelixArbitraryPlaneCrossing.cc.

References funct::cos(), HelixArbitraryPlaneCrossing2Order::directionInDouble(), e, funct::sin(), theCachedCDPhi, theCachedDPhi, theCachedS, theCachedSDPhi, theCosPhi0, theCosTheta, theQuadraticCrossingFromStart, theRho, theSinPhi0, and theSinTheta.

Referenced by direction(), and pathLength().

                                                              {
  //
  // Calculate delta phi (if not already available)
  //
  if ( s!=theCachedS ) {
    theCachedS = s;
    theCachedDPhi = theCachedS*theRho*theSinTheta;
    theCachedSDPhi = sin(theCachedDPhi);
    theCachedCDPhi = cos(theCachedDPhi);
  }

  if ( fabs(theCachedDPhi)>1.e-4 ) {
    // full helix formula
    return DirectionTypeDouble(theCosPhi0*theCachedCDPhi-theSinPhi0*theCachedSDPhi,
                               theSinPhi0*theCachedCDPhi+theCosPhi0*theCachedSDPhi,
                               theCosTheta/theSinTheta);
  }
  else {
    // 2nd order
    return theQuadraticCrossingFromStart.directionInDouble(theCachedS);
  }
}

bool HelixArbitraryPlaneCrossing::notAtSurface	(	const Plane &	plane,
		const PositionTypeDouble &	point,
		const	float
	)			const [inline, private]

Iteration control: check for significant distance to plane.

Definition at line 196 of file HelixArbitraryPlaneCrossing.cc.

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

Referenced by pathLength().

                                                                           {
  float dz = plane.localZ(Surface::GlobalPoint(point.x(),point.y(),point.z()));
  return fabs(dz)>maxDist;
}

std::pair< bool, double > HelixArbitraryPlaneCrossing::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 41 of file HelixArbitraryPlaneCrossing.cc.

References alongMomentum, anyDirection, directionInDouble(), first, iteration, Basic3DVector< T >::mag(), notAtSurface(), oppositeToMomentum, HelixArbitraryPlaneCrossing2Order::pathLength(), GloballyPositioned< T >::position(), positionInDouble(), theCosPhi0, theCosTheta, theMaxDistToPlane, theNumericalPrecision, thePropDir, theQuadraticCrossingFromStart, theRho, theSinPhi0, theSinTheta, theX0, theY0, theZ0, Basic3DVector< T >::x(), Basic3DVector< T >::y(), and Basic3DVector< T >::z().

                                                          {
  //
  // Constants used for control of convergence
  //
  const int maxIterations(100);
  //
  // maximum distance to plane (taking into account numerical precision)
  //
  float maxNumDz = theNumericalPrecision*plane.position().mag();
  float safeMaxDist = (theMaxDistToPlane>maxNumDz?theMaxDistToPlane:maxNumDz);
  //
  // Prepare internal value of the propagation direction and position / direction vectors for iteration 
  //
  PropagationDirection propDir = thePropDir;
  PositionTypeDouble xnew(theX0,theY0,theZ0);
  DirectionTypeDouble pnew(theCosPhi0,theSinPhi0,theCosTheta/theSinTheta);
  //
  // Prepare iterations: count and total pathlength
  //
  int iteration(maxIterations);
  double dSTotal(0.);
  //
  bool first(true);
  while ( notAtSurface(plane,xnew,safeMaxDist) ) {
    //
    // return empty solution vector if no convergence after maxIterations iterations
    //
    if ( --iteration<0 ) {
      edm::LogInfo("HelixArbitraryPlaneCrossing") << "pathLength : no convergence";
      return std::pair<bool,double>(false,0);
    }
    //
    // Use existing 2nd order object at first pass, create temporary object
    // for subsequent passes.
    //
    std::pair<bool,double> deltaS2;
    if ( first ) {
      first = false;
      deltaS2 = theQuadraticCrossingFromStart.pathLength(plane);
    }
    else {
      HelixArbitraryPlaneCrossing2Order quadraticCrossing(xnew.x(),xnew.y(),xnew.z(),
                                                          pnew.x(),pnew.y(),
                                                          theCosTheta,theSinTheta,
                                                          theRho,
                                                          anyDirection);
      deltaS2 = quadraticCrossing.pathLength(plane);
    }
    if ( !deltaS2.first )  return deltaS2;
    //
    // Calculate and sort total pathlength (max. 2 solutions)
    //
    dSTotal += deltaS2.second;
    PropagationDirection newDir = dSTotal>=0 ? alongMomentum : oppositeToMomentum;
    if ( propDir == anyDirection ) {
      propDir = newDir;
    }
    else {
      if ( newDir!=propDir )  return std::pair<bool,double>(false,0);
    }
    //
    // Step forward by dSTotal.
    //
    xnew = positionInDouble(dSTotal);
    pnew = directionInDouble(dSTotal);
  }
  //
  // Return result
  //
  return std::pair<bool,double>(true,dSTotal);
}

HelixPlaneCrossing::PositionType HelixArbitraryPlaneCrossing::position

(

double

s

)

const [virtual]

Position at pathlength s from the starting point.

Implements HelixPlaneCrossing.

Definition at line 116 of file HelixArbitraryPlaneCrossing.cc.

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

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

HelixArbitraryPlaneCrossing::PositionTypeDouble HelixArbitraryPlaneCrossing::positionInDouble

(

double

s

)

const

Position at pathlength s from the starting point.

Definition at line 125 of file HelixArbitraryPlaneCrossing.cc.

References funct::cos(), e, HelixArbitraryPlaneCrossing2Order::positionInDouble(), funct::sin(), theCachedCDPhi, theCachedDPhi, theCachedS, theCachedSDPhi, theCosPhi0, theCosTheta, theQuadraticCrossingFromStart, theRho, theSinPhi0, theSinTheta, theX0, theY0, and theZ0.

Referenced by pathLength(), and position().

                                                             {
  //
  // Calculate delta phi (if not already available)
  //
  if ( s!=theCachedS ) {
    theCachedS = s;
    theCachedDPhi = theCachedS*theRho*theSinTheta;
    theCachedSDPhi = sin(theCachedDPhi);
    theCachedCDPhi = cos(theCachedDPhi);
  }
  //
  // Calculate with appropriate formulation of full helix formula or with 
  //   2nd order approximation.
  //
//    if ( fabs(theCachedDPhi)>1.e-1 ) {
  if ( fabs(theCachedDPhi)>1.e-4 ) {
    // "standard" helix formula
    return PositionTypeDouble(theX0+(-theSinPhi0*(1.-theCachedCDPhi)+theCosPhi0*theCachedSDPhi)/theRho,
                              theY0+(theCosPhi0*(1.-theCachedCDPhi)+theSinPhi0*theCachedSDPhi)/theRho,
                              theZ0+theCachedS*theCosTheta);
    }
//    else if ( fabs(theCachedDPhi)>theNumericalPrecision ) {
//      // full helix formula, but avoiding (1-cos(deltaPhi)) for small angles
//      return PositionTypeDouble(theX0+(-theSinPhi0*theCachedSDPhi*theCachedSDPhi/(1.+theCachedCDPhi)+
//                                   theCosPhi0*theCachedSDPhi)/theRho,
//                            theY0+(theCosPhi0*theCachedSDPhi*theCachedSDPhi/(1.+theCachedCDPhi)+
//                                   theSinPhi0*theCachedSDPhi)/theRho,
//                            theZ0+theCachedS*theCosTheta);
//    }
  else {
    // Use 2nd order.
    return theQuadraticCrossingFromStart.positionInDouble(theCachedS);
  }
}

---

Member Data Documentation

double HelixArbitraryPlaneCrossing::theCachedCDPhi [mutable, private]

Definition at line 67 of file HelixArbitraryPlaneCrossing.h.

Referenced by directionInDouble(), and positionInDouble().

double HelixArbitraryPlaneCrossing::theCachedDPhi [mutable, private]

Definition at line 65 of file HelixArbitraryPlaneCrossing.h.

Referenced by directionInDouble(), and positionInDouble().

double HelixArbitraryPlaneCrossing::theCachedS [mutable, private]

Definition at line 64 of file HelixArbitraryPlaneCrossing.h.

Referenced by directionInDouble(), and positionInDouble().

double HelixArbitraryPlaneCrossing::theCachedSDPhi [mutable, private]

Definition at line 66 of file HelixArbitraryPlaneCrossing.h.

Referenced by directionInDouble(), and positionInDouble().

double HelixArbitraryPlaneCrossing::theCosPhi0 [private]

Definition at line 56 of file HelixArbitraryPlaneCrossing.h.

Referenced by directionInDouble(), HelixArbitraryPlaneCrossing(), pathLength(), and positionInDouble().

double HelixArbitraryPlaneCrossing::theCosTheta [private]

Definition at line 57 of file HelixArbitraryPlaneCrossing.h.

Referenced by directionInDouble(), HelixArbitraryPlaneCrossing(), pathLength(), and positionInDouble().

const float HelixArbitraryPlaneCrossing::theMaxDistToPlane = 1.e-4 [static, private]

Definition at line 70 of file HelixArbitraryPlaneCrossing.h.

Referenced by pathLength().

const float HelixArbitraryPlaneCrossing::theNumericalPrecision = 5.e-7 [static, private]

Definition at line 69 of file HelixArbitraryPlaneCrossing.h.

Referenced by pathLength().

const PropagationDirection HelixArbitraryPlaneCrossing::thePropDir [private]

Definition at line 62 of file HelixArbitraryPlaneCrossing.h.

Referenced by pathLength().

HelixArbitraryPlaneCrossing2Order HelixArbitraryPlaneCrossing::theQuadraticCrossingFromStart [private]

Definition at line 60 of file HelixArbitraryPlaneCrossing.h.

Referenced by directionInDouble(), pathLength(), and positionInDouble().

const double HelixArbitraryPlaneCrossing::theRho [private]

Definition at line 58 of file HelixArbitraryPlaneCrossing.h.

Referenced by directionInDouble(), pathLength(), and positionInDouble().

double HelixArbitraryPlaneCrossing::theSinPhi0 [private]

Definition at line 56 of file HelixArbitraryPlaneCrossing.h.

Referenced by directionInDouble(), HelixArbitraryPlaneCrossing(), pathLength(), and positionInDouble().

double HelixArbitraryPlaneCrossing::theSinTheta [private]

Definition at line 57 of file HelixArbitraryPlaneCrossing.h.

Referenced by directionInDouble(), HelixArbitraryPlaneCrossing(), pathLength(), and positionInDouble().

const double HelixArbitraryPlaneCrossing::theX0 [private]

Definition at line 55 of file HelixArbitraryPlaneCrossing.h.

Referenced by pathLength(), and positionInDouble().

const double HelixArbitraryPlaneCrossing::theY0 [private]

Definition at line 55 of file HelixArbitraryPlaneCrossing.h.

Referenced by pathLength(), and positionInDouble().

const double HelixArbitraryPlaneCrossing::theZ0 [private]

Definition at line 55 of file HelixArbitraryPlaneCrossing.h.

Referenced by pathLength(), and positionInDouble().

---

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

• TrackingTools/GeomPropagators/interface/HelixArbitraryPlaneCrossing.h
• TrackingTools/GeomPropagators/src/HelixArbitraryPlaneCrossing.cc

---