#include <L3MuonTrajectoryBuilder.h>

Inheritance diagram for L3MuonTrajectoryBuilder:

Public Member Functions
	L3MuonTrajectoryBuilder (const edm::ParameterSet &, const MuonServiceProxy *)
	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 &)
	reconstruct trajectories from standalone and tracker only Tracks More...

	~L3MuonTrajectoryBuilder ()
	destructor More...

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

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

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

edm::InputTag	theTkCollName

TrajectoryCleaner *	theTrajectoryCleaner

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

Date:: 2008/12/15 18:22:55

Revision:: 1.8.2.1

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

Definition at line 30 of file L3MuonTrajectoryBuilder.h.

Constructor & Destructor Documentation

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

constructor with Parameter Set and MuonServiceProxy

Definition at line 71 of file L3MuonTrajectoryBuilder.cc.

References edm::ParameterSet::getParameter(), theTkCollName, and theTrajectoryCleaner.

                                                               : GlobalTrajectoryBuilderBase(par, service) {
 
   theTrajectoryCleaner = new TrajectoryCleanerBySharedHits();    
 
   theTkCollName = par.getParameter<edm::InputTag>("tkTrajLabel");
 
 }

L3MuonTrajectoryBuilder::~L3MuonTrajectoryBuilder ( )

destructor

Definition at line 85 of file L3MuonTrajectoryBuilder.cc.

References theTrajectoryCleaner.

                                                   {
   if (theTrajectoryCleaner) delete theTrajectoryCleaner;
 }

Member Function Documentation

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

privatevirtual

make a TrackCand collection using tracker Track, Trajectory information

Implements GlobalTrajectoryBuilderBase.

Definition at line 178 of file L3MuonTrajectoryBuilder.cc.

References allTrackerTracks, category(), and position.

Referenced by trajectories().

                                                                                                                {
 
   const std::string category = "Muon|RecoMuon|L3MuonTrajectoryBuilder|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*)(0),tkTrackRef);
     tkCandColl.push_back(tkCand);
   }
 
   for(vector<TrackCand>::const_iterator tk = tkCandColl.begin(); tk != tkCandColl.end() ; ++tk) { 
     edm::Ref<L3MuonTrajectorySeedCollection> l3seedRef = (*tk).second->seedRef().castTo<edm::Ref<L3MuonTrajectorySeedCollection> >() ;
     reco::TrackRef staTrack = l3seedRef->l2Track();
     if(staTrack == (staCand.second) ) tkTrackCands.push_back(*tk);
   }
 
   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 92 of file L3MuonTrajectoryBuilder.cc.

References allTrackerTracks, category(), LogDebug, GlobalTrajectoryBuilderBase::setEvent(), and theTkCollName.

                                                             {
   
   const std::string category = "Muon|RecoMuon|L3MuonTrajectoryBuilder|setEvent";
   
   GlobalTrajectoryBuilderBase::setEvent(event);
       
   // get tracker TrackCollection from Event
   event.getByLabel(theTkCollName,allTrackerTracks);
   LogDebug(category) 
       << "Found " << allTrackerTracks->size() 
       << " tracker Tracks with label "<< theTkCollName;  
   
 }

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

virtual

reconstruct trajectories from standalone and tracker only Tracks

Implements MuonTrajectoryBuilder.

Definition at line 109 of file L3MuonTrajectoryBuilder.cc.

References GlobalTrajectoryBuilderBase::build(), category(), LogDebug, makeTkCandCollection(), GlobalMuonTrackMatcher::match(), query::result, edm::second(), 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);
   
   vector<TrackCand> trackerTracks;
   
   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 (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);
       //      LogTrace(category) << "tpush";
       //
     } 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 ( vector<TrackCand>::const_iterator is = regionalTkTracks.begin(); is != regionalTkTracks.end(); ++is) {
     delete (*is).first;   
   }
   
   return result;
   
 }