MuonTrackFinder Class Reference

#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
void	load (CandidateContainer &, edm::Event &, const TrackerTopology &ttopo)
	convert the trajectories into tracks and load them in to the event More...
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	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

CandidateContainer

typedef MuonCandidate::CandidateContainer MuonTrackFinder::CandidateContainer

Definition at line 29 of file MuonTrackFinder.h.

TrackCand

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

Definition at line 30 of file MuonTrackFinder.h.

TrajectoryContainer

typedef MuonCandidate::TrajectoryContainer MuonTrackFinder::TrajectoryContainer

Definition at line 28 of file MuonTrackFinder.h.

Constructor & Destructor Documentation

MuonTrackFinder() [1/2]

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() [2/2]

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::~MuonTrackFinder ( )

virtual

destructor

Definition at line 48 of file MuonTrackFinder.cc.

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

References LogTrace.

Member Function Documentation

load() [1/2]

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.

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

References theTrackLoader.

load() [2/2]

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.

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

References theTrackLoader, and FastTrackerRecHitMaskProducer_cfi::trajectories.

Referenced by reconstruct().

reconstruct() [1/2]

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.

                                                                                                {
  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);
}

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

reconstruct() [2/2]

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.

                                                                                                                {
  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);
}

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

setEvent()

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

private

percolate the Event Setup

Definition at line 53 of file MuonTrackFinder.cc.

{ theTrajBuilder->setEvent(event); }

References theTrajBuilder.

Referenced by reconstruct().

Member Data Documentation

theTrackLoader

std::unique_ptr<MuonTrackLoader> MuonTrackFinder::theTrackLoader

private

Definition at line 74 of file MuonTrackFinder.h.

Referenced by load().

theTrajBuilder

std::unique_ptr<MuonTrajectoryBuilder> MuonTrackFinder::theTrajBuilder

private

Definition at line 70 of file MuonTrackFinder.h.

Referenced by reconstruct(), and setEvent().

theTrajCleaner

std::unique_ptr<MuonTrajectoryCleaner> MuonTrackFinder::theTrajCleaner

private

Definition at line 72 of file MuonTrackFinder.h.

Referenced by reconstruct().

theTtopoToken

const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> MuonTrackFinder::theTtopoToken

private

Definition at line 68 of file MuonTrackFinder.h.

Referenced by reconstruct().