#include <L3MuonTrajectoryBuilder.h>

Inheritance diagram for L3MuonTrajectoryBuilder:

Public Member Functions
	L3MuonTrajectoryBuilder (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
	return a container reconstructed muons starting from a given track More...

	~L3MuonTrajectoryBuilder () override
	Destructor. More...

Public Member Functions inherited from GlobalTrajectoryBuilderBase
	GlobalTrajectoryBuilderBase (const edm::ParameterSet &, const MuonServiceProxy *, edm::ConsumesCollector &)
	constructor with Parameter Set and MuonServiceProxy 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...

Static Public Member Functions
static void	fillDescriptions (edm::ParameterSetDescription &descriptions)
	Add default values for fillDescriptions. 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

reco::BeamSpot	beamSpot

edm::Handle< reco::BeamSpot >	beamSpotHandle

edm::Handle < reco::VertexCollection >	pvHandle

edm::InputTag	theBeamSpotInputTag

double	theDXYBeamSpot

double	theMaxChi2

edm::InputTag	theTkCollName

edm::EDGetTokenT < reco::TrackCollection >	theTrackToken

std::unique_ptr < TrajectoryCleaner >	theTrajectoryCleaner

bool	theUseVertex

edm::InputTag	theVertexCollInputTag

reco::Vertex	vtx

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 37 of file L3MuonTrajectoryBuilder.h.

Constructor & Destructor Documentation

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

Constructor with Parameter Set and MuonServiceProxy.

Class: L3MuonTrajectoryBuilder

Description: Reconstruct muons starting from a muon track reconstructed in the standalone muon system (with DT, CSC and RPC information). It tries to reconstruct the corresponding track in the tracker and performs matching between the reconstructed tracks in the muon system and the tracker.

Authors : N. Neumeister Purdue University C. Liu Purdue University A. Everett Purdue University with contributions from: S. Lacaprara, J. Mumford, P. Traczyk

Definition at line 53 of file L3MuonTrajectoryBuilder.cc.

References edm::ConsumesCollector::consumes(), edm::ParameterSet::getParameter(), theBeamSpotInputTag, theDXYBeamSpot, theMaxChi2, theTkCollName, theTrackToken, theTrajectoryCleaner, theUseVertex, and theVertexCollInputTag.

     : GlobalTrajectoryBuilderBase(par, service, iC) {
   theTrajectoryCleaner = std::make_unique<TrajectoryCleanerBySharedHits>();
   theTkCollName = par.getParameter<edm::InputTag>("tkTrajLabel");
   theBeamSpotInputTag = par.getParameter<edm::InputTag>("tkTrajBeamSpot");
   theMaxChi2 = par.getParameter<double>("tkTrajMaxChi2");
   theDXYBeamSpot = par.getParameter<double>("tkTrajMaxDXYBeamSpot");
   theUseVertex = par.getParameter<bool>("tkTrajUseVertex");
   theVertexCollInputTag = par.getParameter<edm::InputTag>("tkTrajVertex");
   theTrackToken = iC.consumes<reco::TrackCollection>(theTkCollName);
 }

L3MuonTrajectoryBuilder::~L3MuonTrajectoryBuilder ( )

override

Destructor.

Definition at line 70 of file L3MuonTrajectoryBuilder.cc.

70 {}

Member Function Documentation

void L3MuonTrajectoryBuilder::fillDescriptions ( edm::ParameterSetDescription & descriptions )

static

Add default values for fillDescriptions.

Definition at line 72 of file L3MuonTrajectoryBuilder.cc.

References edm::ParameterSetDescription::add(), and MuonTrackingRegionBuilder::fillDescriptionsHLT().

                                                                                {
   edm::ParameterSetDescription descTRB;
   MuonTrackingRegionBuilder::fillDescriptionsHLT(descTRB);
   desc.add("MuonTrackingRegionBuilder", descTRB);
 }

std::vector< L3MuonTrajectoryBuilder::TrackCand > L3MuonTrajectoryBuilder::makeTkCandCollection ( const TrackCand & staCand )

overrideprivatevirtual

Make a TrackCand collection using tracker Track, Trajectory information.

Implements GlobalTrajectoryBuilderBase.

Definition at line 169 of file L3MuonTrajectoryBuilder.cc.

References a, allTrackerTracks, beamSpot, category, reco::BeamSpot::position(), reco::Vertex::position(), position, AlCaHLTBitMon_QueryRunRegistry::string, theDXYBeamSpot, theMaxChi2, theUseVertex, and vtx.

Referenced by trajectories().

                                                                                                                   {
   const std::string category = "Muon|RecoMuon|L3MuonTrajectoryBuilder|makeTkCandCollection";
   std::vector<TrackCand> tkCandColl;
   std::vector<TrackCand> tkTrackCands;
 
   //  for (auto&& tkTrack: allTrackerTracks){
   //    auto tkCand = TrackCand((Trajectory*)(0),tkTrack);
   for (unsigned int position = 0; position != allTrackerTracks->size(); ++position) {
     reco::TrackRef tkTrackRef(allTrackerTracks, position);
     TrackCand tkCand = TrackCand((Trajectory*)nullptr, tkTrackRef);
     tkCandColl.push_back(tkCand);
   }
 
   //Loop over TrackCand collection made from allTrackerTracks in previous step
   for (auto&& tkCand : tkCandColl) {
     auto& tk = tkCand.second;
     bool canUseL3MTS = false;
     // check the seedRef is non-null first; and then
     if (tk->seedRef().isNonnull()) {
       auto a = dynamic_cast<const L3MuonTrajectorySeed*>(tk->seedRef().get());
       canUseL3MTS = a != nullptr;
     }
     if (canUseL3MTS) {
       edm::Ref<L3MuonTrajectorySeedCollection> l3seedRef =
           tk->seedRef().castTo<edm::Ref<L3MuonTrajectorySeedCollection> >();
       // May still need provenance here, so using trackref:
       reco::TrackRef staTrack = l3seedRef->l2Track();
       if (staTrack == (staCand.second)) {
         // Apply filters (dxy, chi2 cut)
         double tk_vtx;
         if (theUseVertex)
           tk_vtx = tk->dxy(vtx.position());
         else
           tk_vtx = tk->dxy(beamSpot.position());
         if (fabs(tk_vtx) > theDXYBeamSpot || tk->normalizedChi2() > theMaxChi2)
           continue;
         tkTrackCands.push_back(tkCand);
       }
     } else {
       // We will try to match all tracker tracks with the muon:
       double tk_vtx;
       if (theUseVertex)
         tk_vtx = tk->dxy(vtx.position());
       else
         tk_vtx = tk->dxy(beamSpot.position());
       if (fabs(tk_vtx) > theDXYBeamSpot || tk->normalizedChi2() > theMaxChi2)
         continue;
       tkTrackCands.push_back(tkCand);
     }
   }
 
   return tkTrackCands;
 }

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

overridevirtual

Pass the Event to the algo at each event.

Reimplemented from GlobalTrajectoryBuilderBase.

Definition at line 81 of file L3MuonTrajectoryBuilder.cc.

References allTrackerTracks, beamSpot, beamSpotHandle, category, edm::HandleBase::isValid(), LogDebug, pvHandle, GlobalTrajectoryBuilderBase::setEvent(), AlCaHLTBitMon_QueryRunRegistry::string, theBeamSpotInputTag, theTkCollName, theTrackToken, theUseVertex, and vtx.

                                                             {
   const std::string category = "Muon|RecoMuon|L3MuonTrajectoryBuilder|setEvent";
 
   GlobalTrajectoryBuilderBase::setEvent(event);
 
   // get tracker TrackCollection from Event
   event.getByToken(theTrackToken, allTrackerTracks);
   LogDebug(category) << "Found " << allTrackerTracks->size() << " tracker Tracks with label " << theTkCollName;
 
   if (theUseVertex) {
     // PV
     edm::Handle<reco::VertexCollection> pvHandle;
     if (pvHandle.isValid()) {
       vtx = pvHandle->front();
     } else {
       edm::LogInfo(category) << "No Primary Vertex available from EventSetup \n";
     }
   } else {
     // BS
     event.getByLabel(theBeamSpotInputTag, beamSpotHandle);
     if (beamSpotHandle.isValid()) {
       beamSpot = *beamSpotHandle;
     } else {
       edm::LogInfo(category) << "No beam spot available from EventSetup \n";
     }
   }
 }

MuonCandidate::CandidateContainer L3MuonTrajectoryBuilder::trajectories ( const TrackCand & )

overridevirtual

return a container reconstructed muons starting from a given track

Implements MuonTrajectoryBuilder.

Definition at line 112 of file L3MuonTrajectoryBuilder.cc.

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

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