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 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 FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest1, const GlobalPoint &pDest2) const final
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Cylinder &) const=0
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< 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 Surface &) const final
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Cylinder &sur) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) const final
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Plane &) const=0
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Plane &sur) const
	RKPropagatorInS (const MagVolume &vol, PropagationDirection dir=alongMomentum, double tolerance=5.e-5)
	~RKPropagatorInS () 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 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 Plane &) const override
std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Cylinder &) 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.

Referenced by clone().

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

~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 304 of file RKPropagatorInS.cc.

References RKPropagatorInS().

{ return new RKPropagatorInS(*this); }

fieldProvider() [1/2]

RKLocalFieldProvider RKPropagatorInS::fieldProvider ( ) const

private

Definition at line 313 of file RKPropagatorInS.cc.

References theVolume.

Referenced by propagateParametersOnCylinder(), and propagateParametersOnPlane().

{ return RKLocalFieldProvider(*theVolume); }

fieldProvider() [2/2]

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

private

Definition at line 315 of file RKPropagatorInS.cc.

References theVolume.

                                                                             {
  return RKLocalFieldProvider(*theVolume, cyl);
}

globalMomentum()

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

private

Definition at line 346 of file RKPropagatorInS.cc.

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

Referenced by gtpFromVolumeLocal().

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

globalPosition()

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

private

Definition at line 339 of file RKPropagatorInS.cc.

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

Referenced by gtpFromVolumeLocal(), and propagateParametersOnPlane().

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

gtpFromLocal()

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

private

Definition at line 306 of file RKPropagatorInS.cc.

References theVolume, and Surface::toGlobal().

Referenced by propagateParametersOnCylinder().

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

gtpFromVolumeLocal()

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

private

Definition at line 355 of file RKPropagatorInS.cc.

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

Referenced by propagateParametersOnPlane().

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

invertDirection()

PropagationDirection RKPropagatorInS::invertDirection ( PropagationDirection  dir ) const

private

Definition at line 319 of file RKPropagatorInS.cc.

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

Referenced by propagateParametersOnCylinder(), and propagateParametersOnPlane().

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

magneticField()

const MagneticField* RKPropagatorInS::magneticField ( ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 43 of file RKPropagatorInS.h.

References theVolume.

{ return theVolume; }

propagate() [1/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;
  }

propagate() [2/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 109 of file Propagator.h.

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

propagate() [3/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 112 of file Propagator.h.

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

propagate() [4/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 117 of file Propagator.h.

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

propagateParametersOnCylinder()

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

private

Definition at line 186 of file RKPropagatorInS.cc.

References funct::abs(), FreeTrajectoryState::charge(), MillePedeFileConverter_cfg::e, HLT_2023v12_cff::eps, fieldProvider(), gtpFromLocal(), invertDirection(), LIKELY, LogDebug, CartesianStateAdaptor::momentum(), FreeTrajectoryState::momentum(), castor_dqm_sourceclient_file_cfg::path, StraightLineCylinderCrossing::pathLength(), StraightLineBarrelCylinderCrossing::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().

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

propagateParametersOnPlane()

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

private

Definition at line 51 of file RKPropagatorInS.cc.

References funct::abs(), PV3DBase< T, PVType, FrameType >::basicVector(), FreeTrajectoryState::charge(), cross(), DeadROC_duringRun::dir, MillePedeFileConverter_cfg::e, HLT_2023v12_cff::eps, 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().

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

propagateWithPath() [1/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() [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]

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

inline

Definition at line 86 of file Propagator.h.

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

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]

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

propagateWithPath() [7/11]

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

inline

Definition at line 91 of file Propagator.h.

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

propagateWithPath() [8/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() [9/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() [10/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.

References SurfaceSideDefinition::afterSurface, alongMomentum, analyticalErrorPropagation(), SurfaceSideDefinition::beforeSurface, runTauDisplay::gp, propagateParametersOnPlane(), Propagator::propagationDirection(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::barrel::side(), and UNLIKELY.

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

propagateWithPath() [11/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.

References SurfaceSideDefinition::afterSurface, alongMomentum, analyticalErrorPropagation(), SurfaceSideDefinition::beforeSurface, runTauDisplay::gp, propagateParametersOnCylinder(), Propagator::propagationDirection(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::barrel::side(), and UNLIKELY.

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

rkMomentum()

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

private

Definition at line 332 of file RKPropagatorInS.cc.

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

Referenced by propagateParametersOnPlane().

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

rkPosition()

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

private

Definition at line 325 of file RKPropagatorInS.cc.

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

Referenced by propagateParametersOnPlane().

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

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().