Inheritance diagram for PATMuonMerger:

Public Member Functions
	PATMuonMerger (const edm::ParameterSet &iConfig)

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

	~PATMuonMerger () 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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Attributes
edm::InputTag	lostTrack_

StringCutObjectSelector < pat::PackedCandidate, false >	lostTrackCut_

edm::EDGetTokenT< std::vector < pat::PackedCandidate > >	lostTrackToken_

edm::InputTag	muons_

StringCutObjectSelector < pat::Muon, false >	muonsCut_

edm::EDGetTokenT< std::vector < pat::Muon > >	muonToken_

edm::InputTag	pfCandidate_

StringCutObjectSelector < pat::PackedCandidate, false >	pfCandidateCut_

edm::EDGetTokenT< std::vector < pat::PackedCandidate > >	pfCandToken_

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 21 of file PATMuonMerger.cc.

Constructor & Destructor Documentation

PATMuonMerger::PATMuonMerger ( const edm::ParameterSet & iConfig )

explicit

Definition at line 42 of file PATMuonMerger.cc.

References lostTrack_, lostTrackToken_, muons_, muonToken_, pfCandidate_, and pfCandToken_.

     : muons_(iConfig.getParameter<edm::InputTag>("muons")),
       muonsCut_(iConfig.getParameter<std::string>("muonCut")),
       pfCandidate_(iConfig.getParameter<edm::InputTag>("pfCandidates")),
       pfCandidateCut_(iConfig.getParameter<std::string>("pfCandidatesCut")),
       lostTrack_(iConfig.getParameter<edm::InputTag>("otherTracks")),
       lostTrackCut_(iConfig.getParameter<std::string>("lostTrackCut")) {
   muonToken_ = consumes<std::vector<pat::Muon>>(muons_);
   pfCandToken_ = consumes<std::vector<pat::PackedCandidate>>(pfCandidate_);
   lostTrackToken_ = consumes<std::vector<pat::PackedCandidate>>(lostTrack_);
   produces<std::vector<pat::Muon>>();
 }

PATMuonMerger::~PATMuonMerger ( )

inlineoverride

Definition at line 24 of file PATMuonMerger.cc.

24 {}

Member Function Documentation

void PATMuonMerger::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 55 of file PATMuonMerger.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                {
   // mergedMuons
   edm::ParameterSetDescription desc;
   desc.add<std::string>("muonCut", "");
   desc.add<edm::InputTag>("otherTracks", edm::InputTag("lostTracks"));
   desc.add<edm::InputTag>("pfCandidates", edm::InputTag("packedPFCandidates"));
   desc.add<std::string>("pfCandidatesCut", "");
   desc.add<edm::InputTag>("muons", edm::InputTag("slimmedMuons"));
   desc.add<std::string>("lostTrackCut", "");
   descriptions.add("mergedMuonsNoCuts", desc);
 }

void PATMuonMerger::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

override

Definition at line 67 of file PATMuonMerger.cc.

References funct::abs(), relval_parameters_module::energy, edm::Event::getByToken(), mps_fire::i, edm::Ptr< T >::isNonnull(), lostTrackCut_, lostTracks_cfi::lostTracks, lostTrackToken_, eostools::move(), RPCpg::mu, HLT_FULL_cff::muon, patZpeak::muons, muonsCut_, muonToken_, dqmiodumpmetadata::n, submitPVResolutionJobs::out, pfCandidateCut_, pfCandToken_, edm::Event::put(), and mathSSE::sqrt().

                                                                          {
   edm::Handle<std::vector<pat::Muon>> muons;
   edm::Handle<std::vector<pat::PackedCandidate>> pfCands;
   edm::Handle<std::vector<pat::PackedCandidate>> lostTracks;
 
   iEvent.getByToken(muonToken_, muons);
   iEvent.getByToken(pfCandToken_, pfCands);
   iEvent.getByToken(lostTrackToken_, lostTracks);
 
   auto out = std::make_unique<std::vector<pat::Muon>>();
   out->reserve(muons->size() + pfCands->size() + lostTracks->size());
 
   // copy all muons
   for (auto& muon : *muons) {
     if (!muonsCut_(muon))
       continue;
     out->push_back(muon);
   }
 
   // add other pfCandidates, removing duplicates
   for (unsigned int pf = 0; pf < pfCands->size(); ++pf) {
     auto pfCand = pfCands->at(pf);
     if (!pfCandidateCut_(pfCand))
       continue;
     reco::CandidatePtr pfCandPtr(pfCands, pf);
     bool isPFMuon = false;
     for (auto& muon : *muons) {
       for (unsigned int i = 0, n = muon.numberOfSourceCandidatePtrs(); i < n; ++i) {
         reco::CandidatePtr ptr = muon.sourceCandidatePtr(i);
         if (ptr.isNonnull() && ptr == pfCandPtr) {
           isPFMuon = true;
           break;
         }
       }
       if (isPFMuon)
         break;
     }
     if (isPFMuon) {
       continue;
     }
 
     // now make a reco::Muon and recast to pat::Muon
     double energy = sqrt(pfCand.p() * pfCand.p() + 0.011163691);
     math::XYZTLorentzVector p4(pfCand.px(), pfCand.py(), pfCand.pz(), energy);
     reco::Muon mu(pfCand.charge(), p4, pfCand.vertex());
     pat::Muon aMu(mu);
     out->push_back(aMu);
   }
 
   // adding now lost tracks, removing duplicates
   for (auto& lostTrack : *lostTracks) {
     if (!lostTrackCut_(lostTrack))
       continue;
     if (std::abs(lostTrack.pdgId()) == 13)
       continue;
 
     // now make a reco::Muon and recast to pat::Muon
     double energy = sqrt(lostTrack.p() * lostTrack.p() + 0.011163691);
     math::XYZTLorentzVector p4(lostTrack.px(), lostTrack.py(), lostTrack.pz(), energy);
     reco::Muon mu(lostTrack.charge(), p4, lostTrack.vertex());
     pat::Muon aMu(mu);
     out->push_back(aMu);
   }
   iEvent.put(std::move(out));
 }