AnalyticalPropagator Class Reference

#include <AnalyticalPropagator.h>

Inheritance diagram for AnalyticalPropagator:

Public Member Functions
	AnalyticalPropagator (const MagneticField *field, PropagationDirection dir=alongMomentum, float maxDPhi=1.6, bool isOld=true)
AnalyticalPropagator *	clone () const override
bool	setMaxDirectionChange (float phiMax) override
void	setMaxRelativeChangeInBz (const float maxDBz)
	~AnalyticalPropagator () override
Public Member Functions inherited from Propagator
template<typename STA , typename SUR >
TrajectoryStateOnSurface	propagate (STA const &state, SUR const &surface) const
virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const final
virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest1, const GlobalPoint &pDest2) const final
virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const reco::BeamSpot &beamSpot) const final
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Surface &) const final
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) const final
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Plane &sur) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Cylinder &sur) const
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest1, const GlobalPoint &pDest2) const
	Propagate to PCA to a line (given by 2 points) given a starting point. More...
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const reco::BeamSpot &beamSpot) const
	Propagate to PCA to a line (given by beamSpot position and slope) given a starting point. More...
virtual PropagationDirection	propagationDirection () const final
	Propagator (PropagationDirection dir=alongMomentum)
virtual void	setPropagationDirection (PropagationDirection dir)
virtual	~Propagator ()

Private Types
typedef std::pair< TrajectoryStateOnSurface, double >	TsosWP

Private Member Functions
const MagneticField *	magneticField () const override
std::pair< TrajectoryStateOnSurface, double >	propagatedStateWithPath (const FreeTrajectoryState &fts, const Surface &surface, const GlobalTrajectoryParameters &gtp, const double &s) const
	propagation of errors (if needed) and generation of a new TSOS More...
bool	propagateParametersOnCylinder (const FreeTrajectoryState &fts, const Cylinder &cylinder, GlobalPoint &x, GlobalVector &p, double &s) const
	parameter propagation to cylinder (returns position, momentum and path length) More...
bool	propagateParametersOnPlane (const FreeTrajectoryState &fts, const Plane &plane, GlobalPoint &x, GlobalVector &p, double &s) const
	parameter propagation to plane (returns position, momentum and path length) More...
bool	propagateWithHelixCrossing (HelixPlaneCrossing &, const Plane &, const float, GlobalPoint &, GlobalVector &, double &s) const
	helix parameter propagation to a plane using HelixPlaneCrossing More...
bool	propagateWithLineCrossing (const GlobalPoint &, const GlobalVector &, const Plane &, GlobalPoint &, double &) const
	straight line parameter propagation to a plane More...
bool	propagateWithLineCrossing (const GlobalPoint &, const GlobalVector &, const Cylinder &, GlobalPoint &, double &) const
	straight line parameter propagation to a cylinder More...
std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &fts, const Plane &plane) const override
	propagation to plane with path length More...
std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &fts, const Cylinder &cylinder) const override
	propagation to cylinder with path length More...

Private Attributes
bool	isOldPropagationType
const MagneticField *	theField
float	theMaxDBzRatio
float	theMaxDPhi2

Detailed Description

(Mostly) analytical helix propagation to cylindrical or planar surfaces. Based on GtfGeometricalPropagator with successive replacement of components (currently: propagation to arbitrary plane).

Definition at line 22 of file AnalyticalPropagator.h.

Member Typedef Documentation

typedef std::pair<TrajectoryStateOnSurface, double> AnalyticalPropagator::TsosWP

private

Definition at line 106 of file AnalyticalPropagator.h.

Constructor & Destructor Documentation

AnalyticalPropagator::AnalyticalPropagator ( const MagneticField *  field, PropagationDirection  dir = alongMomentum, float  maxDPhi = 1.6, bool  isOld = true  )

inline

Definition at line 24 of file AnalyticalPropagator.h.

Referenced by clone().

      : Propagator(dir),
        theMaxDPhi2(maxDPhi * maxDPhi),
        theMaxDBzRatio(0.5),
        theField(field),
        isOldPropagationType(isOld) {}

AnalyticalPropagator::~AnalyticalPropagator ( )

inlineoverride

Definition at line 34 of file AnalyticalPropagator.h.

References Propagator::propagate(), propagateWithPath(), and Propagator::propagateWithPath().

{}

Member Function Documentation

AnalyticalPropagator* AnalyticalPropagator::clone ( void  ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 64 of file AnalyticalPropagator.h.

References AnalyticalPropagator().

{ return new AnalyticalPropagator(*this); }

const MagneticField* AnalyticalPropagator::magneticField ( ) const

inlineoverrideprivatevirtual

Implements Propagator.

Definition at line 103 of file AnalyticalPropagator.h.

References theField.

{ return theField; }

std::pair< TrajectoryStateOnSurface, double > AnalyticalPropagator::propagatedStateWithPath ( const FreeTrajectoryState &  fts, const Surface &  surface, const GlobalTrajectoryParameters &  gtp, const double &  s  ) const

private

propagation of errors (if needed) and generation of a new TSOS

Definition at line 112 of file AnalyticalPropagator.cc.

References SurfaceSideDefinition::afterSurface, alongMomentum, SurfaceSideDefinition::beforeSurface, FreeTrajectoryState::curvilinearError(), FreeTrajectoryState::hasError(), AnalyticalCurvilinearJacobian::jacobian(), CurvilinearTrajectoryError::matrix(), GlobalTrajectoryParameters::momentum(), FreeTrajectoryState::parameters(), GlobalTrajectoryParameters::position(), and alignCSCRings::s.

Referenced by setMaxRelativeChangeInBz().

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

private

parameter propagation to cylinder (returns position, momentum and path length)

Definition at line 145 of file AnalyticalPropagator.cc.

References funct::abs(), constexpr, MillePedeFileConverter_cfg::e, f, PV3DBase< T, PVType, FrameType >::mag(), FreeTrajectoryState::momentum(), AlCaHLTBitMon_ParallelJobs::p, GloballyPositioned< T >::position(), FreeTrajectoryState::position(), alignCSCRings::s, tolerance, FreeTrajectoryState::transverseCurvature(), Vector3DBase< T, FrameTag >::unit(), UNLIKELY, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by setMaxRelativeChangeInBz().

                                                                                                                {
  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

private

parameter propagation to plane (returns position, momentum and path length)

Definition at line 186 of file AnalyticalPropagator.cc.

References funct::abs(), DeadROC_duringRun::dir, MillePedeFileConverter_cfg::e, f, LIKELY, LogDebug, PV3DBase< T, PVType, FrameType >::mag(), Basic3DVector< T >::mag(), FreeTrajectoryState::momentum(), oppositeToMomentum, AlCaHLTBitMon_ParallelJobs::p, StraightLineBarrelCylinderCrossing::pathLength(), StraightLinePlaneCrossing::pathLength(), perp(), PV3DBase< T, PVType, FrameType >::phi(), StraightLineBarrelCylinderCrossing::position(), StraightLinePlaneCrossing::position(), FreeTrajectoryState::position(), propagateWithLineCrossing(), alignCSCRings::s, indexGen::s2, tolerance, FreeTrajectoryState::transverseCurvature(), and UNLIKELY.

Referenced by setMaxRelativeChangeInBz().

                                                                                                          {
  // 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::propagateWithHelixCrossing ( HelixPlaneCrossing &  planeCrossing, const Plane &  plane, const float  pmag, GlobalPoint &  x, GlobalVector &  p, double &  s  ) const

private

helix parameter propagation to a plane using HelixPlaneCrossing

Definition at line 380 of file AnalyticalPropagator.cc.

References HelixPlaneCrossing::direction(), PV3DBase< T, PVType, FrameType >::mag(), HelixPlaneCrossing::pathLength(), HelixPlaneCrossing::position(), and UNLIKELY.

Referenced by setMaxRelativeChangeInBz().

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

bool AnalyticalPropagator::propagateWithLineCrossing ( const GlobalPoint &  , const GlobalVector &  , const Plane &  , GlobalPoint &  , double &    ) const

private

straight line parameter propagation to a plane

Referenced by propagateParametersOnPlane(), and setMaxRelativeChangeInBz().

bool AnalyticalPropagator::propagateWithLineCrossing ( const GlobalPoint &  , const GlobalVector &  , const Cylinder &  , GlobalPoint &  , double &    ) const

private

straight line parameter propagation to a cylinder

std::pair<TrajectoryStateOnSurface, double> AnalyticalPropagator::propagateWithPath ( const FreeTrajectoryState &  fts, const Plane &  plane  ) const

overrideprivatevirtual

propagation to plane with path length

Implements Propagator.

Referenced by DualBzeroTrajectoryFactory::propagateExternal(), DualTrajectoryFactory::propagateExternal(), and ~AnalyticalPropagator().

std::pair<TrajectoryStateOnSurface, double> AnalyticalPropagator::propagateWithPath ( const FreeTrajectoryState &  fts, const Cylinder &  cylinder  ) const

overrideprivatevirtual

propagation to cylinder with path length

Implements Propagator.

bool AnalyticalPropagator::setMaxDirectionChange ( float  phiMax )

inlineoverridevirtual

limitation of change in transverse direction (to avoid loops).

Reimplemented from Propagator.

Definition at line 59 of file AnalyticalPropagator.h.

References AlignmentTrackSelector_cfi::phiMax, and theMaxDPhi2.

                                                    {
    theMaxDPhi2 = phiMax * phiMax;
    return true;
  }

void AnalyticalPropagator::setMaxRelativeChangeInBz ( const float  maxDBz )

inline

Set the maximum relative change in Bz (Bz_at_end-Bz_at_start)/Bz_at_start for a single propagation. The default is no limit. NB: this propagator assumes constant, non-zero magnetic field parallel to the z-axis!

Definition at line 70 of file AnalyticalPropagator.h.

References dso_internal, AlCaHLTBitMon_ParallelJobs::p, propagatedStateWithPath(), propagateParametersOnCylinder(), propagateParametersOnPlane(), propagateWithHelixCrossing(), propagateWithLineCrossing(), alignCSCRings::s, theMaxDBzRatio, and x.

{ theMaxDBzRatio = maxDBz; }

Member Data Documentation

bool AnalyticalPropagator::isOldPropagationType

private

Definition at line 110 of file AnalyticalPropagator.h.

const MagneticField* AnalyticalPropagator::theField

private

Definition at line 109 of file AnalyticalPropagator.h.

Referenced by magneticField().

float AnalyticalPropagator::theMaxDBzRatio

private

Definition at line 108 of file AnalyticalPropagator.h.

Referenced by setMaxRelativeChangeInBz().

float AnalyticalPropagator::theMaxDPhi2

private

Definition at line 107 of file AnalyticalPropagator.h.

Referenced by setMaxDirectionChange().