Propagate an object (usually a track) to the second muon station. Support for other muon stations will be added on request. More...

#include "MuonAnalysis/MuonAssociators/interface/PropagateToMuon.h"

Public Member Functions
TrajectoryStateOnSurface	extrapolate (const reco::Track &tk) const
	Extrapolate reco::Track to the muon station 2, return an invalid TSOS if it fails. More...

TrajectoryStateOnSurface	extrapolate (const reco::Candidate &tk) const
	Extrapolate reco::Candidate to the muon station 2, return an invalid TSOS if it fails. More...

TrajectoryStateOnSurface	extrapolate (const SimTrack &tk, const edm::SimVertexContainer &vtxs) const

TrajectoryStateOnSurface	extrapolate (const FreeTrajectoryState &state) const
	Extrapolate a FreeTrajectoryState to the muon station 2, return an invalid TSOS if it fails. More...

	PropagateToMuon ()

	PropagateToMuon (edm::ESHandle< MagneticField >, edm::ESHandle< Propagator >, edm::ESHandle< Propagator >, edm::ESHandle< Propagator >, edm::ESHandle< MuonDetLayerGeometry >, bool, bool, bool, WhichTrack, WhichState, bool, bool)

	~PropagateToMuon ()

Private Member Functions
TrajectoryStateOnSurface	getBestDet (const TrajectoryStateOnSurface &tsos, const DetLayer *station) const
	Get the best TSOS on one of the chambres of this DetLayer, or an invalid TSOS if none match. More...

FreeTrajectoryState	startingState (const reco::Candidate &reco) const
	Starting state for the propagation. More...

FreeTrajectoryState	startingState (const reco::Track &tk) const
	Starting state for the propagation. More...

FreeTrajectoryState	startingState (const SimTrack &tk, const edm::SimVertexContainer &vtxs) const
	Starting state for the propagation. More...

Private Attributes
const BoundCylinder *	barrelCylinder_

double	barrelHalfLength_

bool	cosmicPropagation_
	for cosmics, some things change: the along-opposite is not in-out, nor the innermost/outermost states are in-out really More...

const BoundDisk *	endcapDiskNeg_ [3]

const BoundDisk *	endcapDiskPos_ [3]

std::pair< float, float >	endcapRadii_ [3]

bool	fallbackToME1_
	Fallback to ME1 if propagation to ME2 fails. More...

edm::ESHandle< MagneticField >	magfield_

edm::ESHandle < MuonDetLayerGeometry >	muonGeometry_

edm::ESHandle< Propagator >	propagator_

edm::ESHandle< Propagator >	propagatorAny_

edm::ESHandle< Propagator >	propagatorOpposite_

bool	useMB2_

bool	useMB2InOverlap_

bool	useSimpleGeometry_

WhichState	whichState_

WhichTrack	whichTrack_
	Labels for input collections. More...

Detailed Description

Propagate an object (usually a track) to the second muon station. Support for other muon stations will be added on request.

Propagate an object (usually a track) to the second (default) or first muon station.

"HLTriggerOffline/Muon/interface/PropagateToMuon.h"

Author: Giovanni Petrucciani

Definition at line 31 of file PropagateToMuon.h.

Constructor & Destructor Documentation

PropagateToMuon::PropagateToMuon ( )

inlineexplicit

Definition at line 33 of file PropagateToMuon.h.

33 {}

PropagateToMuon::PropagateToMuon	(	edm::ESHandle< MagneticField >	magfield,
		edm::ESHandle< Propagator >	propagator,
		edm::ESHandle< Propagator >	propagatorAny,
		edm::ESHandle< Propagator >	propagatorOpposite,
		edm::ESHandle< MuonDetLayerGeometry >	muonGeometry,
		bool	useSimpleGeometry,
		bool	useMB2,
		bool	fallbackToME1,
		WhichTrack	whichTrack,
		WhichState	whichState,
		bool	cosmicPropagation,
		bool	useMB2InOverlap
	)

explicit

Definition at line 14 of file PropagateToMuon.cc.

References barrelCylinder_, barrelHalfLength_, endcapDiskNeg_, endcapDiskPos_, endcapRadii_, mps_fire::i, muonGeometry_, GeometricSearchDet::surface(), useMB2_, and useMB2InOverlap_.

     : magfield_(magfield),
       propagator_(propagator),
       propagatorAny_(propagatorAny),
       propagatorOpposite_(propagatorOpposite),
       muonGeometry_(muonGeometry),
       useSimpleGeometry_(useSimpleGeometry),
       useMB2_(useMB2),
       fallbackToME1_(fallbackToME1),
       whichTrack_(whichTrack),
       whichState_(whichState),
       cosmicPropagation_(cosmicPropagation),
       useMB2InOverlap_(useMB2InOverlap) {
   // Get the barrel cylinder
   const DetLayer *dtLay = muonGeometry_->allDTLayers()[useMB2_ ? 1 : 0];
   barrelCylinder_ = dynamic_cast<const BoundCylinder *>(&dtLay->surface());
   barrelHalfLength_ = barrelCylinder_->bounds().length() / 2;
   ;
   //std::cout << "L1MuonMatcher: barrel radius = " << barrelCylinder_->radius() << ", half length = " << barrelHalfLength_ << std::endl;
 
   // Get the endcap disks. Note that ME1 has two disks (ME1/1 and ME2/1-ME3/2-ME4/1), so there's one more index
   for (size_t i = 0; i <= (useMB2_ ? 2 : 1); ++i) {
     endcapDiskPos_[i] = dynamic_cast<const BoundDisk *>(&muonGeometry_->forwardCSCLayers()[i]->surface());
     endcapDiskNeg_[i] = dynamic_cast<const BoundDisk *>(&muonGeometry_->backwardCSCLayers()[i]->surface());
     endcapRadii_[i] = std::make_pair(endcapDiskPos_[i]->innerRadius(), endcapDiskPos_[i]->outerRadius());
     //std::cout << "L1MuonMatcher: endcap " << i << " Z = " << endcapDiskPos_[i]->position().z() << ", radii = " << endcapRadii_[i].first << "," << endcapRadii_[i].second << std::endl;
   }
 
   if (useMB2_ && useMB2InOverlap_)
     barrelHalfLength_ = endcapDiskPos_[2]->position().z();
 }

PropagateToMuon::~PropagateToMuon ( )

inline

Definition at line 46 of file PropagateToMuon.h.

46 {}

Member Function Documentation

TrajectoryStateOnSurface PropagateToMuon::extrapolate ( const reco::Track & tk ) const

inline

Extrapolate reco::Track to the muon station 2, return an invalid TSOS if it fails.

Definition at line 49 of file PropagateToMuon.h.

References extrapolate(), and startingState().

Referenced by L1MuonMatcherAlgo::extrapolate(), extrapolate(), and MuonGmtPair::MuonGmtPair().

49 { return extrapolate(startingState(tk)); }

PropagateToMuon::extrapolate

TrajectoryStateOnSurface extrapolate(const reco::Track &tk) const

Extrapolate reco::Track to the muon station 2, return an invalid TSOS if it fails.

Definition: PropagateToMuon.h:49

PropagateToMuon::startingState

FreeTrajectoryState startingState(const reco::Candidate &reco) const

Starting state for the propagation.

Definition: PropagateToMuon.cc:57

TrajectoryStateOnSurface PropagateToMuon::extrapolate ( const reco::Candidate & tk ) const

inline

Extrapolate reco::Candidate to the muon station 2, return an invalid TSOS if it fails.

Definition at line 52 of file PropagateToMuon.h.

References extrapolate(), and startingState().

Referenced by extrapolate().

52 { return extrapolate(startingState(tk)); }

PropagateToMuon::extrapolate

TrajectoryStateOnSurface extrapolate(const reco::Track &tk) const

Extrapolate reco::Track to the muon station 2, return an invalid TSOS if it fails.

Definition: PropagateToMuon.h:49

PropagateToMuon::startingState

FreeTrajectoryState startingState(const reco::Candidate &reco) const

Starting state for the propagation.

Definition: PropagateToMuon.cc:57

TrajectoryStateOnSurface PropagateToMuon::extrapolate	(	const SimTrack &	tk,
		const edm::SimVertexContainer &	vtxs
	)		const

inline

Extrapolate a SimTrack to the muon station 2, return an invalid TSOS if it fails; needs the SimVertices too, to know where to start from Note: it will throw an exception if the SimTrack has no vertex.

Definition at line 57 of file PropagateToMuon.h.

References extrapolate(), and startingState().

                                                                                                     {
     return extrapolate(startingState(tk, vtxs));
   }

TrajectoryStateOnSurface PropagateToMuon::extrapolate ( const FreeTrajectoryState & state ) const

Extrapolate a FreeTrajectoryState to the muon station 2, return an invalid TSOS if it fails.

Definition at line 129 of file PropagateToMuon.cc.

References AtVertex, barrelCylinder_, barrelHalfLength_, cosmicPropagation_, Vector3DBase< T, FrameTag >::dot(), endcapDiskNeg_, endcapDiskPos_, endcapRadii_, PVValHelper::eta, PV3DBase< T, PVType, FrameType >::eta(), Exception, fallbackToME1_, first, getBestDet(), TrajectoryStateOnSurface::globalPosition(), edm::ESHandleBase::isValid(), sistrip::SpyUtilities::isValid(), TrajectoryStateOnSurface::isValid(), PV3DBase< T, PVType, FrameType >::mag(), magfield_, FreeTrajectoryState::momentum(), muonGeometry_, PV3DBase< T, PVType, FrameType >::perp(), FreeTrajectoryState::position(), position, Propagator::propagate(), propagator_, propagatorOpposite_, rho, edm::second(), useMB2_, useSimpleGeometry_, whichState_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                             {
   if (!magfield_.isValid() || barrelCylinder_ == nullptr) {
     throw cms::Exception("NotInitialized")
         << "PropagateToMuon: You must call init(const edm::EventSetup &iSetup) before using this object.\n";
   }
 
   TrajectoryStateOnSurface final;
   if (start.momentum().mag() == 0)
     return final;
   double eta = start.momentum().eta();
 
   const Propagator *propagatorBarrel = &*propagator_;
   const Propagator *propagatorEndcaps = &*propagator_;
   if (whichState_ != AtVertex) {
     if (start.position().perp() > barrelCylinder_->radius())
       propagatorBarrel = &*propagatorOpposite_;
     if (fabs(start.position().z()) > endcapDiskPos_[useMB2_ ? 2 : 1]->position().z())
       propagatorEndcaps = &*propagatorOpposite_;
   }
   if (cosmicPropagation_) {
     if (start.momentum().dot(GlobalVector(start.position().x(), start.position().y(), start.position().z())) < 0) {
       // must flip the propagations
       propagatorBarrel = (propagatorBarrel == &*propagator_ ? &*propagatorOpposite_ : &*propagator_);
       propagatorEndcaps = (propagatorEndcaps == &*propagator_ ? &*propagatorOpposite_ : &*propagator_);
     }
   }
 
   TrajectoryStateOnSurface tsos = propagatorBarrel->propagate(start, *barrelCylinder_);
   if (tsos.isValid()) {
     if (useSimpleGeometry_) {
       //std::cout << "  propagated to barrel, z = " << tsos.globalPosition().z() << ", bound = " << barrelHalfLength_ << std::endl;
       if (fabs(tsos.globalPosition().z()) <= barrelHalfLength_)
         final = tsos;
     } else {
       final = getBestDet(tsos, muonGeometry_->allDTLayers()[1]);
     }
   }
   if (!final.isValid()) {
     for (int ie = (useMB2_ ? 2 : 1); ie >= 0; --ie) {
       tsos = propagatorEndcaps->propagate(start, (eta > 0 ? *endcapDiskPos_[ie] : *endcapDiskNeg_[ie]));
       if (tsos.isValid()) {
         if (useSimpleGeometry_) {
           float rho = tsos.globalPosition().perp();
           //std::cout << "  propagated to endcap " << ie << ", rho = " << rho << ", bounds [ " << endcapRadii_[ie].first << ", " << endcapRadii_[ie].second << "]" << std::endl;
           if ((rho >= endcapRadii_[ie].first) && (rho <= endcapRadii_[ie].second))
             final = tsos;
         } else {
           final = getBestDet(
               tsos, (eta > 0 ? muonGeometry_->forwardCSCLayers()[ie] : muonGeometry_->backwardCSCLayers()[ie]));
         }
       }  //else //std::cout << "  failed to propagated to endcap " << ie  << std::endl;
       if (final.isValid())
         break;
       if (ie == 2 && !fallbackToME1_)
         break;
     }
   }
   return final;
 }

TrajectoryStateOnSurface PropagateToMuon::getBestDet	(	const TrajectoryStateOnSurface &	tsos,
		const DetLayer *	station
	)		const

private

Get the best TSOS on one of the chambres of this DetLayer, or an invalid TSOS if none match.

Definition at line 189 of file PropagateToMuon.cc.

References GeometricSearchDet::compatibleDets(), propagatorAny_, and runTheMatrix::ret.

Referenced by extrapolate().

                                                                                   {
   TrajectoryStateOnSurface ret;  // start as null
   // require compatibility at 3 sigma
   Chi2MeasurementEstimator estimator(1e10, 3.);
   std::vector<GeometricSearchDet::DetWithState> dets = layer->compatibleDets(tsos, *propagatorAny_, estimator);
   if (!dets.empty()) {
     ret = dets.front().second;
   }
   return ret;
 }

FreeTrajectoryState PropagateToMuon::startingState ( const reco::Candidate & reco ) const

private

Starting state for the propagation.

Definition at line 57 of file PropagateToMuon.cc.

References reco::Candidate::charge(), reco::RecoCandidate::combinedMuon(), Exception, GlobalTk, edm::Ref< C, T, F >::isNull(), magfield_, MuonTk, None, edm::ESHandle< class >::product(), reco::Candidate::px(), reco::Candidate::py(), reco::Candidate::pz(), dt_dqm_sourceclient_common_cff::reco, runTheMatrix::ret, reco::RecoCandidate::standAloneMuon(), reco::RecoCandidate::track(), TrackerTk, reco::Candidate::vx(), reco::Candidate::vy(), reco::Candidate::vz(), and whichTrack_.

Referenced by extrapolate().

                                                                                   {
   FreeTrajectoryState ret;
   if (whichTrack_ != None) {
     const reco::RecoCandidate *rc = dynamic_cast<const reco::RecoCandidate *>(&reco);
     if (rc == nullptr)
       throw cms::Exception("Invalid Data") << "Input object is not a RecoCandidate.\n";
     reco::TrackRef tk;
     switch (whichTrack_) {
       case TrackerTk:
         tk = rc->track();
         break;
       case MuonTk:
         tk = rc->standAloneMuon();
         break;
       case GlobalTk:
         tk = rc->combinedMuon();
         break;
       default:
         break;  // just to make gcc happy
     }
     if (tk.isNull()) {
       ret = FreeTrajectoryState();
     } else {
       ret = startingState(*tk);
     }
   } else {
     ret = FreeTrajectoryState(GlobalPoint(reco.vx(), reco.vy(), reco.vz()),
                               GlobalVector(reco.px(), reco.py(), reco.pz()),
                               reco.charge(),
                               magfield_.product());
   }
   return ret;
 }

FreeTrajectoryState PropagateToMuon::startingState ( const reco::Track & tk ) const

private

Starting state for the propagation.

Definition at line 91 of file PropagateToMuon.cc.

References AtVertex, cosmicPropagation_, trajectoryStateTransform::initialFreeState(), trajectoryStateTransform::innerFreeState(), Innermost, reco::Track::innerPosition(), edm::ESHandleBase::isValid(), magfield_, trajectoryStateTransform::outerFreeState(), Outermost, reco::Track::outerPosition(), edm::ESHandle< class >::product(), and whichState_.

                                                                             {
   if (!magfield_.isValid())
     throw cms::Exception("NotInitialized")
         << "PropagateToMuon: You must call init(const edm::EventSetup &iSetup) before using this object.\n";
   WhichState state = whichState_;
   if (cosmicPropagation_) {
     if (whichState_ == Innermost) {
       state = tk.innerPosition().Mag2() <= tk.outerPosition().Mag2() ? Innermost : Outermost;
     } else if (whichState_ == Outermost) {
       state = tk.innerPosition().Mag2() <= tk.outerPosition().Mag2() ? Outermost : Innermost;
     }
   }
   switch (state) {
     case Innermost:
       return trajectoryStateTransform::innerFreeState(tk, magfield_.product());
     case Outermost:
       return trajectoryStateTransform::outerFreeState(tk, magfield_.product());
 
     case AtVertex:
     default:
       return trajectoryStateTransform::initialFreeState(tk, magfield_.product());
   }
 }

FreeTrajectoryState PropagateToMuon::startingState	(	const SimTrack &	tk,
		const edm::SimVertexContainer &	vtxs
	)		const

private

Starting state for the propagation.

Definition at line 115 of file PropagateToMuon.cc.

References CoreSimTrack::charge(), edm::ESHandleBase::isValid(), magfield_, CoreSimTrack::momentum(), SimTrack::noVertex(), edm::ESHandle< class >::product(), and SimTrack::vertIndex().

                                                                                                               {
   if (!magfield_.isValid())
     throw cms::Exception("NotInitialized")
         << "PropagateToMuon: You must call init(const edm::EventSetup &iSetup) before using this object.\n";
   if (tk.noVertex())
     throw cms::Exception("UnsupportedOperation")
         << "I can't propagate simtracks without a vertex, I don't know where to start from.\n";
   const math::XYZTLorentzVectorD &vtx = (vtxs)[tk.vertIndex()].position();
   return FreeTrajectoryState(GlobalPoint(vtx.X(), vtx.Y(), vtx.Z()),
                              GlobalVector(tk.momentum().X(), tk.momentum().Y(), tk.momentum().Z()),
                              int(tk.charge()),
                              magfield_.product());
 }