Inheritance diagram for MuonWithPFIsoProducer:

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

	~MuonWithPFIsoProducer () override

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	beginJob () override

void	endJob () override

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

Private Attributes
double	gammaIsoVeto_

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

double	neutralHadronIsoVeto_

edm::EDGetTokenT< edm::View< reco::PFCandidate > >	pfToken_

double	trackIsoVeto_

bool	usePfMuonsOnly_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 16 of file MuonWithPFIsoProducer.cc.

Constructor & Destructor Documentation

MuonWithPFIsoProducer::MuonWithPFIsoProducer ( const edm::ParameterSet & pset )

explicit

Definition at line 45 of file MuonWithPFIsoProducer.cc.

References gammaIsoVeto_, edm::ParameterSet::getUntrackedParameter(), HLT_2018_cff::InputTag, muonToken_, neutralHadronIsoVeto_, pfToken_, trackIsoVeto_, and usePfMuonsOnly_.

                                                                         {
   // What is being produced
   produces<std::vector<reco::Muon> >();
 
   // Muon collection
   muonToken_ =
       consumes<edm::View<reco::Muon> >(pset.getUntrackedParameter<edm::InputTag>("MuonTag", edm::InputTag("muons")));
 
   // PF candidate collection
   pfToken_ = consumes<edm::View<reco::PFCandidate> >(
       pset.getUntrackedParameter<edm::InputTag>("PFTag", edm::InputTag("particleFlow")));
 
   // Use only PF muons to get exact consistency with PfMET
   usePfMuonsOnly_ = pset.getUntrackedParameter<bool>("UsePfMuonsOnly", false);
 
   // Veto cone
   trackIsoVeto_ = pset.getUntrackedParameter<double>("TrackIsoVeto", 0.01);
   gammaIsoVeto_ = pset.getUntrackedParameter<double>("GammaIsoVeto", 0.07);
   neutralHadronIsoVeto_ = pset.getUntrackedParameter<double>("NeutralHadronIsoVeto", 0.1);
 }

MuonWithPFIsoProducer::~MuonWithPFIsoProducer ( )

override

Definition at line 67 of file MuonWithPFIsoProducer.cc.

67 {}

Member Function Documentation

void MuonWithPFIsoProducer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 70 of file MuonWithPFIsoProducer.cc.

70 {}

void MuonWithPFIsoProducer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 73 of file MuonWithPFIsoProducer.cc.

73 {}

void MuonWithPFIsoProducer::produce	(	edm::Event &	ev,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 76 of file MuonWithPFIsoProducer.cc.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

                                                                              {
   // Initialize pointer to new output muon collection
   std::unique_ptr<reco::MuonCollection> newmuons(new reco::MuonCollection);
 
   // Get Muon collection
   edm::Handle<edm::View<reco::Muon> > muonCollection;
   if (!ev.getByToken(muonToken_, muonCollection)) {
     edm::LogError("") << ">>> Muon collection does not exist !!!";
     ev.put(std::move(newmuons));
     return;
   }
 
   // Get PFCandidate collection
   edm::Handle<edm::View<reco::PFCandidate> > pfCollection;
   if (!ev.getByToken(pfToken_, pfCollection)) {
     edm::LogError("") << ">>> PFCandidate collection does not exist !!!";
     ev.put(std::move(newmuons));
     return;
   }
 
   // Loop over Pf candidates to find muons and collect deposits in veto,
   // dR<0.3 and dR<0.5 cones. Interpret "track" as charged particles (e,mu,
   // chraged hadrons). Interpret "em" as photons and also as electromagnetic
   // energy in HF. Interpret "had" as neutral hadrons and also as hadronic
   // energy in HF. Apply weights if requested at input level.
   // HO energies are not filled. Ditto for jet energies around the muon.
   unsigned int muonCollectionSize = muonCollection->size();
   unsigned int pfCollectionSize = pfCollection->size();
   for (unsigned int i = 0; i < muonCollectionSize; i++) {
     edm::RefToBase<reco::Muon> mu = muonCollection->refAt(i);
 
     // Ask for PfMuon consistency if requested
     bool muonFound = false;
 
     // Starting bycloning this muon
     reco::Muon* newmu = mu->clone();
     reco::TrackRef tk = mu->innerTrack();
 
     // Set isolations
     reco::MuonIsolation iso03;
     reco::MuonIsolation iso05;
     // Loop on all candidates
     for (unsigned int j = 0; j < pfCollectionSize; j++) {
       edm::RefToBase<reco::PFCandidate> pf = pfCollection->refAt(j);
 
       // Check the muon is in the PF collection when required
       bool thisIsTheMuon = false;
       if (tk.isNonnull() && pf->trackRef() == tk) {
         thisIsTheMuon = true;
         muonFound = true;
       }
 
       // Get dR. Nothing to add if dR>0.5
       double deltaR = Geom::deltaR(mu->momentum(), pf->momentum());
       if (deltaR > 0.5)
         continue;
 
       // Fill "tracker" components
       if (pf->particleId() == reco::PFCandidate::h || pf->particleId() == reco::PFCandidate::e ||
           pf->particleId() == reco::PFCandidate::mu) {
         if (deltaR < trackIsoVeto_ || thisIsTheMuon) {
           iso05.trackerVetoPt += pf->pt();
           iso03.trackerVetoPt += pf->pt();
         } else {
           iso05.sumPt += pf->pt();
           iso05.nTracks++;
           if (deltaR < 0.3) {
             iso03.sumPt += pf->pt();
             iso03.nTracks++;
           }
         }
         // Fill "em" components
       } else if (pf->particleId() == reco::PFCandidate::gamma || pf->particleId() == reco::PFCandidate::egamma_HF) {
         if (deltaR < gammaIsoVeto_) {
           iso05.emVetoEt += pf->pt();
           iso03.emVetoEt += pf->pt();
         } else {
           iso05.emEt += pf->pt();
           if (deltaR < 0.3)
             iso03.emEt += pf->pt();
         }
         // Fill "had" components
       } else if (pf->particleId() == reco::PFCandidate::h0 || pf->particleId() == reco::PFCandidate::h_HF) {
         if (deltaR < neutralHadronIsoVeto_) {
           iso05.hadVetoEt += pf->pt();
           iso03.hadVetoEt += pf->pt();
         } else {
           iso05.hadEt += pf->pt();
           if (deltaR < 0.3)
             iso03.hadEt += pf->pt();
         }
       }
     }
 
     // Do not take this muon (under explicit request) if it is not a PfMuon
     if (usePfMuonsOnly_ && (!muonFound))
       continue;
 
     // Set this isolation information in the new muon
     newmu->setIsolation(iso03, iso05);
 
     // Add new muon to output collection
     newmuons->push_back(*newmu);
   }
 
   // Add output collection to event
   ev.put(std::move(newmuons));
 }