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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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

References fillDescriptions(), and iEvent.

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(), 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(), DEFINE_FWK_MODULE, edm::Event::getByToken(), mps_fire::i, edm::Ptr< T >::isNonnull(), lostTrackCut_, isotracks_cff::lostTracks, lostTrackToken_, eostools::move(), RPCpg::mu, extraflags_cff::muons, muonsCut_, muonToken_, gen::n, MillePedeFileConverter_cfg::out, p4, packedPFCandidateRefMixer_cfi::pf, 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));
 }