MuonTrackLoader Class Reference

#include <MuonTrackLoader.h>

Public Types
typedef MuonCandidate::CandidateContainer	CandidateContainer
typedef MuonCandidate::TrajectoryContainer	TrajectoryContainer

Public Member Functions
edm::OrphanHandle< reco::TrackCollection >	loadTracks (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 (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 (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 (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=nullptr)
	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
edm::ESGetToken< TrajectorySmoother, TrajectoryFitter::Record >	theSmootherToken
bool	theSmoothingStep
bool	theSmoothTkTrackFlag
edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	theTrackerRecHitBuilderToken
bool	theTrajectoryFlag
bool	theUpdatingAtVtx
std::unique_ptr< 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 45 of file MuonTrackLoader.h.

Member Typedef Documentation

CandidateContainer

typedef MuonCandidate::CandidateContainer MuonTrackLoader::CandidateContainer

Definition at line 48 of file MuonTrackLoader.h.

TrajectoryContainer

typedef MuonCandidate::TrajectoryContainer MuonTrackLoader::TrajectoryContainer

Definition at line 47 of file MuonTrackLoader.h.

Constructor & Destructor Documentation

MuonTrackLoader()

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

Constructor for the STA reco the args must be specify!

Definition at line 95 of file MuonTrackLoader.cc.

References edm::ConsumesCollector::consumes(), edm::ConsumesCollector::esConsumes(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), edm::parameterSet(), AlCaHLTBitMon_QueryRunRegistry::string, theAllowNoVtxFlag, theBeamSpotInputTag, theBeamSpotToken, theL2SeededTkLabel, thePutTkTrackFlag, theSmootherToken, theSmoothingStep, theSmoothTkTrackFlag, theTrackerRecHitBuilderToken, 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) {
    auto smootherName = parameterSet.getParameter<string>("Smoother");
    theSmootherToken = iC.esConsumes(edm::ESInputTag("", smootherName));

    auto trackerRecHitBuilderName = parameterSet.getParameter<std::string>("TTRHBuilder");
    theTrackerRecHitBuilderToken = iC.esConsumes(edm::ESInputTag("", trackerRecHitBuilderName));
  }

  // 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 = std::make_unique<MuonUpdatorAtVertex>(updatorPar, service);

  thePutTkTrackFlag = parameterSet.getUntrackedParameter<bool>("PutTkTrackIntoEvent", false);
  theSmoothTkTrackFlag = parameterSet.getUntrackedParameter<bool>("SmoothTkTrack", false);
  theAllowNoVtxFlag = parameterSet.getUntrackedParameter<bool>("AllowNoVertex", false);
}

~MuonTrackLoader()

MuonTrackLoader::~MuonTrackLoader ( )

virtual

Destructor.

Definition at line 130 of file MuonTrackLoader.cc.

{}

Member Function Documentation

buildTrackAtPCA()

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 674 of file MuonTrackLoader.cc.

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

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

buildTrackExtra()

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

private

Definition at line 755 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(), and findQualityFiles::v.

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

buildTrackUpdatedAtPCA()

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 724 of file MuonTrackLoader.cc.

References pwdgSkimBPark_cfi::beamSpot, FreeTrajectoryState::charge(), FreeTrajectoryState::curvilinearError(), debug, LogTrace, metname, FreeTrajectoryState::momentum(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::position(), theService, theUpdatorAtVtx, HLT_2024v14_cff::track, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

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

loadTracks() [1/4]

edm::OrphanHandle<reco::TrackCollection> MuonTrackLoader::loadTracks	(	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 loadTracks().

loadTracks() [2/4]

edm::OrphanHandle<reco::TrackCollection> MuonTrackLoader::loadTracks	(	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.

loadTracks() [3/4]

edm::OrphanHandle<reco::TrackCollection> MuonTrackLoader::loadTracks	(	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.

loadTracks() [4/4]

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

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

Definition at line 362 of file MuonTrackLoader.cc.

References edm::OrphanHandleBase::isValid(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, electronStore::links, loadTracks(), LogDebug, LogTrace, metname, eostools::move(), position, theL2SeededTkLabel, thePutTkTrackFlag, theSmoothTkTrackFlag, and JetHT_cfg::trackCollection.

                                                                                                       {
  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::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)->releaseTrajectory());
    {
      auto tt = (*it)->releaseTrackerTrajectory();
      if (thePutTkTrackFlag)
        trackerTrajs.push_back(std::move(tt));
    }

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

  trackerTrajs.clear();

  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++;
    }
  }

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

unpackHit()

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

staticprivate

Definition at line 48 of file MuonTrackLoader.cc.

References filterCSVwithJSON::copy, MuonSubdetId::CSC, MuonSubdetId::DT, MuonSubdetId::GEM, hfClusterShapes_cfi::hits, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, MuonSubdetId::ME0, DetId::Muon, MuonSubdetId::RPC, and DetId::Tracker.

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

Member Data Documentation

hitCloner

TkClonerImpl MuonTrackLoader::hitCloner

private

Definition at line 106 of file MuonTrackLoader.h.

theAllowNoVtxFlag

bool MuonTrackLoader::theAllowNoVtxFlag

private

Definition at line 115 of file MuonTrackLoader.h.

Referenced by buildTrackAtPCA(), and MuonTrackLoader().

theBeamSpotInputTag

edm::InputTag MuonTrackLoader::theBeamSpotInputTag

private

Definition at line 108 of file MuonTrackLoader.h.

Referenced by MuonTrackLoader().

theBeamSpotToken

edm::EDGetTokenT<reco::BeamSpot> MuonTrackLoader::theBeamSpotToken

private

Definition at line 109 of file MuonTrackLoader.h.

Referenced by MuonTrackLoader().

theL2SeededTkLabel

std::string MuonTrackLoader::theL2SeededTkLabel

private

Label for L2SeededTracks.

Definition at line 112 of file MuonTrackLoader.h.

Referenced by loadTracks(), and MuonTrackLoader().

thePutTkTrackFlag

bool MuonTrackLoader::thePutTkTrackFlag

private

Definition at line 113 of file MuonTrackLoader.h.

Referenced by loadTracks(), and MuonTrackLoader().

theService

const MuonServiceProxy* MuonTrackLoader::theService

private

Definition at line 95 of file MuonTrackLoader.h.

Referenced by buildTrackAtPCA(), buildTrackExtra(), and buildTrackUpdatedAtPCA().

theSmoother

std::unique_ptr<TrajectorySmoother> MuonTrackLoader::theSmoother

private

Definition at line 105 of file MuonTrackLoader.h.

theSmootherToken

edm::ESGetToken<TrajectorySmoother, TrajectoryFitter::Record> MuonTrackLoader::theSmootherToken

private

Definition at line 103 of file MuonTrackLoader.h.

Referenced by MuonTrackLoader().

theSmoothingStep

bool MuonTrackLoader::theSmoothingStep

private

Definition at line 102 of file MuonTrackLoader.h.

Referenced by MuonTrackLoader().

theSmoothTkTrackFlag

bool MuonTrackLoader::theSmoothTkTrackFlag

private

Definition at line 114 of file MuonTrackLoader.h.

Referenced by loadTracks(), and MuonTrackLoader().

theTrackerRecHitBuilderToken

edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> MuonTrackLoader::theTrackerRecHitBuilderToken

private

Definition at line 104 of file MuonTrackLoader.h.

Referenced by MuonTrackLoader().

theTrajectoryFlag

bool MuonTrackLoader::theTrajectoryFlag

private

Definition at line 100 of file MuonTrackLoader.h.

Referenced by MuonTrackLoader().

theUpdatingAtVtx

bool MuonTrackLoader::theUpdatingAtVtx

private

Definition at line 97 of file MuonTrackLoader.h.

Referenced by MuonTrackLoader().

theUpdatorAtVtx

std::unique_ptr<MuonUpdatorAtVertex> MuonTrackLoader::theUpdatorAtVtx

private

Definition at line 98 of file MuonTrackLoader.h.

Referenced by buildTrackAtPCA(), buildTrackUpdatedAtPCA(), and MuonTrackLoader().