RKPropagatorInS Class Reference

#include <RKPropagatorInS.h>

Inheritance diagram for RKPropagatorInS:

Public Member Functions
Propagator *	clone () const override
const MagneticField *	magneticField () const override
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
template<typename STA , typename SUR >
TrajectoryStateOnSurface	propagate (STA const &state, SUR const &surface) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Cylinder &) const=0
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Plane &) const=0
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Surface &) const final
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 std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Cylinder &sur) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Plane &sur) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) const final
	RKPropagatorInS (const MagVolume &vol, PropagationDirection dir=alongMomentum, double tolerance=5.e-5)
	~RKPropagatorInS () override
Public Member Functions inherited from Propagator
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
template<typename STA , typename SUR >
TrajectoryStateOnSurface	propagate (STA const &state, SUR const &surface) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Surface &) const final
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 std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Cylinder &sur) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Plane &sur) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) const final
virtual PropagationDirection	propagationDirection () const final
	Propagator (PropagationDirection dir=alongMomentum)
virtual bool	setMaxDirectionChange (float phiMax)
virtual void	setPropagationDirection (PropagationDirection dir)
virtual	~Propagator ()

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

Private Member Functions
RKLocalFieldProvider	fieldProvider () const
RKLocalFieldProvider	fieldProvider (const Cylinder &cyl) const
GlobalVector	globalMomentum (const Basic3DVector< float > &mom) const
GlobalPoint	globalPosition (const Basic3DVector< float > &pos) const
GlobalTrajectoryParameters	gtpFromLocal (const Basic3DVector< float > &lpos, const Basic3DVector< float > &lmom, TrackCharge ch, const Surface &surf) const
GlobalTrajectoryParameters	gtpFromVolumeLocal (const CartesianStateAdaptor &state, TrackCharge charge) const
PropagationDirection	invertDirection (PropagationDirection dir) const
GlobalParametersWithPath	propagateParametersOnCylinder (const FreeTrajectoryState &ts, const Cylinder &cyl) const
GlobalParametersWithPath	propagateParametersOnPlane (const FreeTrajectoryState &ts, const Plane &plane) const
std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Cylinder &) const override
std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Plane &) const override
Basic3DVector< double >	rkMomentum (const GlobalVector &mom) const
Basic3DVector< double >	rkPosition (const GlobalPoint &pos) const

Private Attributes
double	theTolerance
const MagVolume *	theVolume

Detailed Description

Definition at line 19 of file RKPropagatorInS.h.

Member Typedef Documentation

TsosWP

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

private

Definition at line 46 of file RKPropagatorInS.h.

Constructor & Destructor Documentation

RKPropagatorInS()

RKPropagatorInS::RKPropagatorInS ( const MagVolume &  vol, PropagationDirection  dir = alongMomentum, double  tolerance = 5.e-5  )

inlineexplicit

Definition at line 25 of file RKPropagatorInS.h.

      : Propagator(dir), theVolume(&vol), theTolerance(tolerance) {}

Referenced by clone().

~RKPropagatorInS()

RKPropagatorInS::~RKPropagatorInS ( )

inlineoverride

Definition at line 28 of file RKPropagatorInS.h.

{}

Member Function Documentation

clone()

Propagator * RKPropagatorInS::clone ( void  ) const

overridevirtual

Implements Propagator.

Definition at line 312 of file RKPropagatorInS.cc.

{ return new RKPropagatorInS(*this); }

References RKPropagatorInS().

fieldProvider() [1/2]

RKLocalFieldProvider RKPropagatorInS::fieldProvider ( ) const

private

Definition at line 321 of file RKPropagatorInS.cc.

{ return RKLocalFieldProvider(*theVolume); }

References theVolume.

Referenced by propagateParametersOnCylinder(), and propagateParametersOnPlane().

fieldProvider() [2/2]

RKLocalFieldProvider RKPropagatorInS::fieldProvider ( const Cylinder &  cyl ) const

private

Definition at line 323 of file RKPropagatorInS.cc.

                                                                             {
  return RKLocalFieldProvider(*theVolume, cyl);
}

References theVolume.

globalMomentum()

GlobalVector RKPropagatorInS::globalMomentum ( const Basic3DVector< float > &  mom ) const

private

Definition at line 354 of file RKPropagatorInS.cc.

{
  if (theVolume != nullptr)
    return theVolume->toGlobal(LocalVector(mom));
  else
    return GlobalVector(mom);
}

References theVolume, and GloballyPositioned< T >::toGlobal().

Referenced by gtpFromVolumeLocal().

globalPosition()

GlobalPoint RKPropagatorInS::globalPosition ( const Basic3DVector< float > &  pos ) const

private

Definition at line 347 of file RKPropagatorInS.cc.

                                                                                 {
  if (theVolume != nullptr)
    return theVolume->toGlobal(LocalPoint(pos));
  else
    return GlobalPoint(pos);
}

References theVolume, and GloballyPositioned< T >::toGlobal().

Referenced by gtpFromVolumeLocal(), and propagateParametersOnPlane().

gtpFromLocal()

GlobalTrajectoryParameters RKPropagatorInS::gtpFromLocal ( const Basic3DVector< float > &  lpos, const Basic3DVector< float > &  lmom, TrackCharge  ch, const Surface &  surf  ) const

private

Definition at line 314 of file RKPropagatorInS.cc.

                                                                                    {
  return GlobalTrajectoryParameters(surf.toGlobal(LocalPoint(lpos)), surf.toGlobal(LocalVector(lmom)), ch, theVolume);
}

References theVolume, and Surface::toGlobal().

Referenced by propagateParametersOnCylinder().

gtpFromVolumeLocal()

GlobalTrajectoryParameters RKPropagatorInS::gtpFromVolumeLocal ( const CartesianStateAdaptor &  state, TrackCharge  charge  ) const

private

Definition at line 363 of file RKPropagatorInS.cc.

                                                                                         {
  return GlobalTrajectoryParameters(
      globalPosition(state.position()), globalMomentum(state.momentum()), charge, theVolume);
}

References ALCARECOTkAlJpsiMuMu_cff::charge, globalMomentum(), globalPosition(), and theVolume.

Referenced by propagateParametersOnPlane().

invertDirection()

PropagationDirection RKPropagatorInS::invertDirection ( PropagationDirection  dir ) const

private

Definition at line 327 of file RKPropagatorInS.cc.

                                                                                    {
  if (dir == anyDirection)
    return dir;
  return (dir == alongMomentum ? oppositeToMomentum : alongMomentum);
}

References alongMomentum, anyDirection, DeadROC_duringRun::dir, and oppositeToMomentum.

Referenced by propagateParametersOnCylinder(), and propagateParametersOnPlane().

magneticField()

const MagneticField* RKPropagatorInS::magneticField ( ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 43 of file RKPropagatorInS.h.

{ return theVolume; }

References theVolume.

propagate() [1/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 109 of file Propagator.h.

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

propagate() [2/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 112 of file Propagator.h.

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

propagate() [3/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 117 of file Propagator.h.

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

propagate() [4/4]

template<typename STA , typename SUR >

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

inline

Definition at line 50 of file Propagator.h.

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

Referenced by HGCal_helpers::SimpleTrackPropagator::propagate().

propagateParametersOnCylinder()

GlobalParametersWithPath RKPropagatorInS::propagateParametersOnCylinder ( const FreeTrajectoryState &  ts, const Cylinder &  cyl  ) const

private

Definition at line 191 of file RKPropagatorInS.cc.

                                                                                                   {
  typedef RKAdaptiveSolver<double, RKOneCashKarpStep, 6> Solver;
  typedef Solver::Vector RKVector;
 
  const GlobalPoint& sp = cyl.position();
  if
    UNLIKELY(sp.x() != 0. || sp.y() != 0.) { throw PropagationException("Cannot propagate to an arbitrary cylinder"); }
 
  GlobalPoint gpos(ts.position());
  GlobalVector gmom(ts.momentum());
  LocalPoint pos(cyl.toLocal(gpos));
  LocalVector mom(cyl.toLocal(gmom));
  double startR = cyl.radius() - pos.perp();
 
  // LogDebug("RKPropagatorInS")  << "RKPropagatorInS: starting from FTS " << ts ;
 
  // (transverse) curvature
  double rho = ts.transverseCurvature();
  //
  // Straight line approximation? |rho|<1.e-10 equivalent to ~ 1um
  // difference in transversal position at 10m.
  //
  if
    UNLIKELY(fabs(rho) < 1.e-10) {
      //
      // 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(gpos, gmom, propagationDirection());
 
      //
      // get solution
      //
      std::pair<bool, double> propResult = cylCrossing.pathLength(cyl);
      if
        LIKELY(propResult.first && theVolume != nullptr) {
          double s = propResult.second;
          // point (reconverted to GlobalPoint)
          GlobalPoint x(cylCrossing.position(s));
          GlobalTrajectoryParameters res(x, gmom, ts.charge(), theVolume);
          LogDebug("RKPropagatorInS") << "Straight line propagation to cylinder succeeded !!";
          return GlobalParametersWithPath(res, s);
        }
 
      //do someting
      edm::LogError("RKPropagatorInS") << "Straight line propagation to cylinder failed !!";
      return GlobalParametersWithPath();
    }
 
  RKLocalFieldProvider field(fieldProvider(cyl));
  // StraightLineCylinderCrossing pathLength( pos, mom, propagationDirection());
  CartesianLorentzForce deriv(field, ts.charge());
 
  RKCartesianDistance dist;
  double eps = theTolerance;
  Solver solver;
  double stot = 0;
  PropagationDirection currentDirection = propagationDirection();
 
  RKVector start(CartesianStateAdaptor::rkstate(pos.basicVector(), mom.basicVector()));
  int safeGuard = 0;
  while (safeGuard++ < 100) {
    CartesianStateAdaptor startState(start);
    StraightLineCylinderCrossing pathLength(
        LocalPoint(startState.position()), LocalVector(startState.momentum()), currentDirection, eps);
 
    std::pair<bool, double> path = pathLength.pathLength(cyl);
    if
      UNLIKELY(!path.first) {
        LogDebug("RKPropagatorInS") << "RKPropagatorInS: Path length calculation to cylinder failed!"
                                    << "Radius " << cyl.radius() << " pos.perp() "
                                    << LocalPoint(startState.position()).perp();
        return GlobalParametersWithPath();
      }
 
    LogDebug("RKPropagatorInS") << "RKPropagatorInS: Path lenght to cylinder is " << path.second << " from point (R,z) "
                                << startState.position().perp() << ", " << startState.position().z() << " to R "
                                << cyl.radius();
 
    double sstep = path.second;
    if
      UNLIKELY(std::abs(sstep) < eps) {
        LogDebug("RKPropagatorInS") << "accuracy not reached, but pathLength calculation says we are there! "
                                    << path.second;
 
        GlobalTrajectoryParameters res(gtpFromLocal(startState.position(), startState.momentum(), ts.charge(), cyl));
        return GlobalParametersWithPath(res, stot);
      }
 
    LogDebug("RKPropagatorInS") << "RKPropagatorInS: Solving for " << sstep << " current distance to cylinder is "
                                << startR;
 
    RKVector rkresult = solver(0, start, sstep, deriv, dist, eps);
    stot += sstep;
    CartesianStateAdaptor cur(rkresult);
    double remainingR = cyl.radius() - cur.position().perp();
 
    if (fabs(remainingR) < eps) {
      LogDebug("RKPropagatorInS") << "Accuracy reached! " << remainingR;
      GlobalTrajectoryParameters res(gtpFromLocal(cur.position(), cur.momentum(), ts.charge(), cyl));
      return GlobalParametersWithPath(res, stot);
    }
 
    start = rkresult;
    if (remainingR * startR > 0) {
      LogDebug("RKPropagatorInS") << "Accuracy not reached yet, trying in same direction again " << remainingR;
    } else {
      LogDebug("RKPropagatorInS") << "Accuracy not reached yet, trying in opposite direction " << remainingR;
      currentDirection = invertDirection(currentDirection);
    }
    startR = remainingR;
  }
 
  edm::LogError("FailedPropagation") << " too many iterations trying to reach cylinder ";
  return GlobalParametersWithPath();
}

References funct::abs(), FreeTrajectoryState::charge(), MillePedeFileConverter_cfg::e, fieldProvider(), gtpFromLocal(), invertDirection(), LIKELY, LogDebug, CartesianStateAdaptor::momentum(), FreeTrajectoryState::momentum(), castor_dqm_sourceclient_file_cfg::path, StraightLineBarrelCylinderCrossing::pathLength(), StraightLineCylinderCrossing::pathLength(), Basic3DVector< T >::perp(), perp(), CartesianStateAdaptor::position(), StraightLineBarrelCylinderCrossing::position(), GloballyPositioned< T >::position(), FreeTrajectoryState::position(), Propagator::propagationDirection(), Cylinder::radius(), rho, CartesianStateAdaptor::rkstate(), alignCSCRings::s, command_line::start, theTolerance, theVolume, GloballyPositioned< T >::toLocal(), FreeTrajectoryState::transverseCurvature(), UNLIKELY, x, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and Basic3DVector< T >::z().

Referenced by propagateWithPath().

propagateParametersOnPlane()

GlobalParametersWithPath RKPropagatorInS::propagateParametersOnPlane ( const FreeTrajectoryState &  ts, const Plane &  plane  ) const

private

Definition at line 51 of file RKPropagatorInS.cc.

                                                                                               {
  GlobalPoint gpos(ts.position());
  GlobalVector gmom(ts.momentum());
  double startZ = plane.localZ(gpos);
  // (transverse) curvature
  double rho = ts.transverseCurvature();
  //
  // Straight line approximation? |rho|<1.e-10 equivalent to ~ 1um
  // difference in transversal position at 10m.
  //
  if
    UNLIKELY(fabs(rho) < 1.e-10) {
      //
      // 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).
      //
      LogDebug("RKPropagatorInS") << " startZ = " << startZ;
 
      if
        UNLIKELY(fabs(startZ) < 1e-5) {
          LogDebug("RKPropagatorInS") << "Propagation is not performed: state is already on final surface.";
          GlobalTrajectoryParameters res(gpos, gmom, ts.charge(), theVolume);
          return GlobalParametersWithPath(res, 0.0);
        }
 
      StraightLinePlaneCrossing::PositionType pos(gpos);
      StraightLinePlaneCrossing::DirectionType dir(gmom);
      StraightLinePlaneCrossing planeCrossing(pos, dir, propagationDirection());
      //
      // get solution
      //
      std::pair<bool, double> propResult = planeCrossing.pathLength(plane);
      if
        LIKELY(propResult.first && theVolume != nullptr) {
          double s = propResult.second;
          // point (reconverted to GlobalPoint)
          GlobalPoint x(planeCrossing.position(s));
          GlobalTrajectoryParameters res(x, gmom, ts.charge(), theVolume);
          return GlobalParametersWithPath(res, s);
        }
      //do someting
      LogDebug("RKPropagatorInS") << "Straight line propgation to plane failed !!";
      return GlobalParametersWithPath();
    }
 
#ifdef EDM_ML_DEBUG
  if (theVolume != 0) {
    LogDebug("RKPropagatorInS") << "RKPropagatorInS: starting prop to plane in volume with pos "
                                << theVolume->position() << " Z axis " << theVolume->toGlobal(LocalVector(0, 0, 1));
 
    LogDebug("RKPropagatorInS") << "The starting position is " << ts.position() << " (global) "
                                << theVolume->toLocal(ts.position()) << " (local) ";
 
    FrameChanger changer;
    auto localPlane = changer.transformPlane(plane, *theVolume);
    LogDebug("RKPropagatorInS") << "The plane position is " << plane.position() << " (global) " << localPlane.position()
                                << " (local) ";
 
    LogDebug("RKPropagatorInS") << "The initial distance to plane is " << plane.localZ(ts.position());
 
    StraightLinePlaneCrossing cross(ts.position().basicVector(), ts.momentum().basicVector());
    std::pair<bool, double> res3 = cross.pathLength(plane);
    LogDebug("RKPropagatorInS") << "straight line distance " << res3.first << " " << res3.second;
  }
#endif
 
  typedef RKAdaptiveSolver<double, RKOneCashKarpStep, 6> Solver;
  typedef Solver::Vector RKVector;
 
  RKLocalFieldProvider field(fieldProvider());
  PathToPlane2Order pathLength(field, &field.frame());
  CartesianLorentzForce deriv(field, ts.charge());
 
  RKCartesianDistance dist;
  double eps = theTolerance;
  Solver solver;
  double stot = 0;
  PropagationDirection currentDirection = propagationDirection();
 
  // in magVolume frame
  RKVector start(CartesianStateAdaptor::rkstate(rkPosition(gpos), rkMomentum(gmom)));
  int safeGuard = 0;
  while (safeGuard++ < 100) {
    CartesianStateAdaptor startState(start);
 
    std::pair<bool, double> path =
        pathLength(plane, startState.position(), startState.momentum(), (double)ts.charge(), currentDirection);
    if
      UNLIKELY(!path.first) {
        LogDebug("RKPropagatorInS") << "RKPropagatorInS: Path length calculation to plane failed!"
                                    << "...distance to plane " << plane.localZ(globalPosition(startState.position()))
                                    << "...Local starting position in volume " << startState.position()
                                    << "...Magnetic field " << field.inTesla(startState.position());
 
        return GlobalParametersWithPath();
      }
 
    LogDebug("RKPropagatorInS") << "RKPropagatorInS: Path lenght to plane is " << path.second;
 
    double sstep = path.second;
    if
      UNLIKELY(std::abs(sstep) < eps) {
        LogDebug("RKPropagatorInS") << "On-surface accuracy not reached, but pathLength calculation says we are there! "
                                    << "path " << path.second << " distance to plane is " << startZ;
        GlobalTrajectoryParameters res(gtpFromVolumeLocal(startState, ts.charge()));
        return GlobalParametersWithPath(res, stot);
      }
 
    LogDebug("RKPropagatorInS") << "RKPropagatorInS: Solving for " << sstep << " current distance to plane is "
                                << startZ;
 
    RKVector rkresult = solver(0, start, sstep, deriv, dist, eps);
    stot += sstep;
    CartesianStateAdaptor cur(rkresult);
    double remainingZ = plane.localZ(globalPosition(cur.position()));
 
    if (fabs(remainingZ) < eps) {
      LogDebug("RKPropagatorInS") << "On-surface accuracy reached! " << remainingZ;
      GlobalTrajectoryParameters res(gtpFromVolumeLocal(cur, ts.charge()));
      return GlobalParametersWithPath(res, stot);
    }
 
    start = rkresult;
 
    if (remainingZ * startZ > 0) {
      LogDebug("RKPropagatorInS") << "Accuracy not reached yet, trying in same direction again " << remainingZ;
    } else {
      LogDebug("RKPropagatorInS") << "Accuracy not reached yet, trying in opposite direction " << remainingZ;
      currentDirection = invertDirection(currentDirection);
    }
    startZ = remainingZ;
  }
 
  edm::LogError("FailedPropagation") << " too many iterations trying to reach plane ";
  return GlobalParametersWithPath();
}

References funct::abs(), PV3DBase< T, PVType, FrameType >::basicVector(), FreeTrajectoryState::charge(), cross(), DeadROC_duringRun::dir, MillePedeFileConverter_cfg::e, fieldProvider(), RKLocalFieldProvider::frame(), globalPosition(), gtpFromVolumeLocal(), RKLocalFieldProvider::inTesla(), invertDirection(), LIKELY, Plane::localZ(), LogDebug, CartesianStateAdaptor::momentum(), FreeTrajectoryState::momentum(), castor_dqm_sourceclient_file_cfg::path, StraightLinePlaneCrossing::pathLength(), CartesianStateAdaptor::position(), GloballyPositioned< T >::position(), StraightLinePlaneCrossing::position(), FreeTrajectoryState::position(), Propagator::propagationDirection(), rho, rkMomentum(), rkPosition(), CartesianStateAdaptor::rkstate(), alignCSCRings::s, command_line::start, theTolerance, theVolume, GloballyPositioned< T >::toGlobal(), GloballyPositioned< T >::toLocal(), FrameChanger::transformPlane(), FreeTrajectoryState::transverseCurvature(), UNLIKELY, and x.

Referenced by propagateWithPath().

propagateWithPath() [1/11]

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

overrideprivatevirtual

Implements Propagator.

Definition at line 38 of file RKPropagatorInS.cc.

                                                                                                          {
  GlobalParametersWithPath gp = propagateParametersOnCylinder(fts, cyl);
  if
    UNLIKELY(!gp) return TsosWP(TrajectoryStateOnSurface(), 0.);
 
  SurfaceSideDefinition::SurfaceSide side =
      PropagationDirectionFromPath()(gp.s(), propagationDirection()) == alongMomentum
          ? SurfaceSideDefinition::beforeSurface
          : SurfaceSideDefinition::afterSurface;
  return analyticalErrorPropagation(fts, cyl, side, gp.parameters(), gp.s());
}

References SurfaceSideDefinition::afterSurface, alongMomentum, analyticalErrorPropagation(), SurfaceSideDefinition::beforeSurface, runTauDisplay::gp, propagateParametersOnCylinder(), Propagator::propagationDirection(), and UNLIKELY.

propagateWithPath() [2/11]

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

propagateWithPath() [3/11]

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

overrideprivatevirtual

Implements Propagator.

Definition at line 25 of file RKPropagatorInS.cc.

                                                                                                         {
  GlobalParametersWithPath gp = propagateParametersOnPlane(fts, plane);
  if
    UNLIKELY(!gp) return TsosWP(TrajectoryStateOnSurface(), 0.);
 
  SurfaceSideDefinition::SurfaceSide side =
      PropagationDirectionFromPath()(gp.s(), propagationDirection()) == alongMomentum
          ? SurfaceSideDefinition::beforeSurface
          : SurfaceSideDefinition::afterSurface;
  return analyticalErrorPropagation(fts, plane, side, gp.parameters(), gp.s());
}

References SurfaceSideDefinition::afterSurface, alongMomentum, analyticalErrorPropagation(), SurfaceSideDefinition::beforeSurface, runTauDisplay::gp, propagateParametersOnPlane(), Propagator::propagationDirection(), and UNLIKELY.

propagateWithPath() [4/11]

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

propagateWithPath() [5/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() [6/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() [7/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() [8/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() [9/11]

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

inline

Definition at line 91 of file Propagator.h.

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

propagateWithPath() [10/11]

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

inline

Definition at line 86 of file Propagator.h.

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

propagateWithPath() [11/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");
}

rkMomentum()

Basic3DVector< double > RKPropagatorInS::rkMomentum ( const GlobalVector &  mom ) const

private

Definition at line 340 of file RKPropagatorInS.cc.

                                                                               {
  if (theVolume != nullptr)
    return theVolume->toLocal(mom).basicVector();
  else
    return mom.basicVector();
}

References PV3DBase< T, PVType, FrameType >::basicVector(), theVolume, and GloballyPositioned< T >::toLocal().

Referenced by propagateParametersOnPlane().

rkPosition()

Basic3DVector< double > RKPropagatorInS::rkPosition ( const GlobalPoint &  pos ) const

private

Definition at line 333 of file RKPropagatorInS.cc.

                                                                              {
  if (theVolume != nullptr)
    return theVolume->toLocal(pos).basicVector();
  else
    return pos.basicVector();
}

References PV3DBase< T, PVType, FrameType >::basicVector(), theVolume, and GloballyPositioned< T >::toLocal().

Referenced by propagateParametersOnPlane().

Member Data Documentation

theTolerance

double RKPropagatorInS::theTolerance

private

Definition at line 49 of file RKPropagatorInS.h.

Referenced by propagateParametersOnCylinder(), and propagateParametersOnPlane().

theVolume

const MagVolume* RKPropagatorInS::theVolume

private

Definition at line 48 of file RKPropagatorInS.h.

Referenced by fieldProvider(), globalMomentum(), globalPosition(), gtpFromLocal(), gtpFromVolumeLocal(), magneticField(), propagateParametersOnCylinder(), propagateParametersOnPlane(), rkMomentum(), and rkPosition().