#include <FastL3MuonTrajectoryBuilder.h>

Inheritance diagram for FastL3MuonTrajectoryBuilder:

Public Member Functions
void	clear ()
	clear memory More...

	FastL3MuonTrajectoryBuilder (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...

	~FastL3MuonTrajectoryBuilder ()
	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...

TC	makeTrajsFromSeeds (const std::vector< TrajectorySeed > &) const
	build a tracker Trajectory from a seed More...

Private Attributes
TrackCand	dummyStaCand

std::vector< TrackCand >	regionalTkTracks

const edm::Event *	theEvent

bool	theFirstEvent

edm::InputTag	theSimModule

edm::ESHandle< TrajectoryBuilder >	theTkBuilder

std::string	theTkBuilderName

TrackerSeedGenerator *	theTkSeedGenerator

bool	theTkTrajsAvailableFlag

edm::InputTag	theTrackerTrajectoryCollection

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 from STA L2 muons and tracker tracks

Date:: 2008/03/24 20:07:54

Revision:: 1.5

Author: Patrick Janot - CERN

Definition at line 41 of file FastL3MuonTrajectoryBuilder.h.

Constructor & Destructor Documentation

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

constructor with Parameter Set and MuonServiceProxy

Class: FastL3MuonTrajectoryBuilder

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

Date:: 2008/05/14 17:43:24

Revision:: 1.9

Authors : Patrick Janot - CERN

Definition at line 50 of file FastL3MuonTrajectoryBuilder.cc.

References edm::ParameterSet::getParameter(), cmsCodeRules.cppFunctionSkipper::operator, refitMuons_cfi::refitMuons, theFirstEvent, and theTrackerTrajectoryCollection.

 : 
   GlobalTrajectoryBuilderBase(par, service), 
   theTkSeedGenerator(0), theTrajectoryCleaner(0) 
 {
 
   theFirstEvent = true;
   
   theTrackerTrajectoryCollection = par.getParameter<edm::InputTag>("TrackerTrajectories");
 
 #ifdef FAMOS_DEBUG
   dbe = edm::Service<DQMStore>().operator->();
   matchMuons = dbe->book1D("MatchMuons", "Eta distribution (match)",100,-2.5,2.5);
   refitMuons = dbe->book1D("RefitMuons", "Eta distribution (refit)",100,-2.5,2.5);
 #endif
 
 }

FastL3MuonTrajectoryBuilder::~FastL3MuonTrajectoryBuilder ( )

destructor

Definition at line 74 of file FastL3MuonTrajectoryBuilder.cc.

References theTrajectoryCleaner.

                                                           {
   if (theTrajectoryCleaner) delete theTrajectoryCleaner;
 #ifdef FAMOS_DEBUG
   dbe->save("test.root");
 #endif
 }

Member Function Documentation

void FastL3MuonTrajectoryBuilder::clear ( void )

clear memory

Definition at line 220 of file FastL3MuonTrajectoryBuilder.cc.

References regionalTkTracks.

Referenced by python.Vispa.Views.WidgetView.WidgetView::closeEvent(), python.Vispa.Views.BoxDecayView.BoxDecayView::closeEvent(), python.Vispa.Share.FindAlgorithm.FindAlgorithm::findUsingFindDialog(), python.Vispa.Views.LineDecayView.LineDecayView::setDataObjects(), python.Vispa.Views.WidgetView.WidgetView::setDataObjects(), python.Vispa.Views.TreeView.TreeView::updateContent(), python.Vispa.Views.TableView.TableView::updateContent(), python.Vispa.Views.BoxDecayView.BoxDecayView::updateContent(), and python.Vispa.Views.PropertyView.PropertyView::updateContent().

                                    { 
   std::vector<TrackCand>::const_iterator is = regionalTkTracks.begin();
   std::vector<TrackCand>::const_iterator il = regionalTkTracks.end();
   for ( ; is != il; ++is) {
     delete (*is).first;   
   }
 }

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

privatevirtual

make a TrackCand collection using tracker Track, Trajectory information

Implements GlobalTrajectoryBuilderBase.

Definition at line 173 of file FastL3MuonTrajectoryBuilder.cc.

References edm::Event::getByLabel(), edm::helpers::KeyVal< K, V >::key, theEvent, theTrackerTrajectoryCollection, and edm::helpers::KeyVal< K, V >::val.

Referenced by setEvent().

                                                                           {
 
   // const std::string category = "Muon|RecoMuon|FastL3MuonTrajectoryBuilder|makeTkCandCollection";
 
   std::vector<TrackCand> tkCandColl;  
 
   // Get the tracker tracks
   edm:: Handle<std::vector<Trajectory> > theTrajectories;
   edm::Handle<TrajTrackAssociationCollection> theAssoMap;  
   theEvent->getByLabel(theTrackerTrajectoryCollection,theTrajectories);
   theEvent->getByLabel(theTrackerTrajectoryCollection,theAssoMap);
   
   TrajTrackAssociationCollection::const_iterator anAssociation;  
   TrajTrackAssociationCollection::const_iterator firstAssociation;  
   TrajTrackAssociationCollection::const_iterator lastAssociation;
   firstAssociation = theAssoMap->begin();
   lastAssociation = theAssoMap->end();
 
   // Loop on muon tracks seeded by L2 muons
   for ( anAssociation = firstAssociation; anAssociation != lastAssociation; ++anAssociation ) { 
     edm::Ref<std::vector<Trajectory> > aTrajectoryRef = anAssociation->key;
     reco::TrackRef aTrackRef = anAssociation->val;
     tkCandColl.push_back(TrackCand(new Trajectory((*aTrajectoryRef)),reco::TrackRef()));
   }
     
   // LogTrace(category) << "Found " << tkCandColl.size() << " tkCands from seeds";
   // std::cout << "Found " << tkCandColl.size() << " tkCands from seeds" << std::endl;
 
   return tkCandColl;
 
 }

std::vector< Trajectory > FastL3MuonTrajectoryBuilder::makeTrajsFromSeeds ( const std::vector< TrajectorySeed > & tkSeeds ) const

private

build a tracker Trajectory from a seed

Definition at line 210 of file FastL3MuonTrajectoryBuilder.cc.

References query::result.

                                                                                               {
 
   // const std::string category = "Muon|RecoMuon|FastL3MuonTrajectoryBuilder|makeTrajsFromSeeds";
   std::vector<Trajectory> result;
   // edm::LogInfo(category) << "Trajectories from all seeds " << result.size();
   return result;
 
 }

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

virtual

pass the Event to the algo at each event

Reimplemented from GlobalTrajectoryBuilderBase.

Definition at line 84 of file FastL3MuonTrajectoryBuilder.cc.

References dummyStaCand, event(), makeTkCandCollection(), regionalTkTracks, GlobalTrajectoryBuilderBase::setEvent(), and theEvent.

                                                                 {
   
   // const std::string category = "Muon|RecoMuon|FastL3MuonTrajectoryBuilder|setEvent";
     
   GlobalTrajectoryBuilderBase::setEvent(event);
   theEvent = &event;
     
   // Retrieve tracker tracks for muons
   regionalTkTracks = makeTkCandCollection(dummyStaCand);
   // edm::LogInfo(category) << "Found " << regionalTkTracks.size() << " tracker tracks from Muons";  
 
 }

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

virtual

reconstruct trajectories from standalone and tracker only Tracks

Implements MuonTrajectoryBuilder.

Definition at line 101 of file FastL3MuonTrajectoryBuilder.cc.

References GlobalTrajectoryBuilderBase::addTraj(), GlobalTrajectoryBuilderBase::build(), GlobalMuonTrackMatcher::match(), MuonCandidate::muonTrack(), refitMuons_cfi::refitMuons, regionalTkTracks, query::result, edm::second(), GlobalTrajectoryBuilderBase::thePtCut, and GlobalTrajectoryBuilderBase::trackMatcher().

                                                                     {
 
   // static const std::string category = "FastL3MuonTrajectoryBuilder";
 
   // 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);
   addTraj(staCand);
   
   // match tracker tracks to muon track
   std::vector<TrackCand> trackerTracks = trackMatcher()->match(staCand, regionalTkTracks);
 
   // edm::LogInfo(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
   //
   //edm::LogInfo(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);
 #ifdef FAMOS_DEBUG
       if ( muonCand->muonTrack()->innerMomentum().Perp2() > 400. ) 
     matchMuons->Fill(muonCand->muonTrack()->innerMomentum().Eta());
 #endif
       // LogTrace(category) << "tpush";
 
     }
   }
   
   if ( tkTrajs.empty() )  {
     // edm::LogInfo(category) << "tkTrajs empty";
     return CandidateContainer();
   }
   
   CandidateContainer result = build(staCand, tkTrajs);  
 #ifdef FAMOS_DEBUG
   if ( result.size() > 0 ) { 
     CandidateContainer::const_iterator muonIt = result.begin();
     if ((*muonIt)->muonTrack()->innerMomentum().Perp2() > 400. ) 
       refitMuons->Fill((*muonIt)->muonTrack()->innerMomentum().Eta());
   }
 #endif
   // edm::LogInfo(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();  
 
   return result;
   
 }