#include <AnalyticalPropagator.h>

Inheritance diagram for AnalyticalPropagator:

Public Member Functions
	AnalyticalPropagator (const MagneticField *field, PropagationDirection dir=alongMomentum, float maxDPhi=1.6)

virtual AnalyticalPropagator *	clone () const

TrajectoryStateOnSurface	propagate (const FreeTrajectoryState &fts, const Plane &plane) const
	propagation to plane More...

TrajectoryStateOnSurface	propagate (const FreeTrajectoryState &fts, const Cylinder &cylinder) const
	propagation to cylinder More...

std::pair < TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &fts, const Plane &plane) const
	propagation to plane with path length More...

std::pair < TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &fts, const Cylinder &cylinder) const
	propagation to cylinder with path length More...

virtual bool	setMaxDirectionChange (float phiMax)

void	setMaxRelativeChangeInBz (const float maxDBz)

	~AnalyticalPropagator ()

Public Member Functions inherited from Propagator
virtual TrajectoryStateOnSurface	propagate (const FreeTrajectoryState &, const Surface &) const

virtual TrajectoryStateOnSurface	propagate (const TrajectoryStateOnSurface &, const Surface &) const

virtual TrajectoryStateOnSurface	propagate (const TrajectoryStateOnSurface &, const Plane &) const

virtual TrajectoryStateOnSurface	propagate (const TrajectoryStateOnSurface &, const Cylinder &) const

virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &, const reco::BeamSpot &) const

virtual std::pair < TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Surface &) const

virtual std::pair < TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &, const Surface &) const

virtual std::pair < TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &, const Plane &) const

virtual std::pair < TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &, const Cylinder &) const

virtual std::pair < FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &, const GlobalPoint &, const GlobalPoint &) const

virtual PropagationDirection	propagationDirection () const

	Propagator (PropagationDirection dir=alongMomentum)

virtual void	setPropagationDirection (PropagationDirection dir) const

virtual	~Propagator ()

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

Private Member Functions
virtual const MagneticField *	magneticField () const

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 Plane &, GlobalPoint &, double &) const
	straight line parameter propagation to a plane More...

bool	propagateWithLineCrossing (const GlobalPoint &, const GlobalVector &, const Cylinder &, GlobalPoint &, double &) const
	straight line parameter propagation to a cylinder More...

Private Attributes
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

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

private

Definition at line 125 of file AnalyticalPropagator.h.

Constructor & Destructor Documentation

AnalyticalPropagator::AnalyticalPropagator	(	const MagneticField *	field,
		PropagationDirection	dir = `alongMomentum`,
		float	maxDPhi = `1.6`
	)

inline

Definition at line 26 of file AnalyticalPropagator.h.

Referenced by clone().

                                  :
     Propagator(dir),
     theMaxDPhi2(maxDPhi*maxDPhi),
     theMaxDBzRatio(0.5),
     theField(field) {}

AnalyticalPropagator::~AnalyticalPropagator ( )

inline

Definition at line 34 of file AnalyticalPropagator.h.

34 {}

Member Function Documentation

virtual AnalyticalPropagator* AnalyticalPropagator::clone ( void ) const

inlinevirtual

Implements Propagator.

Definition at line 73 of file AnalyticalPropagator.h.

References AnalyticalPropagator().

   {
     return new AnalyticalPropagator(*this);
   }

virtual const MagneticField* AnalyticalPropagator::magneticField ( ) const

inlineprivatevirtual

Implements Propagator.

Definition at line 122 of file AnalyticalPropagator.h.

References theField.

122 {return theField;}

AnalyticalPropagator::theField

const MagneticField * theField

Definition: AnalyticalPropagator.h:128

TrajectoryStateOnSurface AnalyticalPropagator::propagate	(	const FreeTrajectoryState &	fts,
		const Plane &	plane
	)		const

inlinevirtual

propagation to plane

Implements Propagator.

Definition at line 46 of file AnalyticalPropagator.h.

References propagateWithPath().

Referenced by EMEnrichingFilterAlgo::applyBFieldCurv(), doubleEMEnrichingFilterAlgo::applyBFieldCurv(), TrackerValidationVariables::fillHitQuantities(), CosmicTrackingRegion::hits(), RoadSearchTrackCandidateMakerAlgorithm::PrepareTrackCandidates(), TrackingRecHitPropagator::project(), RecHitPropagator::propagate(), spr::propagateCalo(), cms::MuonTCMETValueMapProducer::propagateTrack(), TCMETAlgo::propagateTrack(), spr::propagateTrackerEnd(), TauTagTools::propagTrackECALSurfContactPoint(), KalmanAlignmentTrackRefitter::refitSingleTracklet(), PerigeeRefittedTrackState::trajectoryStateOnSurface(), and KinematicRefittedTrackState::trajectoryStateOnSurface().

                                                                {
     return propagateWithPath(fts,plane).first;
   }

TrajectoryStateOnSurface AnalyticalPropagator::propagate	(	const FreeTrajectoryState &	fts,
		const Cylinder &	cylinder
	)		const

inlinevirtual

propagation to cylinder

Implements Propagator.

Definition at line 56 of file AnalyticalPropagator.h.

References propagateWithPath().

                                                                      {
     return propagateWithPath(fts,cylinder).first;
   }

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

References SurfaceSideDefinition::afterSurface, alongMomentum, SurfaceSideDefinition::beforeSurface, FreeTrajectoryState::curvilinearError(), FreeTrajectoryState::hasError(), AnalyticalCurvilinearJacobian::jacobian(), CurvilinearTrajectoryError::matrix(), GlobalTrajectoryParameters::momentum(), FreeTrajectoryState::parameters(), GlobalTrajectoryParameters::position(), and asciidump::s.

 {
   //
   // for forward propagation: state is before surface,
   // for backward propagation: state is after surface
   //
   SurfaceSide side = PropagationDirectionFromPath()(s,propagationDirection())==alongMomentum 
     ? beforeSurface : afterSurface;
   // 
   //
   // error propagation (if needed) and conversion to a TrajectoryStateOnSurface
   //
   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 TsosWP(TrajectoryStateOnSurface(gtp,cte,surface,side),s);
   }
   else {
     //
     // return state without errors
     //
     return TsosWP(TrajectoryStateOnSurface(gtp,surface,side),s);
   }
 }

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

References ExpressReco_HICollisions_FallBack::e, PV3DBase< T, PVType, FrameType >::mag(), FreeTrajectoryState::momentum(), L1TEmulatorMonitor_cff::p, HelixBarrelCylinderCrossing::pathLength(), GloballyPositioned< T >::position(), FreeTrajectoryState::position(), rho, asciidump::s, FreeTrajectoryState::transverseCurvature(), Vector3DBase< T, FrameTag >::unit(), PV3DBase< T, PVType, FrameType >::x(), ExpressReco_HICollisions_FallBack::x, and PV3DBase< T, PVType, FrameType >::y().

 {
 
   GlobalPoint const & sp = cylinder.position();
   if (sp.x()!=0. || sp.y()!=0.) {
     throw PropagationException("Cannot propagate to an arbitrary cylinder");
   }
   // preset output
   x = fts.position();
   p = fts.momentum();
   s = 0;
   // (transverse) curvature
   double rho = fts.transverseCurvature();
   //
   // Straight line approximation? |rho|<1.e-10 equivalent to ~ 1um 
   // difference in transversal position at 10m.
   //
   if( fabs(rho)<1.e-10 )
     return propagateWithLineCrossing(fts.position(),p,cylinder,x,s);
   //
   // Helix case
   //
   // check for possible intersection
   const double tolerance = 1.e-4; // 1 micron distance
   double rdiff = x.perp() - cylinder.radius();
   if ( fabs(rdiff) < tolerance )  return true;
   //
   // Instantiate HelixBarrelCylinderCrossing and get solutions
   //
   HelixBarrelCylinderCrossing cylinderCrossing(fts.position(),fts.momentum(),rho,
                            propagationDirection(),cylinder);
   if ( !cylinderCrossing.hasSolution() )  return false;
   // path length
   s = cylinderCrossing.pathLength();
   // point
   x = cylinderCrossing.position();
   // direction (renormalised)
   p = cylinderCrossing.direction().unit()*fts.momentum().mag();
   return true;
 }

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

References ExpressReco_HICollisions_FallBack::e, PV3DBase< T, PVType, FrameType >::mag(), FreeTrajectoryState::momentum(), L1TEmulatorMonitor_cff::p, FreeTrajectoryState::position(), rho, asciidump::s, FreeTrajectoryState::transverseCurvature(), and ExpressReco_HICollisions_FallBack::x.

 {
   // initialisation of position, momentum and path length
   x = fts.position();
   p = fts.momentum();
   s = 0;
   // (transverse) curvature
   double rho = fts.transverseCurvature();
   //
   // Straight line approximation? |rho|<1.e-10 equivalent to ~ 1um 
   // difference in transversal position at 10m.
   //
   if( fabs(rho)<1.e-10 )
     return propagateWithLineCrossing(fts.position(),p,plane,x,s);
   //
   // Helix case 
   //
   GlobalVector u = plane.normalVector();
   const double small = 1.e-6; // for orientation of planes
   //
   // Frame-independant point and vector are created explicitely to 
   // avoid confusing gcc (refuses to compile with temporary objects
   // in the constructor).
   //
   HelixPlaneCrossing::PositionType helixPos(x);
   HelixPlaneCrossing::DirectionType helixDir(p);
   if (fabs(u.z()) < small) {
     // barrel plane:
     // instantiate HelixBarrelPlaneCrossing, get vector of solutions and check for existance
     HelixBarrelPlaneCrossingByCircle planeCrossing(helixPos,helixDir,rho,propagationDirection());
     return propagateWithHelixCrossing(planeCrossing,plane,fts.momentum().mag(),x,p,s);
   }
   if (fabs(u.x()) < small && fabs(u.y()) < small) {
     // forward plane:
     // instantiate HelixForwardPlaneCrossing, get vector of solutions and check for existance
     HelixForwardPlaneCrossing planeCrossing(helixPos,helixDir,rho,propagationDirection());
     return propagateWithHelixCrossing(planeCrossing,plane,fts.momentum().mag(),x,p,s);
   }
   else {
     // arbitrary plane:
     // instantiate HelixArbitraryPlaneCrossing, get vector of solutions and check for existance
     HelixArbitraryPlaneCrossing planeCrossing(helixPos,helixDir,rho,propagationDirection());
     return propagateWithHelixCrossing(planeCrossing,plane,fts.momentum().mag(),x,p,s);
   }
 }

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

References HelixPlaneCrossing::direction(), Basic3DVector< T >::mag(), HelixPlaneCrossing::pathLength(), and HelixPlaneCrossing::position().

                                            {
   // get solution
   std::pair<bool,double> propResult = planeCrossing.pathLength(plane);
   if ( !propResult.first )  return false;
   s = propResult.second;
   // point (reconverted to GlobalPoint)
   HelixPlaneCrossing::PositionType xGen = planeCrossing.position(s);
   x = GlobalPoint(xGen);
   // direction (reconverted to GlobalVector, renormalised)
   HelixPlaneCrossing::DirectionType pGen = planeCrossing.direction(s);
   pGen *= pmag/pGen.mag();
   p = GlobalVector(pGen);
   //
   return true;
 }

bool AnalyticalPropagator::propagateWithLineCrossing	(	const GlobalPoint &	x0,
		const GlobalVector &	p0,
		const Plane &	plane,
		GlobalPoint &	x,
		double &	s
	)		const

private

straight line parameter propagation to a plane

Definition at line 232 of file AnalyticalPropagator.cc.

References dir, StraightLinePlaneCrossing::pathLength(), pos, and StraightLinePlaneCrossing::position().

                                                           {
   //
   // 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).
   //
   StraightLinePlaneCrossing::PositionType pos(x0);
   StraightLinePlaneCrossing::DirectionType dir(p0);
   StraightLinePlaneCrossing planeCrossing(pos,dir,propagationDirection());
   //
   // get solution
   //
   std::pair<bool,double> propResult = planeCrossing.pathLength(plane);
   if ( !propResult.first )  return false;
   s = propResult.second;
   // point (reconverted to GlobalPoint)
   x = GlobalPoint(planeCrossing.position(s));
   //
   return true;
 }

bool AnalyticalPropagator::propagateWithLineCrossing	(	const GlobalPoint &	x0,
		const GlobalVector &	p0,
		const Cylinder &	cylinder,
		GlobalPoint &	x,
		double &	s
	)		const

private

straight line parameter propagation to a cylinder

Definition at line 258 of file AnalyticalPropagator.cc.

References StraightLineBarrelCylinderCrossing::pathLength(), and StraightLineBarrelCylinderCrossing::position().

                                                           {
   //
   // 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(x0,p0,propagationDirection());
   //
   // get solution
   //
   std::pair<bool,double> propResult = cylCrossing.pathLength(cylinder);
   if ( !propResult.first )  return false;
   s = propResult.second;
   // point (reconverted to GlobalPoint)
   x = cylCrossing.position(s);
   //
   return true;
 }

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

virtual

propagation to plane with path length

Implements Propagator.

Definition at line 28 of file AnalyticalPropagator.cc.

References FreeTrajectoryState::charge(), ExpressReco_HICollisions_FallBack::e, Plane::localZ(), LogDebug, PV3DBase< T, PVType, FrameType >::mag(), PV3DBase< T, PVType, FrameType >::mag2(), FreeTrajectoryState::momentum(), L1TEmulatorMonitor_cff::p, PV3DBase< T, PVType, FrameType >::perp2(), GloballyPositioned< T >::position(), FreeTrajectoryState::position(), rho, asciidump::s, FreeTrajectoryState::transverseCurvature(), and ExpressReco_HICollisions_FallBack::x.

Referenced by ReferenceTrajectory::construct(), TrackerValidationVariables::fillHitQuantities(), propagate(), DualTrajectoryFactory::propagateExternal(), DualBzeroTrajectoryFactory::propagateExternal(), and TwoBodyDecayTrajectoryState::propagateSingleState().

 {
   // check curvature
   double rho = fts.transverseCurvature();
   
   // propagate parameters
   GlobalPoint x;
   GlobalVector p;
   double s;
   
   // check if already on plane
   const float maxDistToPlane(0.1e-4);
   const float numericalPrecision(5.e-7);
   float maxDz = numericalPrecision*plane.position().mag();
   if ( fabs(plane.localZ(fts.position()))>(maxDistToPlane>maxDz?maxDistToPlane:maxDz) ) {
     // propagate
     bool parametersOK = this->propagateParametersOnPlane(fts, plane, x, p, s);
     // check status and deltaPhi limit
     float dphi2 = s*rho;
     dphi2 = dphi2*dphi2*fts.momentum().perp2()/fts.momentum().mag2();
     if ( !parametersOK || dphi2>theMaxDPhi2 )  return TsosWP(TrajectoryStateOnSurface(),0.);
   }
   else {
     LogDebug("AnalyticalPropagator")<<"not going anywhere. Already on surface.\n"
                     <<"plane.localZ(fts.position()): "<<plane.localZ(fts.position())<<"\n"
                     <<"maxDistToPlane: "<<maxDistToPlane<<"\n"
                     <<"maxDz: "<<maxDz<<"\n"
                     <<"plane.position().mag(): "<<plane.position().mag();
     x = fts.position();
     p = fts.momentum();
     s = 0.;
   }
   //
   // Compute propagated state and check change in curvature
   //
   GlobalTrajectoryParameters gtp(x,p,fts.charge(),theField);
   if ( fabs(rho)>1.e-10 && fabs((gtp.transverseCurvature()-rho)/rho)>theMaxDBzRatio ) 
     return TsosWP(TrajectoryStateOnSurface(),0.);
   //
   // construct TrajectoryStateOnSurface
   //
   return propagatedStateWithPath(fts,plane,gtp,s);
 }

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

virtual

propagation to cylinder with path length

Implements Propagator.

Definition at line 75 of file AnalyticalPropagator.cc.

References FreeTrajectoryState::charge(), PV3DBase< T, PVType, FrameType >::mag2(), FreeTrajectoryState::momentum(), L1TEmulatorMonitor_cff::p, PV3DBase< T, PVType, FrameType >::perp2(), rho, asciidump::s, Cylinder::tangentPlane(), FreeTrajectoryState::transverseCurvature(), and ExpressReco_HICollisions_FallBack::x.

 {
   // check curvature
   double rho = fts.transverseCurvature();
 
   // propagate parameters
   GlobalPoint x;
   GlobalVector p;
   double s = 0;
 
   bool parametersOK = this->propagateParametersOnCylinder(fts, cylinder, x, p, s);
   // check status and deltaPhi limit
   float dphi2 = s*rho;
   dphi2 = dphi2*dphi2*fts.momentum().perp2()/fts.momentum().mag2();
   if ( !parametersOK || dphi2>theMaxDPhi2 )  return TsosWP(TrajectoryStateOnSurface(),0.);
   //
   // Compute propagated state and check change in curvature
   //
   GlobalTrajectoryParameters gtp(x,p,fts.charge(),theField);
   if ( fabs(rho)>1.e-10 && fabs((gtp.transverseCurvature()-rho)/rho)>theMaxDBzRatio ) 
     return TsosWP(TrajectoryStateOnSurface(),0.);
   //
   // create result TSOS on TangentPlane (local parameters & errors are better defined)
   //
   ReferenceCountingPointer<TangentPlane> plane(cylinder.tangentPlane(x));  // need to be here until tsos is created!
   return propagatedStateWithPath(fts,*plane,gtp,s);
 }

virtual bool AnalyticalPropagator::setMaxDirectionChange ( float phiMax )

inlinevirtual

limitation of change in transverse direction (to avoid loops).

Reimplemented from Propagator.

Definition at line 67 of file AnalyticalPropagator.h.

References ExpressReco_HICollisions_FallBack::phiMax, and theMaxDPhi2.

                                                     { 
     theMaxDPhi2 = phiMax*phiMax;
     return true;
   }

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 85 of file AnalyticalPropagator.h.

References theMaxDBzRatio.

                                                      {
     theMaxDBzRatio = maxDBz;
   }

Member Data Documentation

const MagneticField* AnalyticalPropagator::theField

private

Definition at line 128 of file AnalyticalPropagator.h.

Referenced by magneticField().

float AnalyticalPropagator::theMaxDBzRatio

private

Definition at line 127 of file AnalyticalPropagator.h.

Referenced by setMaxRelativeChangeInBz().

float AnalyticalPropagator::theMaxDPhi2

private

Definition at line 126 of file AnalyticalPropagator.h.

Referenced by setMaxDirectionChange().

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation