HelixBarrelCylinderCrossing Class Reference

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

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

References funct::abs(), alongMomentum, B, bothSol, correctionTermsCaloMet_cff::C, chooseSolution(), l1tSlwPFPuppiJets_cfi::cosPhi, d1, F(), f, RealQuadEquation::first, dqmMemoryStats::float, RealQuadEquation::hasSolution, PV3DBase< T, PVType, FrameType >::mag(), Basic2DVector< T >::mag(), onlyPos, SiStripOfflineCRack_cfg::p2, StraightLineCylinderCrossing::pathLength(), PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::perp2(), DiDispStaMuonMonitor_cfi::pt, dttmaxenums::R, Cylinder::radius(), rho, RealQuadEquation::second, l1tSlwPFPuppiJets_cfi::sinPhi, mkfit::Const::sol, 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().

                                                                       {
  // 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);
}

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.

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

Referenced by HelixBarrelCylinderCrossing().

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

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.

References theDir.

Referenced by TIBRing::computeCrossings().

{ return theDir; }

hasSolution()

bool HelixBarrelCylinderCrossing::hasSolution ( ) const

inline

Definition at line 34 of file HelixBarrelCylinderCrossing.h.

References theSolExists.

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

{ return theSolExists; }

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.

References theS.

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

References thePos.

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

{ return thePos; }

position1()

PositionType HelixBarrelCylinderCrossing::position1 ( ) const

inline

Method to access separately each solution of the helix-cylinder crossing equations.

Definition at line 51 of file HelixBarrelCylinderCrossing.h.

References thePos1.

{ return thePos1; }

position2()

PositionType HelixBarrelCylinderCrossing::position2 ( ) const

inline

Method to access separately each solution of the helix-cylinder crossing equations.

Definition at line 54 of file HelixBarrelCylinderCrossing.h.

References thePos2.

{ return thePos2; }

Member Data Documentation

theDir

DirectionType HelixBarrelCylinderCrossing::theDir

private

Definition at line 65 of file HelixBarrelCylinderCrossing.h.

Referenced by direction(), and HelixBarrelCylinderCrossing().

thePos

PositionType HelixBarrelCylinderCrossing::thePos

private

Definition at line 64 of file HelixBarrelCylinderCrossing.h.

Referenced by HelixBarrelCylinderCrossing(), and position().

thePos1

PositionType HelixBarrelCylinderCrossing::thePos1

private

Definition at line 69 of file HelixBarrelCylinderCrossing.h.

Referenced by HelixBarrelCylinderCrossing(), and position1().

thePos2

PositionType HelixBarrelCylinderCrossing::thePos2

private

Definition at line 70 of file HelixBarrelCylinderCrossing.h.

Referenced by HelixBarrelCylinderCrossing(), and position2().

theS

double HelixBarrelCylinderCrossing::theS

private

Definition at line 66 of file HelixBarrelCylinderCrossing.h.

Referenced by HelixBarrelCylinderCrossing(), and pathLength().

theSolExists

bool HelixBarrelCylinderCrossing::theSolExists

private

Definition at line 67 of file HelixBarrelCylinderCrossing.h.

Referenced by chooseSolution(), hasSolution(), and HelixBarrelCylinderCrossing().