|
|
|
#include <AnalyticalPropagator.h>
Public Member Functions | |
| AnalyticalPropagator (const MagneticField *field, PropagationDirection dir=alongMomentum, float maxDPhi=1.6, bool isOld=true) | |
| virtual AnalyticalPropagator * | clone () const |
| TrajectoryStateOnSurface | propagate (const FreeTrajectoryState &fts, const Cylinder &cylinder) const |
| propagation to cylinder | |
| TrajectoryStateOnSurface | propagate (const FreeTrajectoryState &fts, const Plane &plane) const |
| propagation to plane | |
| std::pair < TrajectoryStateOnSurface, double > | propagateWithPath (const FreeTrajectoryState &fts, const Plane &plane) const |
| propagation to plane with path length | |
| std::pair < TrajectoryStateOnSurface, double > | propagateWithPath (const FreeTrajectoryState &fts, const Cylinder &cylinder) const |
| propagation to cylinder with path length | |
| virtual bool | setMaxDirectionChange (float phiMax) |
| void | setMaxRelativeChangeInBz (const float maxDBz) |
| ~AnalyticalPropagator () | |
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 >p, const double &s) const dso_internal |
| propagation of errors (if needed) and generation of a new TSOS | |
| bool | propagateParametersOnCylinder (const FreeTrajectoryState &fts, const Cylinder &cylinder, GlobalPoint &x, GlobalVector &p, double &s) const dso_internal |
| parameter propagation to cylinder (returns position, momentum and path length) | |
| bool | propagateParametersOnPlane (const FreeTrajectoryState &fts, const Plane &plane, GlobalPoint &x, GlobalVector &p, double &s) const dso_internal |
| parameter propagation to plane (returns position, momentum and path length) | |
| bool | propagateWithHelixCrossing (HelixPlaneCrossing &, const Plane &, const float, GlobalPoint &, GlobalVector &, double &s) const dso_internal |
| helix parameter propagation to a plane using HelixPlaneCrossing | |
| bool | propagateWithLineCrossing (const GlobalPoint &, const GlobalVector &, const Cylinder &, GlobalPoint &, double &) const dso_internal |
| straight line parameter propagation to a cylinder | |
| bool | propagateWithLineCrossing (const GlobalPoint &, const GlobalVector &, const Plane &, GlobalPoint &, double &) const dso_internal |
| straight line parameter propagation to a plane | |
Private Attributes | |
| bool | isOldPropagationType |
| const MagneticField * | theField |
| float | theMaxDBzRatio |
| float | theMaxDPhi2 |
(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 23 of file AnalyticalPropagator.h.
typedef std::pair<TrajectoryStateOnSurface,double> AnalyticalPropagator::TsosWP [private] |
Definition at line 127 of file AnalyticalPropagator.h.
| AnalyticalPropagator::AnalyticalPropagator | ( | const MagneticField * | field, |
| PropagationDirection | dir = alongMomentum, |
||
| float | maxDPhi = 1.6, |
||
| bool | isOld = true |
||
| ) | [inline] |
Definition at line 27 of file AnalyticalPropagator.h.
Referenced by clone().
:
Propagator(dir),
theMaxDPhi2(maxDPhi*maxDPhi),
theMaxDBzRatio(0.5),
theField(field),
isOldPropagationType(isOld) {}
| AnalyticalPropagator::~AnalyticalPropagator | ( | ) | [inline] |
Definition at line 36 of file AnalyticalPropagator.h.
{}
| virtual AnalyticalPropagator* AnalyticalPropagator::clone | ( | void | ) | const [inline, virtual] |
Implements Propagator.
Definition at line 75 of file AnalyticalPropagator.h.
References AnalyticalPropagator().
{
return new AnalyticalPropagator(*this);
}
| virtual const MagneticField* AnalyticalPropagator::magneticField | ( | ) | const [inline, private, virtual] |
Implements Propagator.
Definition at line 124 of file AnalyticalPropagator.h.
References theField.
{return theField;}
| TrajectoryStateOnSurface AnalyticalPropagator::propagate | ( | const FreeTrajectoryState & | fts, |
| const Cylinder & | cylinder | ||
| ) | const [inline, virtual] |
propagation to cylinder
Implements Propagator.
Definition at line 58 of file AnalyticalPropagator.h.
References propagateWithPath().
{
return propagateWithPath(fts,cylinder).first;
}
| TrajectoryStateOnSurface AnalyticalPropagator::propagate | ( | const FreeTrajectoryState & | fts, |
| const Plane & | plane | ||
| ) | const [inline, virtual] |
propagation to plane
Implements Propagator.
Definition at line 48 of file AnalyticalPropagator.h.
References propagateWithPath().
Referenced by EMEnrichingFilterAlgo::applyBFieldCurv(), doubleEMEnrichingFilterAlgo::applyBFieldCurv(), CosmicTrackingRegion::hits(), RoadSearchTrackCandidateMakerAlgorithm::PrepareTrackCandidates(), TrackingRecHitPropagator::project(), RecHitPropagator::propagate(), spr::propagateCalo(), TCMETAlgo::propagateTrack(), cms::MuonTCMETValueMapProducer::propagateTrack(), spr::propagateTrackerEnd(), TauTagTools::propagTrackECALSurfContactPoint(), KalmanAlignmentTrackRefitter::refitSingleTracklet(), KinematicRefittedTrackState::trajectoryStateOnSurface(), and PerigeeRefittedTrackState::trajectoryStateOnSurface().
{
return propagateWithPath(fts,plane).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 115 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 alignCSCRings::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 147 of file AnalyticalPropagator.cc.
References alignCSCRings::e, PV3DBase< T, PVType, FrameType >::mag(), FreeTrajectoryState::momentum(), AlCaHLTBitMon_ParallelJobs::p, HelixBarrelCylinderCrossing::pathLength(), GloballyPositioned< T >::position(), FreeTrajectoryState::position(), rho, alignCSCRings::s, FreeTrajectoryState::transverseCurvature(), Vector3DBase< T, FrameTag >::unit(), PV3DBase< T, PVType, FrameType >::x(), 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 191 of file AnalyticalPropagator.cc.
References HelixArbitraryPlaneCrossing::direction(), alignCSCRings::e, LogDebug, PV3DBase< T, PVType, FrameType >::mag(), Basic3DVector< T >::mag(), FreeTrajectoryState::momentum(), oppositeToMomentum, AlCaHLTBitMon_ParallelJobs::p, perp(), PV3DBase< T, PVType, FrameType >::phi(), HelixArbitraryPlaneCrossing::position(), FreeTrajectoryState::position(), rho, alignCSCRings::s, indexGen::s2, FreeTrajectoryState::transverseCurvature(), and 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 (isOldPropagationType && 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 (isOldPropagationType && 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
if(isOldPropagationType){
HelixArbitraryPlaneCrossing planeCrossing(helixPos,helixDir,rho,propagationDirection());
return propagateWithHelixCrossing(planeCrossing,plane,fts.momentum().mag(),x,p,s);
}else{
//--- Alternative implementation to be used for the propagation of the parameters of looping
// particles that cross twice the (infinite) surface of the plane. It is not trivial to determine
// which of the two intersections has to be returned.
//---- FIXME: WHAT FOLLOWS HAS TO BE REWRITTEN IN A CLEANER (AND CPU-OPTIMIZED) WAY ---------
LogDebug("AnalyticalPropagator") << "In AnaliticalProp, calling HAPC " << "\n"
<< "plane is centered in xyz: "
<< plane.position().x() << " , "
<< plane.position().y() << " , "
<< plane.position().z() << "\n";
GlobalPoint gp1 = fts.position();
GlobalVector gm1 = fts.momentum();
double s1 = 0;
double rho1 = fts.transverseCurvature();
HelixPlaneCrossing::PositionType helixPos1(gp1);
HelixPlaneCrossing::DirectionType helixDir1(gm1);
LogDebug("AnalyticalPropagator") << "gp1 before calling planeCrossing1: " << gp1 << "\n";
HelixArbitraryPlaneCrossing planeCrossing1(helixPos1,helixDir1,rho1,propagationDirection());
HelixPlaneCrossing::PositionType xGen;
HelixPlaneCrossing::DirectionType pGen;
double tolerance(0.0050);
if(propagationDirection()==oppositeToMomentum)
tolerance *=-1;
bool check1 = propagateWithHelixCrossing(planeCrossing1,plane,fts.momentum().mag(),gp1,gm1,s1);
double dphi1 = fabs(fts.momentum().phi()-gm1.phi());
LogDebug("AnalyticalPropagator") << "check1, s1, dphi, gp1: "
<< check1 << " , "
<< s1 << " , "
<< dphi1 << " , "
<< gp1 << "\n";
//move forward a bit to avoid that the propagator doesn't propagate because the state is already on surface.
//we want to go to the other point of intersection between the helix and the plane
xGen = planeCrossing1.position(s1+tolerance);
pGen = planeCrossing1.direction(s1+tolerance);
/*
if(!check1 || s1>170 ){
//PropagationDirection newDir = (propagationDirection() == alongMomentum) ? oppositeToMomentum : alongMomentum;
PropagationDirection newDir = anyDirection;
HelixArbitraryPlaneCrossing planeCrossing1B(helixPos1,helixDir1,rho1,newDir);
check1 = propagateWithHelixCrossing(planeCrossing1B,plane,fts.momentum().mag(),gp1,gm1,s1);
LogDebug("AnalyticalPropagator") << "after second attempt, check1, s1,gp1: "
<< check1 << " , "
<< s1 << " , " << gp1 << "\n";
xGen = planeCrossing1B.position(s1+tolerance);
pGen = planeCrossing1B.direction(s1+tolerance);
}
*/
if(!check1){
LogDebug("AnalyticalPropagator") << "failed also second attempt. No idea what to do, then bailout" << "\n";
}
pGen *= gm1.mag()/pGen.mag();
GlobalPoint gp2(xGen);
GlobalVector gm2(pGen);
double s2 = 0;
double rho2 = rho1;
HelixPlaneCrossing::PositionType helixPos2(gp2);
HelixPlaneCrossing::DirectionType helixDir2(gm2);
HelixArbitraryPlaneCrossing planeCrossing2(helixPos2,helixDir2,rho2,propagationDirection());
bool check2 = propagateWithHelixCrossing(planeCrossing2,plane,gm2.mag(),gp2,gm2,s2);
if(!check2){
x = gp1;
p = gm1;
s = s1;
return check1;
}
if(!check1){
edm::LogError("AnalyticalPropagator") << "LOGIC ERROR: I should not have entered here!" << "\n";
return false;
}
LogDebug("AnalyticalPropagator") << "check2, s2, gp2: "
<< check2 << " , "
<< s2 << " , " << gp2 << "\n";
double dist1 = (plane.position()-gp1).perp();
double dist2 = (plane.position()-gp2).perp();
LogDebug("AnalyticalPropagator") << "propDir, dist1, dist2: "
<< propagationDirection() << " , "
<< dist1 << " , "
<< dist2 << "\n";
//If there are two solutions, the one which is the closest to the module's center is chosen
if(dist1<2*dist2){
x = gp1;
p = gm1;
s = s1;
return check1;
}else if(dist2<2*dist1){
x = gp2;
p = gm2;
s = s1+s2+tolerance;
return check2;
}else{
if(fabs(s1)<fabs(s2)){
x = gp1;
p = gm1;
s = s1;
return check1;
}else{
x = gp2;
p = gm2;
s = s1+s2+tolerance;
return check2;
}
}
//-------- END of ugly piece of code ---------------
}
}
}
| 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 421 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 371 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 397 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(), alignCSCRings::e, Plane::localZ(), LogDebug, PV3DBase< T, PVType, FrameType >::mag2(), FreeTrajectoryState::momentum(), AlCaHLTBitMon_ParallelJobs::p, PV3DBase< T, PVType, FrameType >::perp2(), GloballyPositioned< T >::position(), FreeTrajectoryState::position(), rho, alignCSCRings::s, FreeTrajectoryState::transverseCurvature(), and x.
Referenced by ReferenceTrajectory::construct(), propagate(), DualBzeroTrajectoryFactory::propagateExternal(), DualTrajectoryFactory::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(), AlCaHLTBitMon_ParallelJobs::p, PV3DBase< T, PVType, FrameType >::perp2(), rho, alignCSCRings::s, Cylinder::tangentPlane(), FreeTrajectoryState::transverseCurvature(), and 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)
//
//try {
ReferenceCountingPointer<TangentPlane> plane(cylinder.tangentPlane(x)); // need to be here until tsos is created!
return propagatedStateWithPath(fts,*plane,gtp,s);
/*
} catch(...) {
std::cout << "wrong tangent to cylinder " << x
<< " pos, rad " << cylinder.position() << " " << cylinder.radius()
<< std::endl;
return TsosWP(TrajectoryStateOnSurface(),0.);
}
*/
}
| virtual bool AnalyticalPropagator::setMaxDirectionChange | ( | float | phiMax | ) | [inline, virtual] |
limitation of change in transverse direction (to avoid loops).
Reimplemented from Propagator.
Definition at line 69 of file AnalyticalPropagator.h.
References jptDQMConfig_cff::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 87 of file AnalyticalPropagator.h.
References theMaxDBzRatio.
{
theMaxDBzRatio = maxDBz;
}
bool AnalyticalPropagator::isOldPropagationType [private] |
Definition at line 131 of file AnalyticalPropagator.h.
const MagneticField* AnalyticalPropagator::theField [private] |
Definition at line 130 of file AnalyticalPropagator.h.
Referenced by magneticField().
float AnalyticalPropagator::theMaxDBzRatio [private] |
Definition at line 129 of file AnalyticalPropagator.h.
Referenced by setMaxRelativeChangeInBz().
float AnalyticalPropagator::theMaxDPhi2 [private] |
Definition at line 128 of file AnalyticalPropagator.h.
Referenced by setMaxDirectionChange().
1.7.3