Inheritance diagram for MuonsFromRefitTracksProducer:

Public Member Functions
	MuonsFromRefitTracksProducer (const edm::ParameterSet &)

	~MuonsFromRefitTracksProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
reco::Muon *	cloneAndSwitchTrack (const reco::Muon &muon, const reco::Muon::MuonTrackTypePair &newTrack) const

void	produce (edm::Event &, const edm::EventSetup &) override

bool	storeMatchMaps (const edm::Event &event)

Private Attributes
bool	fromCocktail

bool	fromGlobalTrack

bool	fromSigmaSwitch

bool	fromTeVRefit

bool	fromTMR

bool	fromTrackerTrack

double	nSigmaSwitch

double	ptThreshold

edm::InputTag	src

edm::EDGetTokenT< edm::View< reco::Muon > >	srcToken_

std::string	tevMuonTracks

double	TMRcut

edm::Handle< reco::TrackToTrackMap >	trackMap

edm::Handle< reco::TrackToTrackMap >	trackMapDefault

edm::EDGetTokenT< reco::TrackToTrackMap >	trackMapDefaultToken_

edm::Handle< reco::TrackToTrackMap >	trackMapFirstHit

edm::EDGetTokenT< reco::TrackToTrackMap >	trackMapFirstHitToken_

edm::Handle< reco::TrackToTrackMap >	trackMapPicky

edm::EDGetTokenT< reco::TrackToTrackMap >	trackMapPickyToken_

edm::EDGetTokenT< reco::TrackToTrackMap >	trackMapToken_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 67 of file MuonsFromRefitTracksProducer.cc.

Constructor & Destructor Documentation

◆ MuonsFromRefitTracksProducer()

MuonsFromRefitTracksProducer::MuonsFromRefitTracksProducer ( const edm::ParameterSet & cfg )

explicit

Definition at line 147 of file MuonsFromRefitTracksProducer.cc.

     : src(cfg.getParameter<edm::InputTag>("src")),
       fromTrackerTrack(cfg.getParameter<bool>("fromTrackerTrack")),
       fromGlobalTrack(cfg.getParameter<bool>("fromGlobalTrack")),
       tevMuonTracks(cfg.getParameter<std::string>("tevMuonTracks")),
       fromCocktail(cfg.getParameter<bool>("fromCocktail")),
       fromTMR(cfg.getParameter<bool>("fromTMR")),
       TMRcut(cfg.getParameter<double>("TMRcut")),
       fromSigmaSwitch(cfg.getParameter<bool>("fromSigmaSwitch")),
       nSigmaSwitch(cfg.getParameter<double>("nSigmaSwitch")),
       ptThreshold(cfg.getParameter<double>("ptThreshold")) {
   fromTeVRefit = tevMuonTracks != "none";
  
   srcToken_ = consumes<edm::View<reco::Muon> >(src);
   trackMapToken_ = consumes<reco::TrackToTrackMap>(edm::InputTag(tevMuonTracks, "default"));
   trackMapDefaultToken_ = consumes<reco::TrackToTrackMap>(edm::InputTag(tevMuonTracks));
   trackMapFirstHitToken_ = consumes<reco::TrackToTrackMap>(edm::InputTag(tevMuonTracks, "firstHit"));
   trackMapPickyToken_ = consumes<reco::TrackToTrackMap>(edm::InputTag(tevMuonTracks, "picky"));
  
   produces<reco::MuonCollection>();
 }

References fromTeVRefit, src, srcToken_, tevMuonTracks, trackMapDefaultToken_, trackMapFirstHitToken_, trackMapPickyToken_, and trackMapToken_.

◆ ~MuonsFromRefitTracksProducer()

MuonsFromRefitTracksProducer::~MuonsFromRefitTracksProducer ( )

inlineoverride

Definition at line 70 of file MuonsFromRefitTracksProducer.cc.

70 {}

Member Function Documentation

◆ cloneAndSwitchTrack()

reco::Muon * MuonsFromRefitTracksProducer::cloneAndSwitchTrack	(	const reco::Muon &	muon,
		const reco::Muon::MuonTrackTypePair &	newTrack
	)		const

private

Definition at line 181 of file MuonsFromRefitTracksProducer.cc.

                                                                                                                {
   // Muon mass to make a four-vector out of the new track.
   static const double muMass = 0.10566;
  
   reco::TrackRef tkTrack = muon.innerTrack();
   reco::TrackRef muTrack = muon.outerTrack();
  
   // Make up a real Muon from the tracker track.
   reco::Particle::Point vtx(newTrack.first->vx(), newTrack.first->vy(), newTrack.first->vz());
   reco::Particle::LorentzVector p4;
   double p = newTrack.first->p();
   p4.SetXYZT(newTrack.first->px(), newTrack.first->py(), newTrack.first->pz(), sqrt(p * p + muMass * muMass));
  
   reco::Muon* mu = muon.clone();
   mu->setCharge(newTrack.first->charge());
   mu->setP4(p4);
   mu->setVertex(vtx);
   mu->setGlobalTrack(newTrack.first);
   mu->setInnerTrack(tkTrack);
   mu->setOuterTrack(muTrack);
   mu->setBestTrack(newTrack.second);
   return mu;
 }

References amptDefaultParameters_cff::mu, fastsim::Constants::muMass, AlCaHLTBitMon_ParallelJobs::p, p4, mathSSE::sqrt(), and extraflags_cff::vtx.

Referenced by produce().

◆ produce()

void MuonsFromRefitTracksProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	eSetup
	)

overrideprivate

Definition at line 206 of file MuonsFromRefitTracksProducer.cc.

                                                                                        {
   // Get the global muons from the event.
   edm::Handle<edm::View<reco::Muon> > muons;
   event.getByToken(srcToken_, muons);
  
   // If we can't get the global muon collection, or below the
   // track-to-track maps needed, still produce an empty collection of
   // muons so consumers don't throw an exception.
   bool ok = !muons.failedToGet();
  
   // If we're instructed to use the TeV refit tracks in some way, we
   // need the track-to-track maps. If we're making a cocktail muon,
   // get all three track maps (the cocktail ingredients); else just
   // get the map which takes the above global tracks to the desired
   // TeV-muon refitted tracks (firstHit or picky).
   if (ok && fromTeVRefit)
     ok = storeMatchMaps(event);
  
   // Make the output collection.
   auto cands = std::make_unique<reco::MuonCollection>();
  
   if (ok) {
     edm::View<reco::Muon>::const_iterator muon;
     for (muon = muons->begin(); muon != muons->end(); muon++) {
       // Filter out the so-called trackerMuons and stand-alone muons
       // (and caloMuons, if they were ever to get into the input muons
       // collection).
       if (!muon->isGlobalMuon())
         continue;
  
       if (fromTeVRefit || fromSigmaSwitch) {
         // Start out with a null TrackRef.
         reco::Muon::MuonTrackTypePair tevTk;
  
         // If making a cocktail muon, use tevOptimized() to get the track
         // desired. Otherwise, get the refit track from the desired track
         // map.
         if (fromTMR)
           tevTk = tevOptimizedTMR(*muon, *trackMapFirstHit, TMRcut);
         else if (fromCocktail)
           tevTk = muon::tevOptimized(*muon);
         else if (fromSigmaSwitch)
           tevTk = sigmaSwitch(*muon, nSigmaSwitch, ptThreshold);
         else {
           reco::TrackToTrackMap::const_iterator tevTkRef = trackMap->find(muon->combinedMuon());
           if (tevTkRef != trackMap->end())
             tevTk = make_pair(tevTkRef->val, reco::Muon::CombinedTrack);
         }
  
         // If the TrackRef is valid, make a new Muon that has the same
         // tracker and stand-alone tracks, but has the refit track as
         // its global track.
         if (tevTk.first.isNonnull())
           cands->push_back(*cloneAndSwitchTrack(*muon, tevTk));
       } else if (fromTrackerTrack)
         cands->push_back(*cloneAndSwitchTrack(*muon, make_pair(muon->innerTrack(), reco::Muon::InnerTrack)));
       else if (fromGlobalTrack)
         cands->push_back(*cloneAndSwitchTrack(*muon, make_pair(muon->globalTrack(), reco::Muon::CombinedTrack)));
       else {
         cands->push_back(*muon->clone());
  
         // Just cloning does not work in the case of the source being
         // a pat::Muon with embedded track references -- these do not
         // get copied. Explicitly set them.
         reco::Muon& last = cands->at(cands->size() - 1);
         if (muon->globalTrack().isTransient())
           last.setGlobalTrack(muon->globalTrack());
         if (muon->innerTrack().isTransient())
           last.setInnerTrack(muon->innerTrack());
         if (muon->outerTrack().isTransient())
           last.setOuterTrack(muon->outerTrack());
       }
     }
   } else
     edm::LogWarning("MuonsFromRefitTracksProducer") << "either " << src << " or the track map(s) " << tevMuonTracks
                                                     << " not present in the event; producing empty collection";
  
   event.put(std::move(cands));
 }

References HLT_FULL_cff::cands, cloneAndSwitchTrack(), reco::Muon::CombinedTrack, fromCocktail, fromGlobalTrack, fromSigmaSwitch, fromTeVRefit, fromTMR, fromTrackerTrack, reco::Muon::InnerTrack, dqmdumpme::last, eostools::move(), HLT_FULL_cff::muon, PDWG_BPHSkim_cff::muons, nSigmaSwitch, convertSQLiteXML::ok, ptThreshold, sigmaSwitch(), src, srcToken_, storeMatchMaps(), tevMuonTracks, muon::tevOptimized(), tevOptimizedTMR(), TMRcut, trackMap, trackMapFirstHit, and edm::helpers::KeyVal< K, V >::val.

◆ storeMatchMaps()

bool MuonsFromRefitTracksProducer::storeMatchMaps ( const edm::Event & event )

private

Definition at line 169 of file MuonsFromRefitTracksProducer.cc.

                                                                        {
   if (fromCocktail || fromTMR) {
     event.getByToken(trackMapDefaultToken_, trackMapDefault);
     event.getByToken(trackMapFirstHitToken_, trackMapFirstHit);
     event.getByToken(trackMapPickyToken_, trackMapPicky);
     return !trackMapDefault.failedToGet() && !trackMapFirstHit.failedToGet() && !trackMapPicky.failedToGet();
   } else {
     event.getByToken(trackMapToken_, trackMap);
     return !trackMap.failedToGet();
   }
 }