CMSSW_4_4_3_patch1/src/TrackingTools/GeomPropagators/src/StraightLineCylinderCrossing.cc

Go to the documentation of this file.

#include "TrackingTools/GeomPropagators/interface/StraightLineCylinderCrossing.h"

#include "DataFormats/GeometrySurface/interface/Cylinder.h"
#include "TrackingTools/GeomPropagators/src/RealQuadEquation.h"

#include <cmath>
#include <iostream>
using namespace std;

StraightLineCylinderCrossing::
StraightLineCylinderCrossing( const LocalPoint& startingPos, const LocalVector& startingDir,
                              const PropagationDirection propDir, double tolerance) :
  theX0(startingPos),
  theP0(startingDir.unit()),
  thePropDir(propDir), 
  theTolerance(tolerance) {}

std::pair<bool,double>
StraightLineCylinderCrossing::pathLength (const Cylinder& cylinder) const
{
  //
  // radius of cylinder and transversal position relative to axis
  //
  double R(cylinder.radius());
  PositionType2D xt2d(theX0.x(),theX0.y());
  //
  // transverse direction
  // 
  DirectionType2D pt2d(theP0.x(),theP0.y());
  //
  // solution of quadratic equation for s - assume |theP0|=1
  //
  RealQuadEquation eq(pt2d.mag2(),2.*xt2d.dot(pt2d),xt2d.mag2()-R*R);
  if ( !eq.hasSolution ) {
    /*
    double A=   pt2d.mag2(); 
    double B=   2.*xt2d.dot(pt2d);
    double C=   xt2d.mag2()-R*R;
    cout << "A= " << pt2d.mag2() 
         << " B= " << 2.*xt2d.dot(pt2d)
         << " C= " << xt2d.mag2()-R*R
         << " D= " << B*B - 4*A*C
         << endl;
    */
    return std::pair<bool,double>(false,0.);
  }
  //
  // choice of solution and verification of direction
  //
  return chooseSolution(eq.first,eq.second);
}

std::pair<bool,double>
StraightLineCylinderCrossing::chooseSolution (const double s1, 
                                              const double s2) const
{
  //
  // follows the logic implemented in HelixBarrelCylinderCrossing
  //
  if ( thePropDir==anyDirection ) {
    return std::pair<bool,double>(true,(fabs(s1)<fabs(s2)?s1:s2));
  }
  else {
    int propSign = thePropDir==alongMomentum ? 1 : -1;
    if ( s1*s2 < 0) {
      // if different signs return the positive one
      return std::pair<bool,double>(true,((s1*propSign>0)?s1:s2));
    }
    else if ( s1*propSign>0 ) {
      // if both positive, return the shortest
      return std::pair<bool,double>(true,(fabs(s1)<fabs(s2)?s1:s2));
    }
    else {
      // if both negative, check if the smaller (abs value) is smaller then tolerance
      double shorter = std::min( fabs(s1), fabs(s2));
      if (shorter < theTolerance) return std::pair<bool,double>(true,0);
      else                        return std::pair<bool,double>(false,0.);
    }
  }
}