#include <AnalyticalImpactPointExtrapolator.h>

Public Member Functions
	AnalyticalImpactPointExtrapolator (const MagneticField *field)
	constructor with default geometrical propagator More...

	AnalyticalImpactPointExtrapolator (const Propagator &, const MagneticField *)
	constructor with alternative propagator More...

TrajectoryStateOnSurface	extrapolate (const FreeTrajectoryState &fts, const GlobalPoint &vtx) const
	extrapolation from FreeTrajectoryState More...

TrajectoryStateOnSurface	extrapolate (const TrajectoryStateOnSurface tsos, const GlobalPoint &vtx) const
	as above, but from TrajectoryStateOnSurface More...

Private Member Functions
TrajectoryStateOnSurface	extrapolateFullState (const TrajectoryStateOnSurface tsos, const GlobalPoint &vertex) const
	extrapolation of (multi) TSOS More...

TrajectoryStateOnSurface	extrapolateSingleState (const FreeTrajectoryState &fts, const GlobalPoint &vertex) const
	extrapolation of (single) FTS More...

bool	propagateWithHelix (const IterativeHelixExtrapolatorToLine &extrapolator, const GlobalPoint &vertex, GlobalPoint &x, GlobalVector &p, double &s) const
	the actual propagation to a new point & momentum vector More...

Private Attributes
const MagneticField *	theField

DeepCopyPointerByClone< Propagator >	thePropagator

Detailed Description

Extrapolate to impact point with respect to vtx, i.e. to the point of closest approach to vtx in 3D. It is slightly faster than the ImpactPointExtrapolator. The helix model is explicitely used in the determination of the target surface. This target surface is centered on vtx; the axes of the local coordinate system (x_loc, y_loc, z_loc) are z_loc // trajectory direction at impact point; x_loc normal to trajectory and along impact vector (impact point - vtx); y_loc forms a right-handed system with the other axes.

Definition at line 26 of file AnalyticalImpactPointExtrapolator.h.

Constructor & Destructor Documentation

◆ AnalyticalImpactPointExtrapolator() [1/2]

AnalyticalImpactPointExtrapolator::AnalyticalImpactPointExtrapolator ( const MagneticField * field )

constructor with default geometrical propagator

Definition at line 12 of file AnalyticalImpactPointExtrapolator.cc.

13 : thePropagator(new AnalyticalPropagator(field, anyDirection)), theField(field) {}

◆ AnalyticalImpactPointExtrapolator() [2/2]

AnalyticalImpactPointExtrapolator::AnalyticalImpactPointExtrapolator	(	const Propagator &	propagator,
		const MagneticField *	field
	)

constructor with alternative propagator

Definition at line 15 of file AnalyticalImpactPointExtrapolator.cc.

     : thePropagator(propagator.clone()), theField(field) {
   thePropagator->setPropagationDirection(anyDirection);
 }

References anyDirection, Propagator::setPropagationDirection(), and thePropagator.

Member Function Documentation

◆ extrapolate() [1/2]

TrajectoryStateOnSurface AnalyticalImpactPointExtrapolator::extrapolate	(	const FreeTrajectoryState &	fts,
		const GlobalPoint &	vtx
	)		const

extrapolation from FreeTrajectoryState

Definition at line 21 of file AnalyticalImpactPointExtrapolator.cc.

                                                                                                       {
   //   static TimingReport::Item& timer = detailedDetTimer("AnalyticalImpactPointExtrapolator");
   //   TimeMe t(timer,false);
  
   return extrapolateSingleState(fts, vtx);
 }

References extrapolateSingleState(), and badGlobalMuonTaggersAOD_cff::vtx.

◆ extrapolate() [2/2]

TrajectoryStateOnSurface AnalyticalImpactPointExtrapolator::extrapolate	(	const TrajectoryStateOnSurface	tsos,
		const GlobalPoint &	vtx
	)		const

as above, but from TrajectoryStateOnSurface

Definition at line 29 of file AnalyticalImpactPointExtrapolator.cc.

                                                                                                       {
   if (tsos.isValid())
     return extrapolateFullState(tsos, vtx);
   else
     return tsos;
 }

References extrapolateFullState(), TrajectoryStateOnSurface::isValid(), and badGlobalMuonTaggersAOD_cff::vtx.

◆ extrapolateFullState()

TrajectoryStateOnSurface AnalyticalImpactPointExtrapolator::extrapolateFullState	(	const TrajectoryStateOnSurface	tsos,
		const GlobalPoint &	vertex
	)		const

private

extrapolation of (multi) TSOS

Definition at line 37 of file AnalyticalImpactPointExtrapolator.cc.

                                                                                                                   {
   //
   // first determine IP plane using propagation with (single) FTS
   // could be optimised (will propagate errors even if duplicated below)
   //
   TrajectoryStateOnSurface singleState = extrapolateSingleState(*tsos.freeTrajectoryState(), vertex);
   if (!singleState.isValid() || tsos.singleState())
     return singleState;
   //
   // propagate multiTsos to plane found above
   //
   return thePropagator->propagate(tsos, singleState.surface());
 }

References extrapolateSingleState(), TrajectoryStateOnSurface::freeTrajectoryState(), TrajectoryStateOnSurface::isValid(), Propagator::propagate(), TrajectoryStateOnSurface::singleState(), TrajectoryStateOnSurface::surface(), thePropagator, and bphysicsOniaDQM_cfi::vertex.

Referenced by extrapolate().

◆ extrapolateSingleState()

TrajectoryStateOnSurface AnalyticalImpactPointExtrapolator::extrapolateSingleState	(	const FreeTrajectoryState &	fts,
		const GlobalPoint &	vertex
	)		const

private

extrapolation of (single) FTS

Definition at line 52 of file AnalyticalImpactPointExtrapolator.cc.

                                                                                                                     {
   //
   // initialisation of position, momentum and transverse curvature
   //
   GlobalPoint x(fts.position());
   GlobalVector p(fts.momentum());
   double rho = fts.transverseCurvature();
   //
   // Straight line approximation? |rho|<1.e-10 equivalent to ~ 1um
   // difference in transversal position at 10m.
   //
   double s(0);
   if (fabs(rho) < 1.e-10) {
     GlobalVector dx(p.dot(vertex - x) / p.mag2() * p);
     x += dx;
     float sign = p.dot(dx);
     s = sign > 0 ? dx.mag() : -dx.mag();
   }
   //
   // Helix case
   //
   else {
     HelixLineExtrapolation::PositionType helixPos(x);
     HelixLineExtrapolation::DirectionType helixDir(p);
     IterativeHelixExtrapolatorToLine extrapolator(helixPos, helixDir, rho, anyDirection);
     if (!propagateWithHelix(extrapolator, vertex, x, p, s))
       return TrajectoryStateOnSurface();
   }
   //
   // Define target surface: origin on line, x_local from line
   //   to helix at closest approach, z_local along the helix
   //   and y_local to complete right-handed system
   //
   GlobalVector zLocal(p.unit());
   GlobalVector yLocal(zLocal.cross(x - vertex).unit());
   GlobalVector xLocal(yLocal.cross(zLocal));
   Surface::RotationType rot(xLocal, yLocal, zLocal);
   PlaneBuilder::ReturnType surface = PlaneBuilder().plane(vertex, rot);
   //
   // Compute propagated state
   //
   GlobalTrajectoryParameters gtp(x, p, fts.charge(), theField);
   if (fts.hasError()) {
     //
     // compute jacobian
     //
     AnalyticalCurvilinearJacobian analyticalJacobian(fts.parameters(), gtp.position(), gtp.momentum(), s);
     CurvilinearTrajectoryError cte(
         ROOT::Math::Similarity(analyticalJacobian.jacobian(), fts.curvilinearError().matrix()));
     return TrajectoryStateOnSurface(gtp, cte, *surface);
   } else {
     //
     // return state without errors
     //
     return TrajectoryStateOnSurface(gtp, *surface);
   }
 }

References anyDirection, FreeTrajectoryState::charge(), FreeTrajectoryState::curvilinearError(), PVValHelper::dx, MillePedeFileConverter_cfg::e, FreeTrajectoryState::hasError(), CurvilinearTrajectoryError::matrix(), FreeTrajectoryState::momentum(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::parameters(), PlaneBuilder::plane(), GlobalTrajectoryParameters::position(), FreeTrajectoryState::position(), propagateWithHelix(), rho, makeMuonMisalignmentScenario::rot, alignCSCRings::s, Validation_hcalonly_cfi::sign, theField, FreeTrajectoryState::transverseCurvature(), bphysicsOniaDQM_cfi::vertex, and x.

Referenced by extrapolate(), and extrapolateFullState().

◆ propagateWithHelix()

bool AnalyticalImpactPointExtrapolator::propagateWithHelix	(	const IterativeHelixExtrapolatorToLine &	extrapolator,
		const GlobalPoint &	vertex,
		GlobalPoint &	x,
		GlobalVector &	p,
		double &	s
	)		const

private

the actual propagation to a new point & momentum vector

Definition at line 111 of file AnalyticalImpactPointExtrapolator.cc.

                                                                             {
   //
   // save absolute value of momentum
   //
   double pmag(p.mag());
   //
   // get path length to solution
   //
   std::pair<bool, double> propResult = extrapolator.pathLength(vertex);
   if (!propResult.first)
     return false;
   s = propResult.second;
   //
   // get point and (normalised) direction from path length
   //
   HelixLineExtrapolation::PositionType xGen = extrapolator.position(s);
   HelixLineExtrapolation::DirectionType pGen = extrapolator.direction(s);
   //
   // Fix normalisation and convert back to GlobalPoint / GlobalVector
   //
   x = GlobalPoint(xGen);
   pGen *= pmag / pGen.mag();
   p = GlobalVector(pGen);
   //
   return true;
 }