#include <AnalyticalTrajectoryExtrapolatorToLine.h>

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

	AnalyticalTrajectoryExtrapolatorToLine (const Propagator &)
	constructor with alternative propagator More...

TrajectoryStateOnSurface	extrapolate (const FreeTrajectoryState &fts, const Line &L) const
	extrapolation from FreeTrajectoryState More...

TrajectoryStateOnSurface	extrapolate (const TrajectoryStateOnSurface tsos, const Line &L) const
	extrapolation from TrajectoryStateOnSurface More...

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

TrajectoryStateOnSurface	extrapolateSingleState (const FreeTrajectoryState &fts, const Line &line) const
	extrapolation of (single) FTS More...

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

Private Attributes
DeepCopyPointerByClone< Propagator >	thePropagator

Detailed Description

Extrapolate to the closest approach w.r.t. a line. This class is faster than the TrajectoryExtrapolatorToLine. The helix model is explicitely used in the determination of the target surface. This target surface is centered on the point of closest approach on the line. The axes of the local coordinate system (x_loc, y_loc, z_loc) are z_loc // trajectory direction at point of closest approach; x_loc normal to trajectory and along impact vector (line->helix); y_loc forms a right-handed system with the other axes.

Definition at line 28 of file AnalyticalTrajectoryExtrapolatorToLine.h.

Constructor & Destructor Documentation

◆ AnalyticalTrajectoryExtrapolatorToLine() [1/2]

AnalyticalTrajectoryExtrapolatorToLine::AnalyticalTrajectoryExtrapolatorToLine ( const MagneticField * field )

constructor with default geometrical propagator

Definition at line 14 of file AnalyticalTrajectoryExtrapolatorToLine.cc.

15 : thePropagator(new AnalyticalPropagator(field, anyDirection)) {}

◆ AnalyticalTrajectoryExtrapolatorToLine() [2/2]

AnalyticalTrajectoryExtrapolatorToLine::AnalyticalTrajectoryExtrapolatorToLine ( const Propagator & propagator )

constructor with alternative propagator

Definition at line 17 of file AnalyticalTrajectoryExtrapolatorToLine.cc.

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

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

Member Function Documentation

◆ extrapolate() [1/2]

TrajectoryStateOnSurface AnalyticalTrajectoryExtrapolatorToLine::extrapolate	(	const FreeTrajectoryState &	fts,
		const Line &	L
	)		const

extrapolation from FreeTrajectoryState

Definition at line 22 of file AnalyticalTrajectoryExtrapolatorToLine.cc.

                                                                                                      {
   return extrapolateSingleState(fts, line);
 }

References extrapolateSingleState(), and mps_splice::line.

Referenced by SignedDecayLength3D::closestApproachToJet(), SignedImpactParameter3D::closestApproachToJet(), and IPTools::closestApproachToJet().

◆ extrapolate() [2/2]

TrajectoryStateOnSurface AnalyticalTrajectoryExtrapolatorToLine::extrapolate	(	const TrajectoryStateOnSurface	tsos,
		const Line &	L
	)		const

extrapolation from TrajectoryStateOnSurface

Definition at line 27 of file AnalyticalTrajectoryExtrapolatorToLine.cc.

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

References extrapolateFullState(), TrajectoryStateOnSurface::isValid(), and mps_splice::line.

◆ extrapolateFullState()

TrajectoryStateOnSurface AnalyticalTrajectoryExtrapolatorToLine::extrapolateFullState	(	const TrajectoryStateOnSurface	tsos,
		const Line &	line
	)		const

private

extrapolation of (multi) TSOS

Definition at line 35 of file AnalyticalTrajectoryExtrapolatorToLine.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(), line);
   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(), mps_splice::line, Propagator::propagate(), TrajectoryStateOnSurface::singleState(), TrajectoryStateOnSurface::surface(), and thePropagator.

Referenced by extrapolate().

◆ extrapolateSingleState()

TrajectoryStateOnSurface AnalyticalTrajectoryExtrapolatorToLine::extrapolateSingleState	(	const FreeTrajectoryState &	fts,
		const Line &	line
	)		const

private

extrapolation of (single) FTS

Definition at line 50 of file AnalyticalTrajectoryExtrapolatorToLine.cc.

                                                                                                                 {
   //   static TimingReport::Item& timer = detailedDetTimer("AnalyticalTrajectoryExtrapolatorToLine");
   //   TimeMe t(timer,false);
   //
   // 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) {
     Line tangent(x, p);
     GlobalPoint xold(x);
     x = tangent.closerPointToLine(line);
     GlobalVector dx(x - xold);
     float sign = p.dot(x - xold);
     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, line, 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
   //
   GlobalPoint origin(line.closerPointToLine(Line(x, p)));
   GlobalVector zLocal(p.unit());
   GlobalVector yLocal(zLocal.cross(x - origin).unit());
   GlobalVector xLocal(yLocal.cross(zLocal));
   Surface::RotationType rot(xLocal, yLocal, zLocal);
   PlaneBuilder::ReturnType surface = PlaneBuilder().plane(origin, rot);
   //
   // Compute propagated state
   //
   GlobalTrajectoryParameters gtp(x, p, fts.charge(), thePropagator->magneticField());
   if (fts.hasError()) {
     //
     // compute jacobian
     //
     AnalyticalCurvilinearJacobian analyticalJacobian(fts.parameters(), gtp.position(), gtp.momentum(), s);
     const AlgebraicMatrix55& jacobian = analyticalJacobian.jacobian();
     CurvilinearTrajectoryError cte(ROOT::Math::Similarity(jacobian, fts.curvilinearError().matrix()));
     return TrajectoryStateOnSurface(gtp, cte, *surface);
   } else {
     //
     // return state without errors
     //
     return TrajectoryStateOnSurface(gtp, *surface);
   }
 }

References anyDirection, FreeTrajectoryState::charge(), Line::closerPointToLine(), FreeTrajectoryState::curvilinearError(), PVValHelper::dx, MillePedeFileConverter_cfg::e, FreeTrajectoryState::hasError(), AnalyticalCurvilinearJacobian::jacobian(), mps_splice::line, Propagator::magneticField(), 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, thePropagator, FreeTrajectoryState::transverseCurvature(), and x.

Referenced by extrapolate(), and extrapolateFullState().

◆ propagateWithHelix()

bool AnalyticalTrajectoryExtrapolatorToLine::propagateWithHelix	(	const IterativeHelixExtrapolatorToLine &	extrapolator,
		const Line &	line,
		GlobalPoint &	x,
		GlobalVector &	p,
		double &	s
	)		const

private

the actual propagation to a new point & momentum vector

Definition at line 114 of file AnalyticalTrajectoryExtrapolatorToLine.cc.

                                                                                  {
   //
   // save absolute value of momentum
   //
   double pmag(p.mag());
   //
   // get path length to solution
   //
   std::pair<bool, double> propResult = extrapolator.pathLength(line);
   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;
 }