#include <HelixBarrelCylinderCrossing.h>

Public Types
typedef GlobalVector	DirectionType

typedef Basic2DVector< TmpType >	Point

typedef GlobalPoint	PositionType

enum	Solution { bothSol, bestSol, onlyPos }

typedef double	TmpType

typedef Basic2DVector< TmpType >	Vector

Public Member Functions
DirectionType	direction () const

bool	hasSolution () const

	HelixBarrelCylinderCrossing (const GlobalPoint &startingPos, const GlobalVector &startingDir, double rho, PropagationDirection propDir, const Cylinder &cyl, Solution sol=bothSol)

double	pathLength () const

PositionType	position () const

PositionType	position1 () const
	Method to access separately each solution of the helix-cylinder crossing equations. More...

PositionType	position2 () const
	Method to access separately each solution of the helix-cylinder crossing equations. More...

Private Member Functions
std::pair< Vector, int >	chooseSolution (const Point &p1, const Point &p2, const PositionType &startingPos, const DirectionType &startingDir, PropagationDirection propDir)

Private Attributes
DirectionType	theDir

PositionType	thePos

PositionType	thePos1

PositionType	thePos2

double	theS

bool	theSolExists

Detailed Description

Calculates the crossing of a helix with a barrel cylinder.

Definition at line 16 of file HelixBarrelCylinderCrossing.h.

Member Typedef Documentation

◆ DirectionType

typedef GlobalVector HelixBarrelCylinderCrossing::DirectionType

Definition at line 25 of file HelixBarrelCylinderCrossing.h.

◆ Point

typedef Basic2DVector<TmpType> HelixBarrelCylinderCrossing::Point

Definition at line 21 of file HelixBarrelCylinderCrossing.h.

◆ PositionType

typedef GlobalPoint HelixBarrelCylinderCrossing::PositionType

Definition at line 24 of file HelixBarrelCylinderCrossing.h.

◆ TmpType

typedef double HelixBarrelCylinderCrossing::TmpType

Definition at line 20 of file HelixBarrelCylinderCrossing.h.

◆ Vector

typedef Basic2DVector<TmpType> HelixBarrelCylinderCrossing::Vector

Definition at line 22 of file HelixBarrelCylinderCrossing.h.

Member Enumeration Documentation

◆ Solution

enum HelixBarrelCylinderCrossing::Solution

Enumerator
bothSol
bestSol
onlyPos

Definition at line 18 of file HelixBarrelCylinderCrossing.h.

18 { bothSol, bestSol, onlyPos };

Constructor & Destructor Documentation

◆ HelixBarrelCylinderCrossing()

HelixBarrelCylinderCrossing::HelixBarrelCylinderCrossing	(	const GlobalPoint &	startingPos,
		const GlobalVector &	startingDir,
		double	rho,
		PropagationDirection	propDir,
		const Cylinder &	cyl,
		Solution	sol = `bothSol`
	)

Definition at line 17 of file HelixBarrelCylinderCrossing.cc.

                                                                        {
   // assumes the cylinder is centered at 0,0
   double R = cyl.radius();
  
   // protect for zero curvature case
   const double sraightLineCutoff = 1.e-7;
   if (fabs(rho) * R < sraightLineCutoff && fabs(rho) * startingPos.perp() < sraightLineCutoff) {
     // switch to straight line case
     StraightLineCylinderCrossing slc(cyl.toLocal(startingPos), cyl.toLocal(startingDir), propDir);
     std::pair<bool, double> pl = slc.pathLength(cyl);
     if (pl.first) {
       theSolExists = true;
       theS = pl.second;
       thePos = cyl.toGlobal(slc.position(theS));
       theDir = startingDir;
     } else
       theSolExists = false;
     return;  // all needed data members have been set
   }
  
   double R2cyl = R * R;
   double pt = startingDir.perp();
   Point center(startingPos.x() - startingDir.y() / (pt * rho), startingPos.y() + startingDir.x() / (pt * rho));
   double p2 = startingPos.perp2();
   bool solveForX;
   double B, C, E, F;
   if (fabs(center.x()) > fabs(center.y())) {
     solveForX = false;
     E = (R2cyl - p2) / (2. * center.x());
     F = center.y() / center.x();
     B = 2. * (startingPos.y() - F * startingPos.x() - E * F);
     C = 2. * E * startingPos.x() + E * E + p2 - R2cyl;
   } else {
     solveForX = true;
     E = (R2cyl - p2) / (2. * center.y());
     F = center.x() / center.y();
     B = 2. * (startingPos.x() - F * startingPos.y() - E * F);
     C = 2. * E * startingPos.y() + E * E + p2 - R2cyl;
   }
  
   RealQuadEquation eq(1 + F * F, B, C);
   if (!eq.hasSolution) {
     theSolExists = false;
     return;
   }
  
   Vector d1, d2;
   ;
   if (solveForX) {
     d1 = Point(eq.first, E - F * eq.first);
     d2 = Point(eq.second, E - F * eq.second);
   } else {
     d1 = Point(E - F * eq.first, eq.first);
     d2 = Point(E - F * eq.second, eq.second);
   }
  
   Vector theD;
   int theActualDir;
  
   std::tie(theD, theActualDir) = chooseSolution(d1, d2, startingPos, startingDir, propDir);
   if (!theSolExists)
     return;
  
   float ipabs = 1.f / startingDir.mag();
   float sinTheta = float(pt) * ipabs;
   float cosTheta = startingDir.z() * ipabs;
  
   // -------
  
   auto dMag = theD.mag();
   float tmp = 0.5f * float(dMag * rho);
   if (std::abs(tmp) > 1.f)
     tmp = std::copysign(1.f, tmp);
   theS = theActualDir * 2.f * std::asin(tmp) / (float(rho) * sinTheta);
   thePos = GlobalPoint(startingPos.x() + theD.x(), startingPos.y() + theD.y(), startingPos.z() + theS * cosTheta);
  
   if (sol == onlyPos)
     return;
  
   if (theS < 0)
     tmp = -tmp;
   auto sinPhi = 2.f * tmp * sqrt(1.f - tmp * tmp);
   auto cosPhi = 1.f - 2.f * tmp * tmp;
   theDir = DirectionType(startingDir.x() * cosPhi - startingDir.y() * sinPhi,
                          startingDir.x() * sinPhi + startingDir.y() * cosPhi,
                          startingDir.z());
  
   if (sol != bothSol)
     return;
  
   //-----  BM
   //double momProj1 = startingDir.x()*d1.x() + startingDir.y()*d1.y();
   //double momProj2 = startingDir.x()*d2.x() + startingDir.y()*d2.y();
  
   int theActualDir1 = propDir == alongMomentum ? 1 : -1;
   int theActualDir2 = propDir == alongMomentum ? 1 : -1;
  
   auto dMag1 = d1.mag();
   auto tmp1 = 0.5f * dMag1 * float(rho);
   if (std::abs(tmp1) > 1.f)
     tmp1 = std::copysign(1.f, tmp1);
   auto theS1 = theActualDir1 * 2.f * std::asin(tmp1) / (rho * sinTheta);
   thePos1 = GlobalPoint(startingPos.x() + d1.x(), startingPos.y() + d1.y(), startingPos.z() + theS1 * cosTheta);
  
   auto dMag2 = d2.mag();
   auto tmp2 = 0.5f * dMag2 * float(rho);
   if (std::abs(tmp2) > 1.f)
     tmp2 = std::copysign(1.f, tmp2);
   auto theS2 = theActualDir2 * 2.f * std::asin(tmp2) / (float(rho) * sinTheta);
   thePos2 = GlobalPoint(startingPos.x() + d2.x(), startingPos.y() + d2.y(), startingPos.z() + theS2 * cosTheta);
 }

References funct::abs(), alongMomentum, TtFullHadDaughter::B, bothSol, gen::C, chooseSolution(), d1, edm::eq(), f, F(), dqmMemoryStats::float, PV3DBase< T, PVType, FrameType >::mag(), Basic2DVector< T >::mag(), onlyPos, p2, StraightLineCylinderCrossing::pathLength(), PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::perp2(), DiDispStaMuonMonitor_cfi::pt, dttmaxenums::R, Cylinder::radius(), rho, mathSSE::sqrt(), theDir, thePos, thePos1, thePos2, theS, theSolExists, createJobs::tmp, Surface::toGlobal(), GloballyPositioned< T >::toLocal(), PV3DBase< T, PVType, FrameType >::x(), Basic2DVector< T >::x(), PV3DBase< T, PVType, FrameType >::y(), Basic2DVector< T >::y(), and PV3DBase< T, PVType, FrameType >::z().

Member Function Documentation

◆ chooseSolution()

std::pair< HelixBarrelCylinderCrossing::Vector, int > HelixBarrelCylinderCrossing::chooseSolution	(	const Point &	p1,
		const Point &	p2,
		const PositionType &	startingPos,
		const DirectionType &	startingDir,
		PropagationDirection	propDir
	)

private

Definition at line 134 of file HelixBarrelCylinderCrossing.cc.

                                   {
   Vector theD;
   int theActualDir;
  
   auto momProj1 = startingDir.x() * d1.x() + startingDir.y() * d1.y();
   auto momProj2 = startingDir.x() * d2.x() + startingDir.y() * d2.y();
  
   if (propDir == anyDirection) {
     theSolExists = true;
     if (d1.mag2() < d2.mag2()) {
       theD = d1;
       theActualDir = (momProj1 > 0) ? 1 : -1;
     } else {
       theD = d2;
       theActualDir = (momProj2 > 0) ? 1 : -1;
     }
   } else {
     int propSign = propDir == alongMomentum ? 1 : -1;
     if (momProj1 * momProj2 < 0) {
       // if different signs return the positive one
       theSolExists = true;
       theD = (momProj1 * propSign > 0) ? d1 : d2;
       theActualDir = propSign;
     } else if (momProj1 * propSign > 0) {
       // if both positive, return the shortest
       theSolExists = true;
       theD = (d1.mag2() < d2.mag2()) ? d1 : d2;
       theActualDir = propSign;
     } else
       theSolExists = false;
   }
  
   return std::pair<Vector, int>(theD, theActualDir);
 }

References alongMomentum, anyDirection, d1, Basic2DVector< T >::mag2(), theSolExists, PV3DBase< T, PVType, FrameType >::x(), Basic2DVector< T >::x(), PV3DBase< T, PVType, FrameType >::y(), and Basic2DVector< T >::y().

Referenced by HelixBarrelCylinderCrossing().

◆ direction()

DirectionType HelixBarrelCylinderCrossing::direction ( ) const

inline

Returns the direction along the helix that corresponds to path length "s" from the starting point. As for position, the direction of the crossing with a cylinder (if it exists!) is given by direction( pathLength( cylinder)).

Definition at line 61 of file HelixBarrelCylinderCrossing.h.

61 { return theDir; }

References theDir.

Referenced by TIBRing::computeCrossings().

◆ hasSolution()

bool HelixBarrelCylinderCrossing::hasSolution ( ) const

inline

Definition at line 34 of file HelixBarrelCylinderCrossing.h.

34 { return theSolExists; }

References theSolExists.

Referenced by TBLayer::computeCrossings(), and TIBRing::computeCrossings().

◆ pathLength()

double HelixBarrelCylinderCrossing::pathLength ( ) const

inline

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

Definition at line 40 of file HelixBarrelCylinderCrossing.h.

40 { return theS; }

References theS.

◆ position()

PositionType HelixBarrelCylinderCrossing::position ( ) const

inline

Returns the position along the helix that corresponds to path length "s" from the starting point. If s is obtained from the pathLength method the position is the destination point, i.e. the position of the crossing with a cylinder (if it exists!) is given by position( pathLength( cylinder)).

Definition at line 48 of file HelixBarrelCylinderCrossing.h.

48 { return thePos; }

References thePos.

Referenced by TBLayer::computeCrossings(), and TIBRing::computeCrossings().