#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 40 of file MuonTrackLoader.h.

Member Typedef Documentation

typedef MuonCandidate::CandidateContainer MuonTrackLoader::CandidateContainer

Definition at line 44 of file MuonTrackLoader.h.

typedef MuonCandidate::TrajectoryContainer MuonTrackLoader::TrajectoryContainer

Definition at line 43 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 87 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 120 of file MuonTrackLoader.cc.

References theUpdatorAtVtx.

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

References FreeTrajectoryState::charge(), Trajectory::chiSquared(), FreeTrajectoryState::curvilinearError(), debug, MuonPatternRecoDumper::dumpFTS(), TrajectoryStateOnSurface::freeState(), Trajectory::geometricalInnermostState(), TrajectoryStateOnSurface::globalPosition(), TrackerBounds::isInside(), LogTrace, FreeTrajectoryState::momentum(), ndof, Trajectory::ndof(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::position(), MuonUpdatorAtVertex::propagate(), theAllowNoVtxFlag, theService, theUpdatorAtVtx, 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);
 }

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

private

Definition at line 791 of file MuonTrackLoader.cc.

References alongMomentum, Surface::bounds(), TrajectoryStateOnSurface::curvilinearError(), Trajectory::direction(), Trajectory::firstMeasurement(), TrajectoryStateOnSurface::globalParameters(), Bounds::inside(), Trajectory::lastMeasurement(), LogTrace, 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().

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

References FreeTrajectoryState::charge(), reco::TrackBase::chi2(), FreeTrajectoryState::curvilinearError(), debug, MuonPatternRecoDumper::dumpFTS(), LogTrace, 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().

                                                                                                                        {
 
   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(), and loadTracks().

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 edm::OrphanHandleBase::isValid(), electronStore::links, loadTracks(), LogDebug, LogTrace, position, reco::MuonTrackLinks::setGlobalTrack(), reco::MuonTrackLinks::setStandAloneTrack(), reco::MuonTrackLinks::setTrackerTrack(), theL2SeededTkLabel, thePutTkTrackFlag, theSmoothTkTrackFlag, and HLT_25ns10e33_v2_cff::trackCollection.

                                                           {
 
   const string metname = "Muon|RecoMuon|MuonTrackLoader";
   
   // the muon collection, it will be loaded in the event
   auto_ptr<reco::MuonTrackLinksCollection> trackLinksCollection(new reco::MuonTrackLinksCollection());
   
   // don't waste any time...
   if ( muonCands.empty() ) {
     auto_ptr<reco::TrackExtraCollection> trackExtraCollection(new reco::TrackExtraCollection() );
     auto_ptr<TrackingRecHitCollection> recHitCollection(new TrackingRecHitCollection() );
     auto_ptr<reco::TrackCollection> trackCollection( new reco::TrackCollection() );
 
     event.put(recHitCollection);
     event.put(trackExtraCollection);
     event.put(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(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->size() > 0 && trackerTracks->size() > 0 ) )
     LogWarning(metname)<<"The MuonTrackLinkCollection is incomplete"; 
   
   // put the MuonCollection in the event
   LogTrace(metname) << "put the MuonCollection in the event" << "\n";
   
   return event.put(trackLinksCollection);
 } 

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

staticprivate

Definition at line 47 of file MuonTrackLoader.cc.

References filterCSVwithJSON::copy, MuonSubdetId::CSC, DetId::det(), TrackingRecHit::dimension(), MuonSubdetId::DT, TrackingRecHit::geographicalId(), DetId::Muon, TrackingRecHit::recHits(), 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);
         }
     }
     return hits;
 }