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
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
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 std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) const final
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< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Plane &) const=0
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const
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 std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Surface &) const final
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Cylinder &sur) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Cylinder &) const=0
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Plane &sur) const
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

TsosWP

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

private

Definition at line 106 of file AnalyticalPropagator.h.

Constructor & Destructor Documentation

AnalyticalPropagator()

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::~AnalyticalPropagator ( )

inlineoverride

Definition at line 34 of file AnalyticalPropagator.h.

{}

Member Function Documentation

clone()

AnalyticalPropagator* AnalyticalPropagator::clone ( void  ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 64 of file AnalyticalPropagator.h.

References AnalyticalPropagator().

{ return new AnalyticalPropagator(*this); }

magneticField()

const MagneticField* AnalyticalPropagator::magneticField ( ) const

inlineoverrideprivatevirtual

Implements Propagator.

Definition at line 103 of file AnalyticalPropagator.h.

References theField.

{ return theField; }

propagate() [1/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 117 of file Propagator.h.

                                                                                  {
    return propagateWithPath(ftsStart, beamSpot).first;
  }

propagate() [2/4]

template<typename STA , typename SUR >

TrajectoryStateOnSurface Propagator::propagate ( typename STA  , typename SUR    )

inline

Definition at line 50 of file Propagator.h.

Referenced by HGCalTBGeometry::neighborZ(), HGCalGeometry::neighborZ(), TrackingRecHitPropagator::project(), RecHitPropagator::propagate(), spr::propagateCalo(), spr::propagateHCAL(), cms::MuonTCMETValueMapProducer::propagateTrack(), spr::propagateTrackerEnd(), TCMETAlgo::propagateTrackToCalorimeterFace(), PerigeeRefittedTrackState::trajectoryStateOnSurface(), and KinematicRefittedTrackState::trajectoryStateOnSurface().

                                                                                 {
    return propagateWithPath(state, surface).first;
  }

propagate() [3/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 109 of file Propagator.h.

                                                                                                                   {
    return propagateWithPath(ftsStart, pDest).first;
  }

propagate() [4/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 112 of file Propagator.h.

                                                                               {
    return propagateWithPath(ftsStart, pDest1, pDest2).first;
  }

propagatedStateWithPath()

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

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

propagateParametersOnCylinder()

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 139 of file AnalyticalPropagator.cc.

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

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

propagateParametersOnPlane()

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 180 of file AnalyticalPropagator.cc.

References funct::abs(), MillePedeFileConverter_cfg::e, f, LIKELY, LogDebug, PV3DBase< T, PVType, FrameType >::mag(), Basic3DVector< T >::mag(), FreeTrajectoryState::momentum(), oppositeToMomentum, AlCaHLTBitMon_ParallelJobs::p, perp(), PV3DBase< T, PVType, FrameType >::phi(), FreeTrajectoryState::position(), alignCSCRings::s, tolerance, FreeTrajectoryState::transverseCurvature(), UNLIKELY, and x.

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

propagateWithHelixCrossing()

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 372 of file AnalyticalPropagator.cc.

References HelixPlaneCrossing::direction(), PV3DBase< T, PVType, FrameType >::mag(), AlCaHLTBitMon_ParallelJobs::p, HelixPlaneCrossing::pathLength(), HelixPlaneCrossing::position(), alignCSCRings::s, UNLIKELY, and x.

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

propagateWithLineCrossing() [1/2]

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

private

straight line parameter propagation to a plane

propagateWithLineCrossing() [2/2]

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

private

straight line parameter propagation to a cylinder

propagateWithPath() [1/11]

std::pair< FreeTrajectoryState, double > Propagator::propagateWithPath

implemented by Stepping Helix Propagate to PCA to point given a starting point

Definition at line 42 of file Propagator.cc.

                                                                                               {
  throw cms::Exception("Propagator::propagate(FTS,GlobalPoint) not implemented");
  return std::pair<FreeTrajectoryState, double>();
}

propagateWithPath() [2/11]

std::pair< FreeTrajectoryState, double > Propagator::propagateWithPath

Propagate to PCA to a line (given by beamSpot position and slope) given a starting point.

Definition at line 53 of file Propagator.cc.

                                                                                                         {
  throw cms::Exception("Propagator::propagate(FTS,beamSpot) not implemented");
  return std::pair<FreeTrajectoryState, double>();
}

propagateWithPath() [3/11]

std::pair< FreeTrajectoryState, double > Propagator::propagateWithPath

Propagate to PCA to a line (given by 2 points) given a starting point.

Definition at line 47 of file Propagator.cc.

                                                                                               {
  throw cms::Exception("Propagator::propagate(FTS,GlobalPoint,GlobalPoint) not implemented");
  return std::pair<FreeTrajectoryState, double>();
}

propagateWithPath() [4/11]

std::pair< TrajectoryStateOnSurface, double > Propagator::propagateWithPath

final

The methods propagateWithPath() are identical to the corresponding methods propagate() in what concerns the resulting TrajectoryStateOnSurface, but they provide in addition the exact path length along the trajectory.Only use the generic method if the surface type (plane or cylinder) is not known at the calling point.

Definition at line 10 of file Propagator.cc.

                                                                                                    {
  // try plane first, most probable case (disk "is a" plane too)
  const Plane* bp = dynamic_cast<const Plane*>(&sur);
  if (bp != nullptr)
    return propagateWithPath(state, *bp);

  // if not plane try cylinder
  const Cylinder* bc = dynamic_cast<const Cylinder*>(&sur);
  if (bc != nullptr)
    return propagateWithPath(state, *bc);

  // unknown surface - can't do it!
  throw PropagationException("The surface is neither Cylinder nor Plane");
}

propagateWithPath() [5/11]

virtual std::pair<TrajectoryStateOnSurface, double> Propagator::propagateWithPath

propagateWithPath() [6/11]

std::pair< TrajectoryStateOnSurface, double > Propagator::propagateWithPath

final

The following three methods are equivalent to the corresponding methods above, but if the starting state is a TrajectoryStateOnSurface, it's better to use it as such rather than use just the FreeTrajectoryState part. It may help some concrete propagators.Only use the generic method if the surface type (plane or cylinder) is not known at the calling point.

Definition at line 26 of file Propagator.cc.

                                                                                                    {
  // try plane first, most probable case (disk "is a" plane too)
  const Plane* bp = dynamic_cast<const Plane*>(&sur);
  if (bp != nullptr)
    return propagateWithPath(state, *bp);

  // if not plane try cylinder
  const Cylinder* bc = dynamic_cast<const Cylinder*>(&sur);
  if (bc != nullptr)
    return propagateWithPath(state, *bc);

  // unknown surface - can't do it!
  throw PropagationException("The surface is neither Cylinder nor Plane");
}

propagateWithPath() [7/11]

virtual std::pair<TrajectoryStateOnSurface, double> Propagator::propagateWithPath

propagateWithPath() [8/11]

virtual std::pair<TrajectoryStateOnSurface, double> Propagator::propagateWithPath

inline

Definition at line 91 of file Propagator.h.

                                                                                                   {
    return propagateWithPath(*tsos.freeState(), sur);
  }

propagateWithPath() [9/11]

virtual std::pair<TrajectoryStateOnSurface, double> Propagator::propagateWithPath

inline

Definition at line 86 of file Propagator.h.

                                                                                                {
    return propagateWithPath(*tsos.freeState(), sur);
  }

propagateWithPath() [10/11]

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

overrideprivatevirtual

propagation to plane with path length

Implements Propagator.

propagateWithPath() [11/11]

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

overrideprivatevirtual

propagation to cylinder with path length

Implements Propagator.

setMaxDirectionChange()

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

setMaxRelativeChangeInBz()

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

{ theMaxDBzRatio = maxDBz; }

Member Data Documentation

isOldPropagationType

bool AnalyticalPropagator::isOldPropagationType

private

Definition at line 110 of file AnalyticalPropagator.h.

theField

const MagneticField* AnalyticalPropagator::theField

private

Definition at line 109 of file AnalyticalPropagator.h.

Referenced by magneticField().

theMaxDBzRatio

float AnalyticalPropagator::theMaxDBzRatio

private

Definition at line 108 of file AnalyticalPropagator.h.

Referenced by setMaxRelativeChangeInBz().

theMaxDPhi2

float AnalyticalPropagator::theMaxDPhi2

private

Definition at line 107 of file AnalyticalPropagator.h.

Referenced by setMaxDirectionChange().