#include <MuonTrackLoader.h>

Public Types
typedef MuonCandidate::CandidateContainer	CandidateContainer

typedef MuonCandidate::TrajectoryContainer	TrajectoryContainer

Public Member Functions
edm::OrphanHandle< reco::TrackCollection >	loadTracks (const TrajectoryContainer &, edm::Event &, const TrackerTopology &ttopo, const std::string &="", bool=true)
	Convert the trajectories into tracks and load the tracks in the event. More...

edm::OrphanHandle< reco::TrackCollection >	loadTracks (const TrajectoryContainer &, edm::Event &, std::vector< bool > &, const TrackerTopology &ttopo, const std::string &="", bool=true)
	Convert the trajectories into tracks and load the tracks in the event. More...

edm::OrphanHandle< reco::TrackCollection >	loadTracks (const TrajectoryContainer &, edm::Event &, const std::vector< std::pair< Trajectory *, reco::TrackRef > > &, edm::Handle< reco::TrackCollection > const &trackHandle, const TrackerTopology &ttopo, const std::string &="", bool=true)
	Convert the trajectories into tracks and load the tracks in the event. More...

edm::OrphanHandle< reco::MuonTrackLinksCollection >	loadTracks (const CandidateContainer &, edm::Event &, const TrackerTopology &ttopo)
	Convert the trajectories into tracks and load the tracks in the event. More...

	MuonTrackLoader (edm::ParameterSet &parameterSet, edm::ConsumesCollector &iC, const MuonServiceProxy *service=0)
	Constructor for the STA reco the args must be specify! More...

virtual	~MuonTrackLoader ()
	Destructor. More...

Private Member Functions
std::pair< bool, reco::Track >	buildTrackAtPCA (const Trajectory &trajectory, const reco::BeamSpot &) const
	Build a track at the PCA WITHOUT any vertex constriant. More...

reco::TrackExtra	buildTrackExtra (const Trajectory &) const

std::pair< bool, reco::Track >	buildTrackUpdatedAtPCA (const reco::Track &trackAtPCA, const reco::BeamSpot &) const
	Takes a track at the PCA and applies the vertex constriant. More...

Static Private Member Functions
static std::vector< const TrackingRecHit * >	unpackHit (const TrackingRecHit &hit)

Private Attributes
TkClonerImpl	hitCloner

bool	theAllowNoVtxFlag

edm::InputTag	theBeamSpotInputTag

edm::EDGetTokenT< reco::BeamSpot >	theBeamSpotToken

std::string	theL2SeededTkLabel
	Label for L2SeededTracks. More...

bool	thePutTkTrackFlag

const MuonServiceProxy *	theService

std::unique_ptr< TrajectorySmoother >	theSmoother

std::string	theSmootherName

bool	theSmoothingStep

bool	theSmoothTkTrackFlag

std::string	theTrackerRecHitBuilderName

bool	theTrajectoryFlag

bool	theUpdatingAtVtx

MuonUpdatorAtVertex *	theUpdatorAtVtx

Detailed Description

Class to load the tracks in the event, it provide some common functionalities both for all the RecoMuon producers.

Author: R. Bellan - INFN Torino ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Class to load the product in the event

Author: R. Bellan - INFN Torino ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Definition at line 43 of file MuonTrackLoader.h.

Member Typedef Documentation

typedef MuonCandidate::CandidateContainer MuonTrackLoader::CandidateContainer

Definition at line 46 of file MuonTrackLoader.h.

typedef MuonCandidate::TrajectoryContainer MuonTrackLoader::TrajectoryContainer

Definition at line 45 of file MuonTrackLoader.h.

Constructor & Destructor Documentation

MuonTrackLoader::MuonTrackLoader	(	edm::ParameterSet &	parameterSet,
		edm::ConsumesCollector &	iC,
		const MuonServiceProxy *	service = `0`
	)

Constructor for the STA reco the args must be specify!

Definition at line 93 of file MuonTrackLoader.cc.

References edm::ConsumesCollector::consumes(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), MuonUpdatorAtVertex_cff::MuonUpdatorAtVertex, AlCaHLTBitMon_QueryRunRegistry::string, theAllowNoVtxFlag, theBeamSpotInputTag, theBeamSpotToken, theL2SeededTkLabel, thePutTkTrackFlag, theSmootherName, theSmoothingStep, theSmoothTkTrackFlag, theTrackerRecHitBuilderName, theTrajectoryFlag, theUpdatingAtVtx, and theUpdatorAtVtx.

     : theService(service) {
   // option to do or not the smoothing step.
   // the trajectories which are passed to the track loader are supposed to be non-smoothed
   theSmoothingStep = parameterSet.getParameter<bool>("DoSmoothing");
   if (theSmoothingStep)
     theSmootherName = parameterSet.getParameter<string>("Smoother");
 
   theTrackerRecHitBuilderName = parameterSet.getParameter<std::string>("TTRHBuilder");
 
   // update at vertex
   theUpdatingAtVtx = parameterSet.getParameter<bool>("VertexConstraint");
 
   // beam spot input tag
   theBeamSpotInputTag = parameterSet.getParameter<edm::InputTag>("beamSpot");
   theBeamSpotToken = iC.consumes<reco::BeamSpot>(theBeamSpotInputTag);
 
   // Flag to put the trajectory into the event
   theTrajectoryFlag = parameterSet.getUntrackedParameter<bool>("PutTrajectoryIntoEvent", true);
 
   theL2SeededTkLabel = parameterSet.getUntrackedParameter<string>("MuonSeededTracksInstance", string());
 
   ParameterSet updatorPar = parameterSet.getParameter<ParameterSet>("MuonUpdatorAtVertexParameters");
   theUpdatorAtVtx = new MuonUpdatorAtVertex(updatorPar, service);
 
   thePutTkTrackFlag = parameterSet.getUntrackedParameter<bool>("PutTkTrackIntoEvent", false);
   theSmoothTkTrackFlag = parameterSet.getUntrackedParameter<bool>("SmoothTkTrack", false);
   theAllowNoVtxFlag = parameterSet.getUntrackedParameter<bool>("AllowNoVertex", false);
 }

MuonTrackLoader::~MuonTrackLoader ( )

virtual

Destructor.

Definition at line 125 of file MuonTrackLoader.cc.

References reco::TrackBase::appendHitPattern(), pwdgSkimBPark_cfi::beamSpot, buildTrackAtPCA(), buildTrackExtra(), buildTrackUpdatedAtPCA(), TrajectorySmoother::clone(), watchdog::const, hitCloner, hfClusterShapes_cfi::hits, mps_fire::i, instance, edm::RefToBase< T >::isNonnull(), loadTracks(), LogDebug, LogTrace, metname, eostools::move(), edm::ESHandle< T >::product(), reco::TrackBase::pt(), edm::OwnVector< T, P >::push_back(), reco::TrackExtraBase::recHitsSize(), Trajectory::seedRef(), reco::Track::setExtra(), reco::TrackExtraBase::setHits(), Trajectory::setSeedRef(), reco::TrackExtraBase::setTrajParams(), theBeamSpotToken, theService, theSmoother, theSmootherName, theSmoothingStep, theTrackerRecHitBuilderName, theTrajectoryFlag, theUpdatingAtVtx, theUpdatorAtVtx, HLT_2018_cff::track, duplicaterechits_cfi::trackCollection, FastTrackerRecHitMaskProducer_cfi::trajectories, reco::TrackExtraBase::trajParams(), UNLIKELY, and unpackHit().

                                   {
   if (theUpdatorAtVtx)
     delete theUpdatorAtVtx;
 }

Member Function Documentation

pair< bool, reco::Track > MuonTrackLoader::buildTrackAtPCA	(	const Trajectory &	trajectory,
		const reco::BeamSpot &	beamSpot
	)		const

private

Build a track at the PCA WITHOUT any vertex constriant.

Definition at line 692 of file MuonTrackLoader.cc.

References FreeTrajectoryState::charge(), Trajectory::chiSquared(), FreeTrajectoryState::curvilinearError(), debug, MuonPatternRecoDumper::dumpFTS(), TrajectoryStateOnSurface::freeState(), Trajectory::geometricalInnermostState(), TrajectoryStateOnSurface::globalPosition(), TrackerBounds::isInside(), LogTrace, metname, FreeTrajectoryState::momentum(), ndof, Trajectory::ndof(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::position(), MuonUpdatorAtVertex::propagate(), theAllowNoVtxFlag, theService, theUpdatorAtVtx, HLT_2018_cff::track, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by loadTracks(), and ~MuonTrackLoader().

                                                                                              {
   const string metname = "Muon|RecoMuon|MuonTrackLoader";
 
   MuonPatternRecoDumper debug;
 
   // FIXME: check the prop direction
   TrajectoryStateOnSurface innerTSOS = trajectory.geometricalInnermostState();
 
   // This is needed to extrapolate the tsos at vertex
   LogTrace(metname) << "Propagate to PCA...";
   pair<bool, FreeTrajectoryState> extrapolationResult = theUpdatorAtVtx->propagate(innerTSOS, beamSpot);
   FreeTrajectoryState ftsAtVtx;
 
   if (extrapolationResult.first)
     ftsAtVtx = extrapolationResult.second;
   else {
     if (TrackerBounds::isInside(innerTSOS.globalPosition())) {
       LogInfo(metname) << "Track in the Tracker: taking the innermost state instead of the state at PCA";
       ftsAtVtx = *innerTSOS.freeState();
     } else {
       if (theAllowNoVtxFlag) {
         LogInfo(metname) << "Propagation to PCA failed, taking the innermost state instead of the state at PCA";
         ftsAtVtx = *innerTSOS.freeState();
       } else {
         LogInfo(metname) << "Stand Alone track: this track will be rejected";
         return pair<bool, reco::Track>(false, reco::Track());
       }
     }
   }
 
   LogTrace(metname) << "TSOS after the extrapolation at vtx";
   LogTrace(metname) << debug.dumpFTS(ftsAtVtx);
 
   GlobalPoint pca = ftsAtVtx.position();
   math::XYZPoint persistentPCA(pca.x(), pca.y(), pca.z());
   GlobalVector p = ftsAtVtx.momentum();
   math::XYZVector persistentMomentum(p.x(), p.y(), p.z());
 
   bool bon = true;
   if (fabs(theService->magneticField()->inTesla(GlobalPoint(0, 0, 0)).z()) < 0.01)
     bon = false;
   double ndof = trajectory.ndof(bon);
 
   reco::Track track(
       trajectory.chiSquared(), ndof, persistentPCA, persistentMomentum, ftsAtVtx.charge(), ftsAtVtx.curvilinearError());
 
   return pair<bool, reco::Track>(true, track);
 }

reco::TrackExtra MuonTrackLoader::buildTrackExtra ( const Trajectory & trajectory ) const

private

Definition at line 773 of file MuonTrackLoader.cc.

References alongMomentum, Surface::bounds(), TrajectoryStateOnSurface::curvilinearError(), Trajectory::direction(), Trajectory::firstMeasurement(), TrajectoryStateOnSurface::globalParameters(), Bounds::inside(), Trajectory::lastMeasurement(), LogTrace, metname, GlobalTrajectoryParameters::momentum(), oppositeToMomentum, AlCaHLTBitMon_ParallelJobs::p, GlobalTrajectoryParameters::position(), TrajectoryMeasurement::recHit(), Trajectory::recHits(), Trajectory::seedRef(), GeomDet::surface(), theService, GeomDet::toLocal(), TrajectoryMeasurement::updatedState(), findQualityFiles::v, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by loadTracks(), and ~MuonTrackLoader().

                                                                                   {
   const string metname = "Muon|RecoMuon|MuonTrackLoader";
 
   const Trajectory::RecHitContainer transRecHits = trajectory.recHits();
 
   // put the collection of TrackingRecHit in the event
 
   // sets the outermost and innermost TSOSs
   // FIXME: check it!
   TrajectoryStateOnSurface outerTSOS;
   TrajectoryStateOnSurface innerTSOS;
   unsigned int innerId = 0, outerId = 0;
   TrajectoryMeasurement::ConstRecHitPointer outerRecHit;
   DetId outerDetId;
 
   if (trajectory.direction() == alongMomentum) {
     LogTrace(metname) << "alongMomentum";
     outerTSOS = trajectory.lastMeasurement().updatedState();
     innerTSOS = trajectory.firstMeasurement().updatedState();
     outerId = trajectory.lastMeasurement().recHit()->geographicalId().rawId();
     innerId = trajectory.firstMeasurement().recHit()->geographicalId().rawId();
     outerRecHit = trajectory.lastMeasurement().recHit();
     outerDetId = trajectory.lastMeasurement().recHit()->geographicalId();
   } else if (trajectory.direction() == oppositeToMomentum) {
     LogTrace(metname) << "oppositeToMomentum";
     outerTSOS = trajectory.firstMeasurement().updatedState();
     innerTSOS = trajectory.lastMeasurement().updatedState();
     outerId = trajectory.firstMeasurement().recHit()->geographicalId().rawId();
     innerId = trajectory.lastMeasurement().recHit()->geographicalId().rawId();
     outerRecHit = trajectory.firstMeasurement().recHit();
     outerDetId = trajectory.firstMeasurement().recHit()->geographicalId();
   } else
     LogError(metname) << "Wrong propagation direction!";
 
   const GeomDet* outerDet = theService->trackingGeometry()->idToDet(outerDetId);
   GlobalPoint outerTSOSPos = outerTSOS.globalParameters().position();
   bool inside = outerDet->surface().bounds().inside(outerDet->toLocal(outerTSOSPos));
 
   GlobalPoint hitPos =
       (outerRecHit->isValid()) ? outerRecHit->globalPosition() : outerTSOS.globalParameters().position();
 
   if (!inside) {
     LogTrace(metname) << "The Global Muon outerMostMeasurementState is not compatible with the recHit detector! "
                          "Setting outerMost postition to recHit position if recHit isValid: "
                       << outerRecHit->isValid();
     LogTrace(metname) << "From " << outerTSOSPos << " to " << hitPos;
   }
 
   //build the TrackExtra
   GlobalPoint v = (inside) ? outerTSOSPos : hitPos;
   GlobalVector p = outerTSOS.globalParameters().momentum();
   math::XYZPoint outpos(v.x(), v.y(), v.z());
   math::XYZVector outmom(p.x(), p.y(), p.z());
 
   v = innerTSOS.globalParameters().position();
   p = innerTSOS.globalParameters().momentum();
   math::XYZPoint inpos(v.x(), v.y(), v.z());
   math::XYZVector inmom(p.x(), p.y(), p.z());
 
   reco::TrackExtra trackExtra(outpos,
                               outmom,
                               true,
                               inpos,
                               inmom,
                               true,
                               outerTSOS.curvilinearError(),
                               outerId,
                               innerTSOS.curvilinearError(),
                               innerId,
                               trajectory.direction(),
                               trajectory.seedRef());
 
   return trackExtra;
 }

pair< bool, reco::Track > MuonTrackLoader::buildTrackUpdatedAtPCA	(	const reco::Track &	trackAtPCA,
		const reco::BeamSpot &	beamSpot
	)		const

private

Takes a track at the PCA and applies the vertex constriant.

Definition at line 742 of file MuonTrackLoader.cc.

References FreeTrajectoryState::charge(), reco::TrackBase::chi2(), FreeTrajectoryState::curvilinearError(), debug, MuonPatternRecoDumper::dumpFTS(), LogTrace, metname, FreeTrajectoryState::momentum(), reco::TrackBase::ndof(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::position(), theService, theUpdatorAtVtx, MuonUpdatorAtVertex::update(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by ~MuonTrackLoader().

                                                                                                     {
   const string metname = "Muon|RecoMuon|MuonTrackLoader";
   MuonPatternRecoDumper debug;
 
   // build the transient track
   reco::TransientTrack transientTrack(track, &*theService->magneticField(), theService->trackingGeometry());
 
   LogTrace(metname) << "Apply the vertex constraint";
   pair<bool, FreeTrajectoryState> updateResult = theUpdatorAtVtx->update(transientTrack, beamSpot);
 
   if (!updateResult.first) {
     return pair<bool, reco::Track>(false, reco::Track());
   }
 
   LogTrace(metname) << "FTS after the vertex constraint";
   FreeTrajectoryState& ftsAtVtx = updateResult.second;
 
   LogTrace(metname) << debug.dumpFTS(ftsAtVtx);
 
   GlobalPoint pca = ftsAtVtx.position();
   math::XYZPoint persistentPCA(pca.x(), pca.y(), pca.z());
   GlobalVector p = ftsAtVtx.momentum();
   math::XYZVector persistentMomentum(p.x(), p.y(), p.z());
 
   reco::Track updatedTrack(
       track.chi2(), track.ndof(), persistentPCA, persistentMomentum, ftsAtVtx.charge(), ftsAtVtx.curvilinearError());
 
   return pair<bool, reco::Track>(true, updatedTrack);
 }

edm::OrphanHandle<reco::TrackCollection> MuonTrackLoader::loadTracks	(	const TrajectoryContainer &	,
		edm::Event &	,
		const TrackerTopology &	ttopo,
		const std::string &	= `""`,
		bool	= `true`
	)

Convert the trajectories into tracks and load the tracks in the event.

Referenced by MuonTrackFinder::load(), loadTracks(), and ~MuonTrackLoader().

edm::OrphanHandle<reco::TrackCollection> MuonTrackLoader::loadTracks	(	const TrajectoryContainer &	,
		edm::Event &	,
		std::vector< bool > &	,
		const TrackerTopology &	ttopo,
		const std::string &	= `""`,
		bool	= `true`
	)

Convert the trajectories into tracks and load the tracks in the event.

edm::OrphanHandle<reco::TrackCollection> MuonTrackLoader::loadTracks	(	const TrajectoryContainer &	,
		edm::Event &	,
		const std::vector< std::pair< Trajectory *, reco::TrackRef > > &	,
		edm::Handle< reco::TrackCollection > const &	trackHandle,
		const TrackerTopology &	ttopo,
		const std::string &	= `""`,
		bool	= `true`
	)

Convert the trajectories into tracks and load the tracks in the event.

OrphanHandle< reco::MuonTrackLinksCollection > MuonTrackLoader::loadTracks	(	const CandidateContainer &	muonCands,
		edm::Event &	event,
		const TrackerTopology &	ttopo
	)

Convert the trajectories into tracks and load the tracks in the event.

Definition at line 367 of file MuonTrackLoader.cc.

References reco::TrackBase::appendHitPattern(), pwdgSkimBPark_cfi::beamSpot, buildTrackAtPCA(), buildTrackExtra(), TrajectorySmoother::clone(), watchdog::const, hitCloner, hfClusterShapes_cfi::hits, mps_fire::i, instance, edm::OrphanHandleBase::isValid(), electronStore::links, loadTracks(), LogDebug, LogTrace, metname, eostools::move(), position, edm::ESHandle< T >::product(), reco::TrackBase::pt(), edm::OwnVector< T, P >::push_back(), reco::TrackExtraBase::recHitsSize(), reco::Track::setExtra(), reco::MuonTrackLinks::setGlobalTrack(), reco::TrackExtraBase::setHits(), Trajectory::setSeedRef(), reco::MuonTrackLinks::setStandAloneTrack(), reco::MuonTrackLinks::setTrackerTrack(), reco::TrackExtraBase::setTrajParams(), theBeamSpotToken, theL2SeededTkLabel, thePutTkTrackFlag, theService, theSmoother, theSmootherName, theSmoothingStep, theSmoothTkTrackFlag, theTrackerRecHitBuilderName, theTrajectoryFlag, theUpdatingAtVtx, HLT_2018_cff::track, duplicaterechits_cfi::trackCollection, FastTrackerRecHitMaskProducer_cfi::trajectories, reco::TrackExtraBase::trajParams(), UNLIKELY, and unpackHit().

                                                                                                        {
   const string metname = "Muon|RecoMuon|MuonTrackLoader";
 
   // the muon collection, it will be loaded in the event
   auto trackLinksCollection = std::make_unique<reco::MuonTrackLinksCollection>();
 
   // don't waste any time...
   if (muonCands.empty()) {
     auto trackExtraCollection = std::make_unique<reco::TrackExtraCollection>();
     auto recHitCollection = std::make_unique<TrackingRecHitCollection>();
     auto trackCollection = std::make_unique<reco::TrackCollection>();
 
     event.put(std::move(recHitCollection));
     event.put(std::move(trackExtraCollection));
     event.put(std::move(trackCollection));
 
     //need to also put the tracker tracks collection if requested
     if (thePutTkTrackFlag) {
       //will take care of putting nothing in the event but the empty collection
       TrajectoryContainer trackerTrajs;
       loadTracks(trackerTrajs, event, ttopo, theL2SeededTkLabel, theSmoothTkTrackFlag);
     }
 
     return event.put(std::move(trackLinksCollection));
   }
 
   // get combined Trajectories
   TrajectoryContainer combinedTrajs;
   TrajectoryContainer trackerTrajs;
   for (CandidateContainer::const_iterator it = muonCands.begin(); it != muonCands.end(); ++it) {
     LogDebug(metname) << "Loader glbSeedRef " << (*it)->trajectory()->seedRef().isNonnull();
     if ((*it)->trackerTrajectory())
       LogDebug(metname) << " "
                         << "tkSeedRef " << (*it)->trackerTrajectory()->seedRef().isNonnull();
 
     combinedTrajs.push_back((*it)->trajectory());
     if (thePutTkTrackFlag)
       trackerTrajs.push_back((*it)->trackerTrajectory());
 
     else {
       if ((*it)->trackerTrajectory())
         delete ((*it)->trackerTrajectory());
     }
 
     // // Create the links between sta and tracker tracks
     // reco::MuonTrackLinks links;
     // links.setStandAloneTrack((*it)->muonTrack());
     // links.setTrackerTrack((*it)->trackerTrack());
     // trackLinksCollection->push_back(links);
     // delete *it;
   }
 
   // create the TrackCollection of combined Trajectories
   // FIXME: could this be done one track at a time in the previous loop?
   LogTrace(metname) << "Build combinedTracks";
   std::vector<bool> combTksVec(combinedTrajs.size(), false);
   OrphanHandle<reco::TrackCollection> combinedTracks = loadTracks(combinedTrajs, event, combTksVec, ttopo);
 
   OrphanHandle<reco::TrackCollection> trackerTracks;
   std::vector<bool> trackerTksVec(trackerTrajs.size(), false);
   if (thePutTkTrackFlag) {
     LogTrace(metname) << "Build trackerTracks: " << trackerTrajs.size();
     trackerTracks = loadTracks(trackerTrajs, event, trackerTksVec, ttopo, theL2SeededTkLabel, theSmoothTkTrackFlag);
   } else {
     for (TrajectoryContainer::iterator it = trackerTrajs.begin(); it != trackerTrajs.end(); ++it) {
       if (*it)
         delete *it;
     }
   }
 
   LogTrace(metname) << "Set the final links in the MuonTrackLinks collection";
 
   unsigned int candposition(0), position(0), tkposition(0);
   //reco::TrackCollection::const_iterator glIt = combinedTracks->begin(),
   //  glEnd = combinedTracks->end();
 
   for (CandidateContainer::const_iterator it = muonCands.begin(); it != muonCands.end(); ++it, ++candposition) {
     // The presence of the global track determines whether to fill the MuonTrackLinks or not
     // N.B. We are assuming here that the global tracks in "combinedTracks"
     //      have the same order as the muon candidates in "muonCands"
     //      (except for possible missing tracks), which should always be the case...
     //if( glIt == glEnd ) break;
     if (combTksVec[candposition]) {
       reco::TrackRef combinedTR(combinedTracks, position++);
       //++glIt;
 
       // Create the links between sta and tracker tracks
       reco::MuonTrackLinks links;
       links.setStandAloneTrack((*it)->muonTrack());
       links.setTrackerTrack((*it)->trackerTrack());
       links.setGlobalTrack(combinedTR);
 
       if (thePutTkTrackFlag && trackerTksVec[candposition]) {
         reco::TrackRef trackerTR(trackerTracks, tkposition++);
         links.setTrackerTrack(trackerTR);
       }
 
       trackLinksCollection->push_back(links);
     }
 
     else {  // if no global track, still increment the tracker-track counter when appropriate
       if (thePutTkTrackFlag && trackerTksVec[candposition])
         tkposition++;
     }
 
     delete *it;
   }
 
   if (thePutTkTrackFlag && trackerTracks.isValid() && !(!combinedTracks->empty() && !trackerTracks->empty()))
     LogWarning(metname) << "The MuonTrackLinkCollection is incomplete";
 
   // put the MuonCollection in the event
   LogTrace(metname) << "put the MuonCollection in the event"
                     << "\n";
 
   return event.put(std::move(trackLinksCollection));
 }

std::vector< const TrackingRecHit * > MuonTrackLoader::unpackHit ( const TrackingRecHit & hit )

staticprivate

Definition at line 46 of file MuonTrackLoader.cc.

References filterCSVwithJSON::copy, MuonSubdetId::CSC, DetId::det(), TrackingRecHit::dimension(), MuonSubdetId::DT, MuonSubdetId::GEM, TrackingRecHit::geographicalId(), hfClusterShapes_cfi::hits, MuonSubdetId::ME0, DetId::Muon, TrackingRecHit::recHits(), MuonSubdetId::RPC, and DetId::Tracker.

Referenced by loadTracks(), and ~MuonTrackLoader().

                                                                                      {
   // get rec hit det id and rec hit type
   DetId id = hit.geographicalId();
   uint16_t detid = id.det();
 
   std::vector<const TrackingRecHit*> hits;
 
   if (detid == DetId::Tracker) {
     hits.push_back(&hit);
   } else if (detid == DetId::Muon) {
     uint16_t subdet = id.subdetId();
     if (subdet == (uint16_t)MuonSubdetId::DT) {
       if (hit.dimension() == 1) {  // DT rechit (granularity 2)
         hits.push_back(&hit);
       } else if (hit.dimension() > 1) {  // 4D segment (granularity 0).
         // Both 2 and 4 dim cases. MB4s have 2D, but formatted in 4D segment
         // 4D --> 2D
         std::vector<const TrackingRecHit*> seg2D = hit.recHits();
         // load 1D hits (2D --> 1D)
         for (std::vector<const TrackingRecHit*>::const_iterator it = seg2D.begin(); it != seg2D.end(); ++it) {
           std::vector<const TrackingRecHit*> hits1D = (*it)->recHits();
           copy(hits1D.begin(), hits1D.end(), back_inserter(hits));
         }
       }
     } else if (subdet == (uint16_t)MuonSubdetId::CSC) {
       if (hit.dimension() == 2) {  // CSC rechit (granularity 2)
         hits.push_back(&hit);
       } else if (hit.dimension() == 4) {  // 4D segment (granularity 0)
         // load 2D hits (4D --> 1D)
         hits = hit.recHits();
       }
     } else if (subdet == (uint16_t)MuonSubdetId::RPC) {
       hits.push_back(&hit);
     } else if (subdet == (uint16_t)MuonSubdetId::GEM) {
       if (hit.dimension() == 2) {  // GEM rechit
         hits.push_back(&hit);
       } else if (hit.dimension() == 4) {  // GEM segment
         hits = hit.recHits();
       }
     } else if (subdet == (uint16_t)MuonSubdetId::ME0) {  //segment
       hits = hit.recHits();
     }
   }
   return hits;
 }