CMS 3D CMS Logo
List of all members | Public Member Functions | Private Types | Private Member Functions | Private Attributes
AnalyticalPropagator Class Referencefinal

#include <AnalyticalPropagator.h>

Inheritance diagram for AnalyticalPropagator:
Propagator

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 &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
 
bool setMaxDirectionChange (float phiMax) override
 
void setMaxRelativeChangeInBz (const float maxDBz)
 
 ~AnalyticalPropagator () 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 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 Cylinder &, GlobalPoint &, double &) const
 straight line parameter propagation to a cylinder More...
 
bool propagateWithLineCrossing (const GlobalPoint &, const GlobalVector &, const Plane &, GlobalPoint &, double &) const
 straight line parameter propagation to a plane More...
 
std::pair< TrajectoryStateOnSurface, double > propagateWithPath (const FreeTrajectoryState &fts, const Cylinder &cylinder) const override
 propagation to cylinder with path length More...
 
std::pair< TrajectoryStateOnSurface, double > propagateWithPath (const FreeTrajectoryState &fts, const Plane &plane) const override
 propagation to plane 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.

28  : Propagator(dir),
29  theMaxDPhi2(maxDPhi * maxDPhi),
30  theMaxDBzRatio(0.5),
31  theField(field),
32  isOldPropagationType(isOld) {}

Referenced by clone().

◆ ~AnalyticalPropagator()

AnalyticalPropagator::~AnalyticalPropagator ( )
inlineoverride

Definition at line 34 of file AnalyticalPropagator.h.

34 {}

Member Function Documentation

◆ clone()

AnalyticalPropagator* AnalyticalPropagator::clone ( void  ) const
inlineoverridevirtual

Implements Propagator.

Definition at line 64 of file AnalyticalPropagator.h.

64 { return new AnalyticalPropagator(*this); }

References AnalyticalPropagator().

◆ magneticField()

const MagneticField* AnalyticalPropagator::magneticField ( ) const
inlineoverrideprivatevirtual

Implements Propagator.

Definition at line 103 of file AnalyticalPropagator.h.

103 { return theField; }

References theField.

◆ propagate() [1/4]

virtual FreeTrajectoryState Propagator::propagate
inlinefinal

Definition at line 109 of file Propagator.h.

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

◆ propagate() [2/4]

virtual FreeTrajectoryState Propagator::propagate
inlinefinal

Definition at line 112 of file Propagator.h.

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

◆ propagate() [3/4]

virtual FreeTrajectoryState Propagator::propagate
inlinefinal

Definition at line 117 of file Propagator.h.

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

◆ propagate() [4/4]

template<typename STA , typename SUR >
TrajectoryStateOnSurface Propagator::propagate ( typename STA  ,
typename SUR   
)
inline

Definition at line 50 of file Propagator.h.

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

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

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

116  {
117  //
118  // for forward propagation: state is before surface,
119  // for backward propagation: state is after surface
120  //
121  SurfaceSide side =
122  PropagationDirectionFromPath()(s, propagationDirection()) == alongMomentum ? beforeSurface : afterSurface;
123  //
124  //
125  // error propagation (if needed) and conversion to a TrajectoryStateOnSurface
126  //
127  if (fts.hasError()) {
128  //
129  // compute jacobian
130  //
131  AnalyticalCurvilinearJacobian analyticalJacobian(fts.parameters(), gtp.position(), gtp.momentum(), s);
132  const AlgebraicMatrix55& jacobian = analyticalJacobian.jacobian();
133  // CurvilinearTrajectoryError cte(ROOT::Math::Similarity(jacobian, fts.curvilinearError().matrix()));
134  return TsosWP(
135  TrajectoryStateOnSurface(gtp, ROOT::Math::Similarity(jacobian, fts.curvilinearError().matrix()), surface, side),
136  s);
137  } else {
138  //
139  // return state without errors
140  //
141  return TsosWP(TrajectoryStateOnSurface(gtp, surface, side), s);
142  }
143 }

References SurfaceSideDefinition::afterSurface, alongMomentum, SurfaceSideDefinition::beforeSurface, FreeTrajectoryState::curvilinearError(), FreeTrajectoryState::hasError(), AnalyticalCurvilinearJacobian::jacobian(), CurvilinearTrajectoryError::matrix(), GlobalTrajectoryParameters::momentum(), FreeTrajectoryState::parameters(), GlobalTrajectoryParameters::position(), and alignCSCRings::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 145 of file AnalyticalPropagator.cc.

146  {
147  GlobalPoint const& sp = cylinder.position();
148  if
149  UNLIKELY(sp.x() != 0. || sp.y() != 0.) { throw PropagationException("Cannot propagate to an arbitrary cylinder"); }
150  // preset output
151  x = fts.position();
152  p = fts.momentum();
153  s = 0;
154  // (transverse) curvature
155  auto rho = fts.transverseCurvature();
156  //
157  // Straight line approximation? |rho|<1.e-10 equivalent to ~ 1um
158  // difference in transversal position at 10m.
159  //
160  if
161  UNLIKELY(std::abs(rho) < 1.e-10f)
162  return propagateWithLineCrossing(fts.position(), p, cylinder, x, s);
163  //
164  // Helix case
165  //
166  // check for possible intersection
167  constexpr float tolerance = 1.e-4; // 1 micron distance
168  auto rdiff = x.perp() - cylinder.radius();
169  if (std::abs(rdiff) < tolerance)
170  return true;
171  //
172  // Instantiate HelixBarrelCylinderCrossing and get solutions
173  //
174  HelixBarrelCylinderCrossing cylinderCrossing(fts.position(), fts.momentum(), rho, propagationDirection(), cylinder);
175  if
176  UNLIKELY(!cylinderCrossing.hasSolution()) return false;
177  // path length
178  s = cylinderCrossing.pathLength();
179  // point
180  x = cylinderCrossing.position();
181  // direction (renormalised)
182  p = cylinderCrossing.direction().unit() * fts.momentum().mag();
183  return true;
184 }

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, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

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

187  {
188  // initialisation of position, momentum and path length
189  x = fts.position();
190  p = fts.momentum();
191  s = 0;
192  // (transverse) curvature
193  auto rho = fts.transverseCurvature();
194  //
195  // Straight line approximation? |rho|<1.e-10 equivalent to ~ 1um
196  // difference in transversal position at 10m.
197  //
198  if
199  UNLIKELY(std::abs(rho) < 1.e-10f)
200  return propagateWithLineCrossing(fts.position(), p, plane, x, s);
201  //
202  // Helix case
203  //
204 
205  //
206  // Frame-independant point and vector are created explicitely to
207  // avoid confusing gcc (refuses to compile with temporary objects
208  // in the constructor).
209  //
210  HelixPlaneCrossing::PositionType helixPos(x);
211  HelixPlaneCrossing::DirectionType helixDir(p);
212  if
213  LIKELY(isOldPropagationType) {
214  OptimalHelixPlaneCrossing planeCrossing(plane, helixPos, helixDir, rho, propagationDirection());
215  return propagateWithHelixCrossing(*planeCrossing, plane, fts.momentum().mag(), x, p, s);
216  }
217 
218  //--- Alternative implementation to be used for the propagation of the parameters of looping
219  // particles that cross twice the (infinite) surface of the plane. It is not trivial to determine
220  // which of the two intersections has to be returned.
221 
222  //---- FIXME: WHAT FOLLOWS HAS TO BE REWRITTEN IN A CLEANER (AND CPU-OPTIMIZED) WAY ---------
223  LogDebug("AnalyticalPropagator") << "In AnaliticalProp, calling HAPC "
224  << "\n"
225  << "plane is centered in xyz: " << plane.position().x() << " , "
226  << plane.position().y() << " , " << plane.position().z() << "\n";
227 
228  GlobalPoint gp1 = fts.position();
229  GlobalVector gm1 = fts.momentum();
230  double s1 = 0;
231  double rho1 = fts.transverseCurvature();
232  HelixPlaneCrossing::PositionType helixPos1(gp1);
233  HelixPlaneCrossing::DirectionType helixDir1(gm1);
234  LogDebug("AnalyticalPropagator") << "gp1 before calling planeCrossing1: " << gp1 << "\n";
235  OptimalHelixPlaneCrossing planeCrossing1(plane, helixPos1, helixDir1, rho1, propagationDirection());
236 
237  HelixPlaneCrossing::PositionType xGen;
238  HelixPlaneCrossing::DirectionType pGen;
239 
240  double tolerance(0.0050);
241  if (propagationDirection() == oppositeToMomentum)
242  tolerance *= -1;
243 
244  bool check1 = propagateWithHelixCrossing(*planeCrossing1, plane, fts.momentum().mag(), gp1, gm1, s1);
245  double dphi1 = fabs(fts.momentum().phi() - gm1.phi());
246  LogDebug("AnalyticalPropagator") << "check1, s1, dphi, gp1: " << check1 << " , " << s1 << " , " << dphi1 << " , "
247  << gp1 << "\n";
248 
249  //move forward a bit to avoid that the propagator doesn't propagate because the state is already on surface.
250  //we want to go to the other point of intersection between the helix and the plane
251  xGen = (*planeCrossing1).position(s1 + tolerance);
252  pGen = (*planeCrossing1).direction(s1 + tolerance);
253 
254  /*
255  if(!check1 || s1>170 ){
256  //PropagationDirection newDir = (propagationDirection() == alongMomentum) ? oppositeToMomentum : alongMomentum;
257  PropagationDirection newDir = anyDirection;
258  HelixArbitraryPlaneCrossing planeCrossing1B(helixPos1,helixDir1,rho1,newDir);
259  check1 = propagateWithHelixCrossing(planeCrossing1B,plane,fts.momentum().mag(),gp1,gm1,s1);
260  LogDebug("AnalyticalPropagator") << "after second attempt, check1, s1,gp1: "
261  << check1 << " , "
262  << s1 << " , " << gp1 << "\n";
263 
264  xGen = planeCrossing1B.position(s1+tolerance);
265  pGen = planeCrossing1B.direction(s1+tolerance);
266  }
267  */
268 
269  if (!check1) {
270  LogDebug("AnalyticalPropagator") << "failed also second attempt. No idea what to do, then bailout"
271  << "\n";
272  }
273 
274  pGen *= gm1.mag() / pGen.mag();
275  GlobalPoint gp2(xGen);
276  GlobalVector gm2(pGen);
277  double s2 = 0;
278  double rho2 = rho1;
279  HelixPlaneCrossing::PositionType helixPos2(gp2);
280  HelixPlaneCrossing::DirectionType helixDir2(gm2);
281  OptimalHelixPlaneCrossing planeCrossing2(plane, helixPos2, helixDir2, rho2, propagationDirection());
282 
283  bool check2 = propagateWithHelixCrossing(*planeCrossing2, plane, gm2.mag(), gp2, gm2, s2);
284 
285  if (!check2) {
286  x = gp1;
287  p = gm1;
288  s = s1;
289  return check1;
290  }
291 
292  if (!check1) {
293  edm::LogError("AnalyticalPropagator") << "LOGIC ERROR: I should not have entered here!"
294  << "\n";
295  return false;
296  }
297 
298  LogDebug("AnalyticalPropagator") << "check2, s2, gp2: " << check2 << " , " << s2 << " , " << gp2 << "\n";
299 
300  double dist1 = (plane.position() - gp1).perp();
301  double dist2 = (plane.position() - gp2).perp();
302 
303  LogDebug("AnalyticalPropagator") << "propDir, dist1, dist2: " << propagationDirection() << " , " << dist1 << " , "
304  << dist2 << "\n";
305 
306  //If there are two solutions, the one which is the closest to the module's center is chosen
307  if (dist1 < 2 * dist2) {
308  x = gp1;
309  p = gm1;
310  s = s1;
311  return check1;
312  } else if (dist2 < 2 * dist1) {
313  x = gp2;
314  p = gm2;
315  s = s1 + s2 + tolerance;
316  return check2;
317  } else {
318  if (fabs(s1) < fabs(s2)) {
319  x = gp1;
320  p = gm1;
321  s = s1;
322  return check1;
323  } else {
324  x = gp2;
325  p = gm2;
326  s = s1 + s2 + tolerance;
327  return check2;
328  }
329  }
330 
331  //-------- END of ugly piece of code ---------------
332 }

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, indexGen::s2, tolerance, FreeTrajectoryState::transverseCurvature(), and UNLIKELY.

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

385  {
386  // get solution
387  std::pair<bool, double> propResult = planeCrossing.pathLength(plane);
388  if
389  UNLIKELY(!propResult.first) return false;
390 
391  s = propResult.second;
392  x = GlobalPoint(planeCrossing.position(s));
393  // direction (reconverted to GlobalVector, renormalised)
394  GlobalVector pGen = GlobalVector(planeCrossing.direction(s));
395  pGen *= pmag / pGen.mag();
396  p = pGen;
397  //
398  return true;
399 }

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

◆ propagateWithLineCrossing() [1/2]

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

straight line parameter propagation to a cylinder

◆ propagateWithLineCrossing() [2/2]

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

straight line parameter propagation to a plane

◆ propagateWithPath() [1/11]

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

◆ propagateWithPath() [2/11]

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

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

11  {
12  // try plane first, most probable case (disk "is a" plane too)
13  const Plane* bp = dynamic_cast<const Plane*>(&sur);
14  if (bp != nullptr)
15  return propagateWithPath(state, *bp);
16 
17  // if not plane try cylinder
18  const Cylinder* bc = dynamic_cast<const Cylinder*>(&sur);
19  if (bc != nullptr)
20  return propagateWithPath(state, *bc);
21 
22  // unknown surface - can't do it!
23  throw PropagationException("The surface is neither Cylinder nor Plane");
24 }

◆ propagateWithPath() [4/11]

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

propagation to cylinder with path length

Implements Propagator.

◆ propagateWithPath() [5/11]

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

propagation to plane with path length

Implements Propagator.

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

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

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

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

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

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

◆ propagateWithPath() [9/11]

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

Definition at line 91 of file Propagator.h.

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

◆ propagateWithPath() [10/11]

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

Definition at line 86 of file Propagator.h.

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

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

27  {
28  // try plane first, most probable case (disk "is a" plane too)
29  const Plane* bp = dynamic_cast<const Plane*>(&sur);
30  if (bp != nullptr)
31  return propagateWithPath(state, *bp);
32 
33  // if not plane try cylinder
34  const Cylinder* bc = dynamic_cast<const Cylinder*>(&sur);
35  if (bc != nullptr)
36  return propagateWithPath(state, *bc);
37 
38  // unknown surface - can't do it!
39  throw PropagationException("The surface is neither Cylinder nor Plane");
40 }

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

59  {
60  theMaxDPhi2 = phiMax * phiMax;
61  return true;
62  }

References AlignmentTrackSelector_cfi::phiMax, and theMaxDPhi2.

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

70 { theMaxDBzRatio = maxDBz; }

References theMaxDBzRatio.

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

Vector3DBase
Definition: Vector3DBase.h:8
FreeTrajectoryState::momentum
GlobalVector momentum() const
Definition: FreeTrajectoryState.h:68
AnalyticalCurvilinearJacobian::jacobian
const AlgebraicMatrix55 & jacobian() const
Definition: AnalyticalCurvilinearJacobian.h:51
AnalyticalCurvilinearJacobian
Definition: AnalyticalCurvilinearJacobian.h:21
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
funct::false
false
Definition: Factorize.h:29
FreeTrajectoryState::hasError
bool hasError() const
Definition: FreeTrajectoryState.h:77
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
GlobalTrajectoryParameters::position
GlobalPoint position() const
Definition: GlobalTrajectoryParameters.h:60
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
PropagationException
Common base class.
Definition: PropagationExceptions.h:14
PropagationDirectionFromPath
Definition: PropagationDirectionFromPath.h:8
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
oppositeToMomentum
Definition: PropagationDirection.h:4
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
SurfaceSideDefinition::SurfaceSide
SurfaceSide
Definition: SurfaceSideDefinition.h:8
SurfaceSideDefinition::afterSurface
Definition: SurfaceSideDefinition.h:8
HLT_FULL_cff.maxDPhi
maxDPhi
Definition: HLT_FULL_cff.py:9146
mathSSE::return
return((rh ^ lh) &mask)
DDAxes::x
indexGen.s2
s2
Definition: indexGen.py:107
FreeTrajectoryState::position
GlobalPoint position() const
Definition: FreeTrajectoryState.h:67
Basic3DVector::mag
T mag() const
The vector magnitude. Equivalent to sqrt(vec.mag2())
Definition: extBasic3DVector.h:116
perp
T perp() const
Magnitude of transverse component.
Definition: Basic3DVectorLD.h:133
AnalyticalPropagator::TsosWP
std::pair< TrajectoryStateOnSurface, double > TsosWP
Definition: AnalyticalPropagator.h:106
AnalyticalPropagator::theMaxDBzRatio
float theMaxDBzRatio
Definition: AnalyticalPropagator.h:108
UNLIKELY
#define UNLIKELY(x)
Definition: Likely.h:21
TrajectoryStateOnSurface
Definition: TrajectoryStateOnSurface.h:16
AnalyticalPropagator::propagateWithPath
std::pair< TrajectoryStateOnSurface, double > propagateWithPath(const FreeTrajectoryState &fts, const Plane &plane) const override
propagation to plane with path length
alignCSCRings.s
s
Definition: alignCSCRings.py:92
AlgebraicMatrix55
ROOT::Math::SMatrix< double, 5, 5, ROOT::Math::MatRepStd< double, 5, 5 > > AlgebraicMatrix55
Definition: AlgebraicROOTObjects.h:55
AnalyticalPropagator::theField
const MagneticField * theField
Definition: AnalyticalPropagator.h:109
FreeTrajectoryState::curvilinearError
const CurvilinearTrajectoryError & curvilinearError() const
Definition: FreeTrajectoryState.h:89
SurfaceSideDefinition::beforeSurface
Definition: SurfaceSideDefinition.h:8
Propagator::propagationDirection
virtual PropagationDirection propagationDirection() const final
Definition: Propagator.h:139
HelixPlaneCrossing::pathLength
virtual std::pair< bool, double > pathLength(const Plane &)=0
AlignmentTrackSelector_cfi.phiMax
phiMax
Definition: AlignmentTrackSelector_cfi.py:17
Point3DBase< float, GlobalTag >
GlobalTrajectoryParameters::momentum
GlobalVector momentum() const
Definition: GlobalTrajectoryParameters.h:65
DDAxes::rho
funct::true
true
Definition: Factorize.h:173
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233
OptimalHelixPlaneCrossing
Definition: OptimalHelixPlaneCrossing.h:10
position
static int position[264][3]
Definition: ReadPGInfo.cc:289
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
FreeTrajectoryState::parameters
const GlobalTrajectoryParameters & parameters() const
Definition: FreeTrajectoryState.h:79
tolerance
const double tolerance
Definition: HGCalGeomParameters.cc:29
AnalyticalPropagator::propagateWithLineCrossing
bool propagateWithLineCrossing(const GlobalPoint &, const GlobalVector &, const Plane &, GlobalPoint &, double &) const
straight line parameter propagation to a plane
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
AnalyticalPropagator::theMaxDPhi2
float theMaxDPhi2
Definition: AnalyticalPropagator.h:107
PV3DBase::mag
T mag() const
Definition: PV3DBase.h:64
AnalyticalPropagator::propagateWithHelixCrossing
bool propagateWithHelixCrossing(HelixPlaneCrossing &, const Plane &, const float, GlobalPoint &, GlobalVector &, double &s) const
helix parameter propagation to a plane using HelixPlaneCrossing
Definition: AnalyticalPropagator.cc:380
GloballyPositioned::position
const PositionType & position() const
Definition: GloballyPositioned.h:36
mag
T mag() const
The vector magnitude. Equivalent to sqrt(vec.mag2())
Definition: Basic3DVectorLD.h:127
RunInfoPI::state
state
Definition: RunInfoPayloadInspectoHelper.h:16
LIKELY
#define LIKELY(x)
Definition: Likely.h:20
Exception
Definition: hltDiff.cc:245
Plane
Definition: Plane.h:16
HelixBarrelCylinderCrossing
Definition: HelixBarrelCylinderCrossing.h:16
Cylinder
Definition: Cylinder.h:19
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
AnalyticalPropagator::AnalyticalPropagator
AnalyticalPropagator(const MagneticField *field, PropagationDirection dir=alongMomentum, float maxDPhi=1.6, bool isOld=true)
Definition: AnalyticalPropagator.h:24
alongMomentum
Definition: PropagationDirection.h:4
FreeTrajectoryState::transverseCurvature
double transverseCurvature() const
Definition: FreeTrajectoryState.h:71
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
Basic3DVector< float >
CurvilinearTrajectoryError::matrix
const AlgebraicSymMatrix55 & matrix() const
Definition: CurvilinearTrajectoryError.h:61
AnalyticalPropagator::isOldPropagationType
bool isOldPropagationType
Definition: AnalyticalPropagator.h:110
DeadROC_duringRun.dir
dir
Definition: DeadROC_duringRun.py:23
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
Propagator::Propagator
Propagator(PropagationDirection dir=alongMomentum)
Definition: Propagator.h:46
Generated for CMSSW Reference Manual by doxygen 1.8.16