#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...

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

MuonTrajectoryBuilder::CandidateContainer	trajectories (const TrackCand &)
	return a container reconstructed muons starting from a given track More...

	~L3MuonTrajectoryBuilder ()
	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 &)
	dummy implementation, unused in this class More...

virtual	~GlobalTrajectoryBuilderBase ()
	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 &)
	Make a TrackCand collection using tracker Track, Trajectory information. More...

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 31 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 54 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 = new 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 ( )

Destructor.

Definition at line 70 of file L3MuonTrajectoryBuilder.cc.

References theTrajectoryCleaner.

                                                   {
   if (theTrajectoryCleaner) delete theTrajectoryCleaner;
 }

Member Function Documentation

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

static

Add default values for fillDescriptions.

Definition at line 74 of file L3MuonTrajectoryBuilder.cc.

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

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

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

privatevirtual

Make a TrackCand collection using tracker Track, Trajectory information.

Implements GlobalTrajectoryBuilderBase.

Definition at line 184 of file L3MuonTrajectoryBuilder.cc.

References a, allTrackerTracks, beamSpot, python.rootplot.argparse::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*)(0),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 )

virtual

Pass the Event to the algo at each event.

Reimplemented from GlobalTrajectoryBuilderBase.

Definition at line 83 of file L3MuonTrajectoryBuilder.cc.

References allTrackerTracks, beamSpot, beamSpotHandle, python.rootplot.argparse::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 & )

virtual

return a container reconstructed muons starting from a given track

Implements MuonTrajectoryBuilder.

Definition at line 120 of file L3MuonTrajectoryBuilder.cc.

References GlobalTrajectoryBuilderBase::build(), python.rootplot.argparse::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> trackerTracks;
   
   std::vector<TrackCand> regionalTkTracks = makeTkCandCollection(staCand);
   LogDebug(category) << "Found " << regionalTkTracks.size() << " tracks within region of interest";  
   
   // match tracker tracks to muon track
   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;
   for (std::vector<TrackCand>::const_iterator tkt = trackerTracks.begin(); tkt != trackerTracks.end(); tkt++) {
     if ((*tkt).first != 0 && (*tkt).first->isValid()) {
       MuonCandidate* muonCand = new MuonCandidate( 0 ,staCand.second,(*tkt).second, new Trajectory(*(*tkt).first));
       tkTrajs.push_back(muonCand);
     } else {
       MuonCandidate* muonCand = new MuonCandidate( 0 ,staCand.second,(*tkt).second, 0);
       tkTrajs.push_back(muonCand);
     }
   }
     
   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 == 0) delete staCand.first;
 
   for( CandidateContainer::const_iterator it = tkTrajs.begin(); it != tkTrajs.end(); ++it) {
     if ( (*it)->trajectory() ) delete (*it)->trajectory();
     if ( (*it)->trackerTrajectory() ) delete (*it)->trackerTrajectory();
     if ( *it ) delete (*it);
   }
   tkTrajs.clear();  
 
   for ( std::vector<TrackCand>::const_iterator is = regionalTkTracks.begin(); is != regionalTkTracks.end(); ++is) {
     delete (*is).first;   
   }
   
   return result;
 }

Member Data Documentation

edm::Handle<reco::TrackCollection> L3MuonTrajectoryBuilder::allTrackerTracks

private

Definition at line 58 of file L3MuonTrajectoryBuilder.h.

Referenced by makeTkCandCollection(), and setEvent().

reco::BeamSpot L3MuonTrajectoryBuilder::beamSpot

private

Definition at line 59 of file L3MuonTrajectoryBuilder.h.

Referenced by makeTkCandCollection(), and setEvent().

edm::Handle<reco::BeamSpot> L3MuonTrajectoryBuilder::beamSpotHandle

private

Definition at line 60 of file L3MuonTrajectoryBuilder.h.

Referenced by setEvent().

edm::Handle<reco::VertexCollection> L3MuonTrajectoryBuilder::pvHandle

private

Definition at line 63 of file L3MuonTrajectoryBuilder.h.

Referenced by setEvent().

edm::InputTag L3MuonTrajectoryBuilder::theBeamSpotInputTag

private

Definition at line 61 of file L3MuonTrajectoryBuilder.h.

Referenced by L3MuonTrajectoryBuilder(), and setEvent().

double L3MuonTrajectoryBuilder::theDXYBeamSpot

private

Definition at line 67 of file L3MuonTrajectoryBuilder.h.

Referenced by L3MuonTrajectoryBuilder(), and makeTkCandCollection().

double L3MuonTrajectoryBuilder::theMaxChi2

private

Definition at line 66 of file L3MuonTrajectoryBuilder.h.

Referenced by L3MuonTrajectoryBuilder(), and makeTkCandCollection().

edm::InputTag L3MuonTrajectoryBuilder::theTkCollName

private

Definition at line 57 of file L3MuonTrajectoryBuilder.h.

Referenced by L3MuonTrajectoryBuilder(), and setEvent().

edm::EDGetTokenT<reco::TrackCollection> L3MuonTrajectoryBuilder::theTrackToken

private

Definition at line 68 of file L3MuonTrajectoryBuilder.h.

Referenced by L3MuonTrajectoryBuilder(), and setEvent().

TrajectoryCleaner* L3MuonTrajectoryBuilder::theTrajectoryCleaner

private

Definition at line 56 of file L3MuonTrajectoryBuilder.h.

Referenced by L3MuonTrajectoryBuilder(), and ~L3MuonTrajectoryBuilder().

bool L3MuonTrajectoryBuilder::theUseVertex

private

Definition at line 65 of file L3MuonTrajectoryBuilder.h.

Referenced by L3MuonTrajectoryBuilder(), makeTkCandCollection(), and setEvent().

edm::InputTag L3MuonTrajectoryBuilder::theVertexCollInputTag

private

Definition at line 64 of file L3MuonTrajectoryBuilder.h.

Referenced by L3MuonTrajectoryBuilder().

reco::Vertex L3MuonTrajectoryBuilder::vtx

private

Definition at line 62 of file L3MuonTrajectoryBuilder.h.

Referenced by makeTkCandCollection(), and setEvent().

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

TrajectoryCleaner *	theTrajectoryCleaner

bool	theUseVertex

edm::InputTag	theVertexCollInputTag

reco::Vertex	vtx

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation