Inheritance diagram for MuonsFromRefitTracksProducer:

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

	~MuonsFromRefitTracksProducer () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::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.

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

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

◆ ~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.

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

Referenced by produce().

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

◆ produce()

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

overrideprivate

Definition at line 206 of file MuonsFromRefitTracksProducer.cc.

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

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

◆ storeMatchMaps()

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

private

Definition at line 169 of file MuonsFromRefitTracksProducer.cc.

References fromCocktail, fromTMR, trackMap, trackMapDefault, trackMapDefaultToken_, trackMapFirstHit, trackMapFirstHitToken_, trackMapPicky, trackMapPickyToken_, and trackMapToken_.

Referenced by produce().

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