#include <MuonTrackFinder.h>

Public Types
typedef MuonCandidate::CandidateContainer	CandidateContainer

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

typedef MuonCandidate::TrajectoryContainer	TrajectoryContainer

Public Member Functions
	MuonTrackFinder (std::unique_ptr< MuonTrajectoryBuilder > ConcreteMuonTrajectoryBuilder, std::unique_ptr< MuonTrackLoader > trackLoader, edm::ConsumesCollector iC)
	Constructor, with default cleaner. For the STA reconstruction the trackLoader must have the propagator. More...

	MuonTrackFinder (std::unique_ptr< MuonTrajectoryBuilder > ConcreteMuonTrajectoryBuilder, std::unique_ptr< MuonTrackLoader > trackLoader, std::unique_ptr< MuonTrajectoryCleaner > cleaner, edm::ConsumesCollector iC)
	Constructor, with user-defined cleaner. For the STA reconstruction the trackLoader must have the propagator. More...

edm::OrphanHandle < reco::TrackCollection >	reconstruct (const edm::Handle< edm::View< TrajectorySeed > > &, edm::Event &, const edm::EventSetup &)
	reconstruct standalone tracks starting from a collection of seeds More...

void	reconstruct (const std::vector< TrackCand > &, edm::Event &, const edm::EventSetup &)

virtual	~MuonTrackFinder ()
	destructor More...

Private Member Functions
edm::OrphanHandle < reco::TrackCollection >	load (TrajectoryContainer &, edm::Event &, const TrackerTopology &ttopo)
	convert the trajectories into tracks and load them in to the event More...

void	load (CandidateContainer &, edm::Event &, const TrackerTopology &ttopo)
	convert the trajectories into tracks and load them in to the event More...

void	setEvent (const edm::Event &)
	percolate the Event Setup More...

Private Attributes
std::unique_ptr< MuonTrackLoader >	theTrackLoader

std::unique_ptr < MuonTrajectoryBuilder >	theTrajBuilder

std::unique_ptr < MuonTrajectoryCleaner >	theTrajCleaner

const edm::ESGetToken < TrackerTopology, TrackerTopologyRcd >	theTtopoToken

Detailed Description

Track finder for the Muon Reco

Author: R. Bellan - INFN Torino

Concrete Track finder for the Muon Reco

Author: R. Bellan - INFN Torino

Definition at line 26 of file MuonTrackFinder.h.

Member Typedef Documentation

typedef MuonCandidate::CandidateContainer MuonTrackFinder::CandidateContainer

Definition at line 29 of file MuonTrackFinder.h.

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

Definition at line 30 of file MuonTrackFinder.h.

typedef MuonCandidate::TrajectoryContainer MuonTrackFinder::TrajectoryContainer

Definition at line 28 of file MuonTrackFinder.h.

Constructor & Destructor Documentation

MuonTrackFinder::MuonTrackFinder	(	std::unique_ptr< MuonTrajectoryBuilder >	ConcreteMuonTrajectoryBuilder,
		std::unique_ptr< MuonTrackLoader >	trackLoader,
		edm::ConsumesCollector	iC
	)

Constructor, with default cleaner. For the STA reconstruction the trackLoader must have the propagator.

Definition at line 29 of file MuonTrackFinder.cc.

     : MuonTrackFinder(std::move(ConcreteMuonTrajectoryBuilder),
                       std::move(trackLoader),
                       std::make_unique<MuonTrajectoryCleaner>(),
                       iC) {}

MuonTrackFinder::MuonTrackFinder	(	std::unique_ptr< MuonTrajectoryBuilder >	ConcreteMuonTrajectoryBuilder,
		std::unique_ptr< MuonTrackLoader >	trackLoader,
		std::unique_ptr< MuonTrajectoryCleaner >	cleaner,
		edm::ConsumesCollector	iC
	)

Constructor, with user-defined cleaner. For the STA reconstruction the trackLoader must have the propagator.

Definition at line 38 of file MuonTrackFinder.cc.

     : theTtopoToken(iC.esConsumes()),
       theTrajBuilder(std::move(ConcreteMuonTrajectoryBuilder)),
       theTrajCleaner(std::move(cleaner)),
       theTrackLoader(std::move(trackLoader)) {}

MuonTrackFinder::~MuonTrackFinder ( )

virtual

destructor

Definition at line 48 of file MuonTrackFinder.cc.

References LogTrace.

                                   {
   LogTrace("Muon|RecoMuon|MuonTrackFinder") << "MuonTrackFinder destructor called" << endl;
 }

Member Function Documentation

edm::OrphanHandle< reco::TrackCollection > MuonTrackFinder::load	(	TrajectoryContainer &	trajectories,
		edm::Event &	event,
		const TrackerTopology &	ttopo
	)

private

convert the trajectories into tracks and load them in to the event

Definition at line 56 of file MuonTrackFinder.cc.

References theTrackLoader.

Referenced by reconstruct().

                                                                                              {
   return theTrackLoader->loadTracks(trajectories, event, ttopo);
 }

void MuonTrackFinder::load	(	CandidateContainer &	muonCands,
		edm::Event &	event,
		const TrackerTopology &	ttopo
	)

private

convert the trajectories into tracks and load them in to the event

Definition at line 63 of file MuonTrackFinder.cc.

References theTrackLoader.

                                                                                                     {
   theTrackLoader->loadTracks(muonCands, event, ttopo);
 }

edm::OrphanHandle< reco::TrackCollection > MuonTrackFinder::reconstruct	(	const edm::Handle< edm::View< TrajectorySeed > > &	seeds,
		edm::Event &	event,
		const edm::EventSetup &	es
	)

reconstruct standalone tracks starting from a collection of seeds

Definition at line 68 of file MuonTrackFinder.cc.

References edm::EventSetup::getData(), load(), LogTrace, metname, eostools::move(), fileCollector::seed, DetachedQuadStep_cff::seeds, setEvent(), theTrajBuilder, theTrajCleaner, and theTtopoToken.

                                                                                                 {
   const string metname = "Muon|RecoMuon|MuonTrackFinder";
   LogTrace(metname) << "SA Recostruction starting from: " << seeds->size() << endl;
 
   // Percolate the event
   setEvent(event);
 
   const auto& ttopo = es.getData(theTtopoToken);
 
   // Trajectory container
   TrajectoryContainer muonTrajectories;
   TrajectorySeedCollection::size_type nSeed = 0;
   // reconstruct the trajectory
   edm::View<TrajectorySeed>::const_iterator seed;
   for (seed = seeds->begin(); seed != seeds->end(); ++seed, ++nSeed) {
     LogTrace(metname) << "+++ New Seed +++" << endl;
     TrajectoryContainer muonTrajs_temp = theTrajBuilder->trajectories(*seed);
     for (TrajectoryContainer::iterator it = muonTrajs_temp.begin(); it != muonTrajs_temp.end(); ++it) {
       (*it)->setSeedRef(seeds->refAt(nSeed));
       muonTrajectories.push_back(std::move(*it));
     }
   }
 
   // clean the clone traj
   LogTrace(metname) << "Clean the trajectories container" << endl;
   if (theTrajCleaner)
     theTrajCleaner->clean(muonTrajectories, event, seeds);  //used by reference...
 
   // convert the trajectories into tracks and load them in to the event
   LogTrace(metname) << "Convert the trajectories into tracks and load them in to the event" << endl;
   return load(muonTrajectories, event, ttopo);
 }

void MuonTrackFinder::reconstruct	(	const std::vector< TrackCand > &	staCandColl,
		edm::Event &	event,
		const edm::EventSetup &	es
	)

reconstruct global tracks starting from a collection of standalone tracks and one of trakectories. If the latter is invalid, trajectories are refitted.

Definition at line 103 of file MuonTrackFinder.cc.

References edm::EventSetup::getData(), load(), LogTrace, metname, setEvent(), theTrajBuilder, theTrajCleaner, and theTtopoToken.

                                                                                                                 {
   const string metname = "Muon|RecoMuon|MuonTrackFinder";
 
   // percolate the event
   setEvent(event);
 
   const auto& ttopo = es.getData(theTtopoToken);
 
   // Muon Candidate container
   CandidateContainer muonCandidates;
 
   // reconstruct the muon candidates
   for (vector<TrackCand>::const_iterator staCand = staCandColl.begin(); staCand != staCandColl.end(); ++staCand) {
     CandidateContainer muonCands_temp = theTrajBuilder->trajectories(*staCand);
     muonCandidates.insert(muonCandidates.end(),
                           std::make_move_iterator(muonCands_temp.begin()),
                           std::make_move_iterator(muonCands_temp.end()));
   }
 
   // clean the cloned candidates
   if (theTrajCleaner)
     theTrajCleaner->clean(muonCandidates);
 
   // convert the trajectories into staTracks and load them into the event
   LogTrace(metname) << "Load Muon Candidates into the event" << endl;
   load(muonCandidates, event, ttopo);
 }