AnalyticalPropagator.cc

Go to the documentation of this file.

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

#include "DataFormats/GeometrySurface/interface/Cylinder.h"
#include "DataFormats/GeometrySurface/interface/TangentPlane.h"
#include "DataFormats/GeometrySurface/interface/Plane.h"

#include "MagneticField/Engine/interface/MagneticField.h"

#include "TrackingTools/GeomPropagators/interface/PropagationExceptions.h"
#include "TrackingTools/GeomPropagators/interface/StraightLinePlaneCrossing.h"
#include "TrackingTools/GeomPropagators/interface/StraightLineBarrelCylinderCrossing.h"
#include "TrackingTools/GeomPropagators/interface/OptimalHelixPlaneCrossing.h"
#include "TrackingTools/GeomPropagators/interface/HelixBarrelCylinderCrossing.h"
#include "TrackingTools/AnalyticalJacobians/interface/AnalyticalCurvilinearJacobian.h"
#include "TrackingTools/GeomPropagators/interface/PropagationDirectionFromPath.h"
#include "TrackingTools/TrajectoryState/interface/SurfaceSideDefinition.h"
#include "TrackingTools/GeomPropagators/interface/PropagationExceptions.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include <cmath>

using namespace SurfaceSideDefinition;

std::pair<TrajectoryStateOnSurface,double>
AnalyticalPropagator::propagateWithPath(const FreeTrajectoryState& fts, 
                    const Plane& plane) const
{
  // check curvature
  float rho = fts.transverseCurvature();
  
  // propagate parameters
  GlobalPoint x;
  GlobalVector p;
  double s;
  
  // check if already on plane
  if likely (plane.localZclamped(fts.position()) !=0)  {
      // propagate
      bool parametersOK = this->propagateParametersOnPlane(fts, plane, x, p, s);
      // check status and deltaPhi limit
      float dphi2 = float(s)*rho;
      dphi2 = dphi2*dphi2*fts.momentum().perp2();
      if unlikely( !parametersOK || dphi2>theMaxDPhi2*fts.momentum().mag2() )  return TsosWP(TrajectoryStateOnSurface(),0.);
    }
  else {
    LogDebug("AnalyticalPropagator")<<"not going anywhere. Already on surface.\n"
                    <<"plane.localZ(fts.position()): "<<plane.localZ(fts.position())<<"\n"
                    <<"plane.position().mag(): "<<plane.position().mag() <<"\n"
                    <<"plane.posPrec: "<<plane.posPrec();
    x = fts.position();
    p = fts.momentum();
    s = 0;
  }
  //
  // Compute propagated state and check change in curvature
  //
  GlobalTrajectoryParameters gtp(x,p,fts.charge(),theField);
  if unlikely(std::abs(gtp.transverseCurvature()-rho)>theMaxDBzRatio*std::abs(rho) ) 
    return TsosWP(TrajectoryStateOnSurface(),0.);
  //
  // construct TrajectoryStateOnSurface
  //
  return propagatedStateWithPath(fts,plane,gtp,s);
}


std::pair<TrajectoryStateOnSurface,double>
AnalyticalPropagator::propagateWithPath(const FreeTrajectoryState& fts, 
                    const Cylinder& cylinder) const
{
  // check curvature
  auto rho = fts.transverseCurvature();

  // propagate parameters
  GlobalPoint x;
  GlobalVector p;
  double s = 0;

  bool parametersOK = this->propagateParametersOnCylinder(fts, cylinder, x, p, s);
  // check status and deltaPhi limit
  float dphi2 = s*rho;
  dphi2 = dphi2*dphi2*fts.momentum().perp2();
  if unlikely( !parametersOK || dphi2>theMaxDPhi2*fts.momentum().mag2() )  return TsosWP(TrajectoryStateOnSurface(),0.);
  //
  // Compute propagated state and check change in curvature
  //
  GlobalTrajectoryParameters gtp(x,p,fts.charge(),theField);
  if unlikely( std::abs(gtp.transverseCurvature()-rho)>theMaxDBzRatio*std::abs(rho) ) 
    return TsosWP(TrajectoryStateOnSurface(),0.);
  //
  // create result TSOS on TangentPlane (local parameters & errors are better defined)
  //

  //try {
    ConstReferenceCountingPointer<TangentPlane> plane(cylinder.tangentPlane(x));  // need to be here until tsos is created!
    return propagatedStateWithPath(fts,*plane,gtp,s);
  /*
  } catch(...) {
    std::cout << "wrong tangent to cylinder " << x 
              << " pos, rad " << cylinder.position() << " " << cylinder.radius()
              << std::endl;
    return TsosWP(TrajectoryStateOnSurface(),0.);
  }
  */
}

std::pair<TrajectoryStateOnSurface,double>
AnalyticalPropagator::propagatedStateWithPath (const FreeTrajectoryState& fts, 
                           const Surface& surface, 
                           const GlobalTrajectoryParameters& gtp, 
                           const double& s) const
{
  //
  // for forward propagation: state is before surface,
  // for backward propagation: state is after surface
  //
  SurfaceSide side = PropagationDirectionFromPath()(s,propagationDirection())==alongMomentum 
    ? beforeSurface : afterSurface;
  // 
  //
  // error propagation (if needed) and conversion to a TrajectoryStateOnSurface
  //
  if (fts.hasError()) {
    //
    // compute jacobian
    //
    AnalyticalCurvilinearJacobian analyticalJacobian(fts.parameters(), gtp.position(), gtp.momentum(), s);
    const AlgebraicMatrix55 &jacobian = analyticalJacobian.jacobian();
    // CurvilinearTrajectoryError cte(ROOT::Math::Similarity(jacobian, fts.curvilinearError().matrix()));
    return TsosWP(TrajectoryStateOnSurface(gtp,
                       ROOT::Math::Similarity(jacobian, fts.curvilinearError().matrix()),
                       surface,side),s);
  }
  else {
    //
    // return state without errors
    //
    return TsosWP(TrajectoryStateOnSurface(gtp,surface,side),s);
  }
}

bool AnalyticalPropagator::propagateParametersOnCylinder(
  const FreeTrajectoryState& fts, const Cylinder& cylinder, 
  GlobalPoint& x, GlobalVector& p, double& s) const
{

  GlobalPoint const & sp = cylinder.position();
  if unlikely(sp.x()!=0. || sp.y()!=0.) {
    throw PropagationException("Cannot propagate to an arbitrary cylinder");
  }
  // preset output
  x = fts.position();
  p = fts.momentum();
  s = 0;
  // (transverse) curvature
  auto rho = fts.transverseCurvature();
  //
  // Straight line approximation? |rho|<1.e-10 equivalent to ~ 1um 
  // difference in transversal position at 10m.
  //
  if unlikely( std::abs(rho)<1.e-10f )
    return propagateWithLineCrossing(fts.position(),p,cylinder,x,s);
  //
  // Helix case
  //
  // check for possible intersection
  constexpr float tolerance = 1.e-4; // 1 micron distance
  auto rdiff = x.perp() - cylinder.radius();
  if ( std::abs(rdiff) < tolerance )  return true;
  //
  // Instantiate HelixBarrelCylinderCrossing and get solutions
  //
  HelixBarrelCylinderCrossing cylinderCrossing(fts.position(),fts.momentum(),rho,
                           propagationDirection(),cylinder);
  if unlikely( !cylinderCrossing.hasSolution() )  return false;
  // path length
  s = cylinderCrossing.pathLength();
  // point
  x = cylinderCrossing.position();
  // direction (renormalised)
  p = cylinderCrossing.direction().unit()*fts.momentum().mag();
  return true;
}
  
bool 
AnalyticalPropagator::propagateParametersOnPlane(const FreeTrajectoryState& fts, 
                         const Plane& plane, 
                         GlobalPoint& x, 
                         GlobalVector& p, 
                         double& s) const
{
  // initialisation of position, momentum and path length
  x = fts.position();
  p = fts.momentum();
  s = 0;
  // (transverse) curvature
  auto rho = fts.transverseCurvature();
  //
  // Straight line approximation? |rho|<1.e-10 equivalent to ~ 1um 
  // difference in transversal position at 10m.
  //
  if unlikely( std::abs(rho)<1.e-10f )
    return propagateWithLineCrossing(fts.position(),p,plane,x,s);
  //
  // Helix case 
  //

  //
  // Frame-independant point and vector are created explicitely to 
  // avoid confusing gcc (refuses to compile with temporary objects
  // in the constructor).
  //
  HelixPlaneCrossing::PositionType helixPos(x);
  HelixPlaneCrossing::DirectionType helixDir(p);
  if likely(isOldPropagationType) {
      OptimalHelixPlaneCrossing planeCrossing(plane,helixPos,helixDir,rho,propagationDirection());
      return propagateWithHelixCrossing(*planeCrossing,plane,fts.momentum().mag(),x,p,s);
    }




  //--- Alternative implementation to be used for the propagation of the parameters  of looping
  //    particles that cross twice the (infinite) surface of the plane. It is not trivial to determine
  //    which of the two intersections has to be returned.
  
  //---- FIXME: WHAT FOLLOWS HAS TO BE REWRITTEN IN A CLEANER (AND CPU-OPTIMIZED) WAY ---------
  LogDebug("AnalyticalPropagator") << "In AnaliticalProp, calling HAPC " << "\n"
                   << "plane is centered in xyz: " 
                   << plane.position().x() << " , "
                   << plane.position().y() << " , " 
                   << plane.position().z() << "\n";
  
  
  GlobalPoint gp1 = fts.position();
  GlobalVector gm1 = fts.momentum();
  double s1 = 0;
  double rho1 = fts.transverseCurvature();
  HelixPlaneCrossing::PositionType helixPos1(gp1);
  HelixPlaneCrossing::DirectionType helixDir1(gm1);
  LogDebug("AnalyticalPropagator") << "gp1 before calling planeCrossing1: " << gp1 << "\n";
  OptimalHelixPlaneCrossing planeCrossing1(plane,helixPos1,helixDir1,rho1,propagationDirection());
  
  HelixPlaneCrossing::PositionType xGen;
  HelixPlaneCrossing::DirectionType pGen;
      
  double tolerance(0.0050);
  if(propagationDirection()==oppositeToMomentum)
    tolerance *=-1;
  
  bool check1 = propagateWithHelixCrossing(*planeCrossing1,plane,fts.momentum().mag(),gp1,gm1,s1);
  double dphi1 = fabs(fts.momentum().phi()-gm1.phi());
  LogDebug("AnalyticalPropagator") << "check1, s1, dphi, gp1: " 
                   << check1 << " , "
                   << s1 << " , " 
                   << dphi1 << " , "
                   << gp1 << "\n";
  
  //move forward a bit to avoid that the propagator doesn't propagate because the state is already on surface.
  //we want to go to the other point of intersection between the helix and the plane
  xGen = (*planeCrossing1).position(s1+tolerance);
  pGen = (*planeCrossing1).direction(s1+tolerance);
  
  /*
    if(!check1 || s1>170 ){
    //PropagationDirection newDir = (propagationDirection() == alongMomentum) ? oppositeToMomentum : alongMomentum;
    PropagationDirection newDir = anyDirection;
    HelixArbitraryPlaneCrossing  planeCrossing1B(helixPos1,helixDir1,rho1,newDir);
    check1 = propagateWithHelixCrossing(planeCrossing1B,plane,fts.momentum().mag(),gp1,gm1,s1);
    LogDebug("AnalyticalPropagator") << "after second attempt, check1, s1,gp1: "
    << check1 << " , "
    << s1 << " , " << gp1 << "\n";
    
    xGen = planeCrossing1B.position(s1+tolerance);
    pGen = planeCrossing1B.direction(s1+tolerance);
    }
      */
  
  if(!check1){
    LogDebug("AnalyticalPropagator") << "failed also second attempt. No idea what to do, then bailout" << "\n";
  }
  
  
  pGen *= gm1.mag()/pGen.mag();
  GlobalPoint gp2(xGen);
  GlobalVector gm2(pGen);
  double s2 = 0;
  double rho2 = rho1;
  HelixPlaneCrossing::PositionType helixPos2(gp2);
  HelixPlaneCrossing::DirectionType helixDir2(gm2);
  OptimalHelixPlaneCrossing planeCrossing2(plane,helixPos2,helixDir2,rho2,propagationDirection());
  
  bool check2 = propagateWithHelixCrossing(*planeCrossing2,plane,gm2.mag(),gp2,gm2,s2);
  
  if(!check2){
    x = gp1;
    p = gm1;
    s = s1;
    return check1;
  }
  
  if(!check1){
    edm::LogError("AnalyticalPropagator") << "LOGIC ERROR: I should not have entered here!" << "\n";
    return false;
  }
  
  
  LogDebug("AnalyticalPropagator")  << "check2, s2, gp2: " 
                    << check2 << " , "
                    << s2 << " , " << gp2 << "\n";
  
  
  double dist1 = (plane.position()-gp1).perp();
  double dist2 = (plane.position()-gp2).perp();
  
  
  LogDebug("AnalyticalPropagator") << "propDir, dist1, dist2: " 
                   << propagationDirection() << " , "
                   << dist1 << " , " 
                   << dist2 << "\n";
  
  //If there are two solutions, the one which is the closest to the module's center is chosen
  if(dist1<2*dist2){
    x = gp1;
    p = gm1;
    s = s1;
    return check1;
  }else if(dist2<2*dist1){
    x = gp2;
    p = gm2;
    s = s1+s2+tolerance;
    return check2;
  }else{
    if(fabs(s1)<fabs(s2)){
      x = gp1;
      p = gm1;
      s = s1;
      return check1;
    }else{
      x = gp2;
      p = gm2;
      s = s1+s2+tolerance;
      return check2;
    }   
  }
  
  //-------- END of ugly piece of code  ---------------
  
}

bool
AnalyticalPropagator::propagateWithLineCrossing (const GlobalPoint& x0, 
                         const GlobalVector& p0,
                         const Plane& plane,
                         GlobalPoint& x, double& s) const {
  //
  // Instantiate auxiliary object for finding intersection.
  // Frame-independant point and vector are created explicitely to 
  // avoid confusing gcc (refuses to compile with temporary objects
  // in the constructor).
  //
  StraightLinePlaneCrossing::PositionType pos(x0);
  StraightLinePlaneCrossing::DirectionType dir(p0);
  StraightLinePlaneCrossing planeCrossing(pos,dir,propagationDirection());
  //
  // get solution
  //
  std::pair<bool,double> propResult = planeCrossing.pathLength(plane);
  if ( !propResult.first )  return false;
  s = propResult.second;
  // point (reconverted to GlobalPoint)
  x = GlobalPoint(planeCrossing.position(s));
  //
  return true;
}

bool
AnalyticalPropagator::propagateWithLineCrossing (const GlobalPoint& x0, 
                         const GlobalVector& p0,
                         const Cylinder& cylinder,
                         GlobalPoint& x, double& s) const {
  //
  // Instantiate auxiliary object for finding intersection.
  // Frame-independant point and vector are created explicitely to 
  // avoid confusing gcc (refuses to compile with temporary objects
  // in the constructor).
  //
  StraightLineBarrelCylinderCrossing cylCrossing(x0,p0,propagationDirection());
  //
  // get solution
  //
  std::pair<bool,double> propResult = cylCrossing.pathLength(cylinder);
  if ( !propResult.first )  return false;
  s = propResult.second;
  // point (reconverted to GlobalPoint)
  x = cylCrossing.position(s);
  //
  return true;
}

bool
AnalyticalPropagator::propagateWithHelixCrossing (HelixPlaneCrossing& planeCrossing,
                          const Plane& plane,
                          const float pmag,
                          GlobalPoint& x,
                          GlobalVector& p,
                          double& s) const {
  // get solution
  std::pair<bool,double> propResult = planeCrossing.pathLength(plane);
  if unlikely( !propResult.first )  return false;

  s = propResult.second;
  x = GlobalPoint(planeCrossing.position(s));
  // direction (reconverted to GlobalVector, renormalised)
  GlobalVector pGen =  GlobalVector(planeCrossing.direction(s));
  pGen *= pmag/pGen.mag();
  p = pGen;
  //
  return true;
}