#include <GlobalMuonTrajectoryBuilder.h>

Inheritance diagram for GlobalMuonTrajectoryBuilder:

Public Member Functions
	GlobalMuonTrajectoryBuilder (const edm::ParameterSet &, const MuonServiceProxy *, edm::ConsumesCollector &)
	constructor with Parameter Set and MuonServiceProxy More...

void	setEvent (const edm::Event &) override
	pass the Event to the algo at each event More...

MuonTrajectoryBuilder::CandidateContainer	trajectories (const TrackCand &) override
	reconstruct trajectories from standalone and tracker only Tracks More...

	~GlobalMuonTrajectoryBuilder () override
	destructor More...

Public Member Functions inherited from GlobalTrajectoryBuilderBase
	GlobalTrajectoryBuilderBase (const edm::ParameterSet &, const MuonServiceProxy *, edm::ConsumesCollector &)
	constructor with Parameter Set and MuonServiceProxy More...

void	setEvent (const edm::Event &) override
	pass the Event to the algo at each event More...

MuonTrajectoryBuilder::TrajectoryContainer	trajectories (const TrajectorySeed &) override
	dummy implementation, unused in this class More...

	~GlobalTrajectoryBuilderBase () override
	destructor More...

Public Member Functions inherited from MuonTrajectoryBuilder
	MuonTrajectoryBuilder ()
	constructor More...

virtual	~MuonTrajectoryBuilder ()
	destructor More...

Private Member Functions
std::vector< TrackCand >	makeTkCandCollection (const TrackCand &) override
	make a TrackCand collection using tracker Track, Trajectory information More...

Private Attributes
edm::Handle < reco::TrackCollection >	allTrackerTracks

edm::EDGetTokenT < reco::TrackCollection >	allTrackerTracksToken

edm::EDGetTokenT < reco::VertexCollection >	primaryVertexToken

bool	selectHighPurity_

edm::InputTag	thePrimaryVtxLabel

edm::InputTag	theTkTrackLabel

edm::Handle < reco::VertexCollection >	vertexCollection

Additional Inherited Members
Public Types inherited from GlobalTrajectoryBuilderBase
typedef MuonTransientTrackingRecHit::ConstMuonRecHitContainer	ConstMuonRecHitContainer

typedef MuonTransientTrackingRecHit::ConstMuonRecHitPointer	ConstMuonRecHitPointer

typedef TransientTrackingRecHit::ConstRecHitContainer	ConstRecHitContainer

typedef TransientTrackingRecHit::ConstRecHitPointer	ConstRecHitPointer

typedef MuonTransientTrackingRecHit::MuonRecHitContainer	MuonRecHitContainer

typedef MuonTransientTrackingRecHit::MuonRecHitPointer	MuonRecHitPointer

typedef TransientTrackingRecHit::RecHitContainer	RecHitContainer

typedef TransientTrackingRecHit::RecHitPointer	RecHitPointer

typedef std::vector< Trajectory >	TC

typedef TC::const_iterator	TI

Public Types inherited from MuonTrajectoryBuilder
typedef MuonCandidate::CandidateContainer	CandidateContainer

typedef std::pair< const Trajectory *, reco::TrackRef >	TrackCand

typedef MuonCandidate::TrajectoryContainer	TrajectoryContainer

Protected Types inherited from GlobalTrajectoryBuilderBase
enum	RefitDirection { inToOut, outToIn, undetermined }

Protected Member Functions inherited from GlobalTrajectoryBuilderBase
void	addTraj (TrackCand &)
	if TrackCand has only a TrackRef, attempt to add Trajectory* More...

MuonTrajectoryBuilder::CandidateContainer	build (const TrackCand &, MuonTrajectoryBuilder::CandidateContainer &) const
	build combined trajectory from sta Track and tracker RecHits More...

void	checkMuonHits (const reco::Track &, ConstRecHitContainer &, ConstRecHitContainer &, std::vector< int > &) const
	check muon RecHits, calculate chamber occupancy and select hits to be used in the final fit More...

RefitDirection	checkRecHitsOrdering (const ConstRecHitContainer &) const
	This does nothing now. More...

std::vector< TrackCand >	chooseRegionalTrackerTracks (const TrackCand &, const std::vector< TrackCand > &)
	choose tracker tracks within region of interest More...

const Trajectory *	chooseTrajectory (const std::vector< Trajectory * > &, int) const
	choose final trajectory More...

RectangularEtaPhiTrackingRegion	defineRegionOfInterest (const reco::TrackRef &) const
	define region of interest with tracker More...

void	fixTEC (ConstRecHitContainer &all, double scl_x, double scl_y) const
	rescale errors of outermost TEC RecHit More...

TransientTrackingRecHit::ConstRecHitContainer	getTransientRecHits (const reco::Track &) const
	get transient RecHits of a Track More...

void	printHits (const ConstRecHitContainer &) const
	print all RecHits of a trajectory More...

ConstRecHitContainer	selectMuonHits (const Trajectory &, const std::vector< int > &) const
	select muon hits compatible with trajectory; check hits in chambers with showers More...

ConstRecHitContainer	selectTrackerHits (const ConstRecHitContainer &) const
	select tracker hits; exclude some tracker hits in the global trajectory More...

const MuonServiceProxy *	service () const

GlobalMuonTrackMatcher *	trackMatcher () const

double	trackProbability (const Trajectory &) const
	calculate chi2 probability (-ln(P)) More...

Protected Attributes inherited from GlobalTrajectoryBuilderBase
std::string	theCategory

float	thePCut

float	thePtCut

Detailed Description

class to build muon trajectory

Author: N. Neumeister Purdue University; C. Liu Purdue University; A. Everett Purdue University

Definition at line 28 of file GlobalMuonTrajectoryBuilder.h.

Constructor & Destructor Documentation

GlobalMuonTrajectoryBuilder::GlobalMuonTrajectoryBuilder	(	const edm::ParameterSet &	par,
		const MuonServiceProxy *	service,
		edm::ConsumesCollector &	iC
	)

constructor with Parameter Set and MuonServiceProxy

Definition at line 56 of file GlobalMuonTrajectoryBuilder.cc.

References allTrackerTracksToken, edm::ConsumesCollector::consumes(), edm::ParameterSet::getParameter(), edm::ConsumesCollector::mayConsume(), primaryVertexToken, selectHighPurity_, thePrimaryVtxLabel, and theTkTrackLabel.

     : GlobalTrajectoryBuilderBase(par, service, iC)
 
 {
   theTkTrackLabel = par.getParameter<edm::InputTag>("TrackerCollectionLabel");
   allTrackerTracksToken = iC.consumes<reco::TrackCollection>(theTkTrackLabel);
   thePrimaryVtxLabel = par.getParameter<edm::InputTag>("VertexCollectionLabel");
   primaryVertexToken = iC.mayConsume<reco::VertexCollection>(thePrimaryVtxLabel);
   selectHighPurity_ = par.getParameter<bool>("selectHighPurity");
 }

GlobalMuonTrajectoryBuilder::~GlobalMuonTrajectoryBuilder ( )

override

destructor

Definition at line 73 of file GlobalMuonTrajectoryBuilder.cc.

73 {}

Member Function Documentation

vector< GlobalMuonTrajectoryBuilder::TrackCand > GlobalMuonTrajectoryBuilder::makeTkCandCollection ( const TrackCand & staCand )

overrideprivatevirtual

make a TrackCand collection using tracker Track, Trajectory information

Implements GlobalTrajectoryBuilderBase.

Definition at line 150 of file GlobalMuonTrajectoryBuilder.cc.

References allTrackerTracks, category, GlobalTrajectoryBuilderBase::chooseRegionalTrackerTracks(), reco::TrackBase::highPurity, position, edm::Handle< T >::product(), selectHighPurity_, AlCaHLTBitMon_QueryRunRegistry::string, and vertexCollection.

Referenced by trajectories().

                               {
   const std::string category = "Muon|RecoMuon|GlobalMuonTrajectoryBuilder|makeTkCandCollection";
 
   vector<TrackCand> tkCandColl;
 
   vector<TrackCand> tkTrackCands;
 
   for (unsigned int position = 0; position != allTrackerTracks->size(); ++position) {
     reco::TrackRef tkTrackRef(allTrackerTracks, position);
     TrackCand tkCand = TrackCand((Trajectory*)nullptr, tkTrackRef);
     if (selectHighPurity_ && !tkTrackRef->quality(reco::TrackBase::highPurity)) {
       const reco::VertexCollection* recoVertices = vertexCollection.product();
       if (!(*recoVertices)[0].isFake())
         continue;
     }
     tkTrackCands.push_back(tkCand);
   }
 
   tkCandColl = chooseRegionalTrackerTracks(staCand, tkTrackCands);
 
   return tkCandColl;
 }

void GlobalMuonTrajectoryBuilder::setEvent ( const edm::Event & event )

overridevirtual

pass the Event to the algo at each event

Implements MuonTrajectoryBuilder.

Definition at line 78 of file GlobalMuonTrajectoryBuilder.cc.

References allTrackerTracks, allTrackerTracksToken, category, LogDebug, primaryVertexToken, GlobalTrajectoryBuilderBase::setEvent(), AlCaHLTBitMon_QueryRunRegistry::string, thePrimaryVtxLabel, theTkTrackLabel, and vertexCollection.

                                                                 {
   const std::string category = "Muon|RecoMuon|GlobalMuonTrajectoryBuilder|setEvent";
 
   GlobalTrajectoryBuilderBase::setEvent(event);
 
   // get tracker TrackCollection from Event
   event.getByToken(allTrackerTracksToken, allTrackerTracks);
   LogDebug(category) << " Found " << allTrackerTracks->size() << " tracker Tracks with label " << theTkTrackLabel;
 
   // get primary vertex from Event
   event.getByToken(primaryVertexToken, vertexCollection);
   LogDebug(category) << " Found " << vertexCollection->size() << " tracker Tracks with label " << thePrimaryVtxLabel;
 }

MuonCandidate::CandidateContainer GlobalMuonTrajectoryBuilder::trajectories ( const TrackCand & staCandIn )

overridevirtual

reconstruct trajectories from standalone and tracker only Tracks

Implements MuonTrajectoryBuilder.

Definition at line 95 of file GlobalMuonTrajectoryBuilder.cc.

References GlobalTrajectoryBuilderBase::build(), category, LogTrace, makeTkCandCollection(), GlobalMuonTrackMatcher::match(), mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, GlobalTrajectoryBuilderBase::thePtCut, and GlobalTrajectoryBuilderBase::trackMatcher().

                                                                                                     {
   const std::string category = "Muon|RecoMuon|GlobalMuonTrajectoryBuilder|trajectories";
 
   // cut on muons with low momenta
   LogTrace(category) << " STA pt " << staCandIn.second->pt() << " rho " << staCandIn.second->innerMomentum().Rho()
                      << " R " << staCandIn.second->innerMomentum().R() << " theCut " << thePtCut;
 
   // convert the STA track into a Trajectory if Trajectory not already present
   TrackCand staCand(staCandIn);
 
   vector<TrackCand> regionalTkTracks = makeTkCandCollection(staCand);
   LogTrace(category) << " Found " << regionalTkTracks.size() << " tracks within region of interest";
 
   // match tracker tracks to muon track
   vector<TrackCand> trackerTracks = trackMatcher()->match(staCand, regionalTkTracks);
   LogTrace(category) << " Found " << trackerTracks.size() << " matching tracker tracks within region of interest";
 
   if (trackerTracks.empty()) {
     if (staCandIn.first == nullptr)
       delete staCand.first;
 
     return CandidateContainer();
   }
 
   // build a combined tracker-muon MuonCandidate
   //
   // turn tkMatchedTracks into MuonCandidates
   //
   LogTrace(category) << " Turn tkMatchedTracks into MuonCandidates";
   CandidateContainer tkTrajs;
   for (vector<TrackCand>::const_iterator tkt = trackerTracks.begin(); tkt != trackerTracks.end(); tkt++) {
     tkTrajs.push_back(std::make_unique<MuonCandidate>(nullptr, staCand.second, (*tkt).second, nullptr));
   }
 
   if (tkTrajs.empty()) {
     LogTrace(category) << " tkTrajs empty";
     if (staCandIn.first == nullptr)
       delete staCand.first;
 
     return CandidateContainer();
   }
 
   CandidateContainer result = build(staCand, tkTrajs);
   LogTrace(category) << " Found " << result.size() << " GLBMuons from one STACand";
 
   // free memory
   if (staCandIn.first == nullptr)
     delete staCand.first;
 
   return result;
 }