Inheritance diagram for MuonWithPFIsoProducer:

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

	~MuonWithPFIsoProducer () override

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

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)

virtual	~ProducerBase () noexcept(false)

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

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

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

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)

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 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(), 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 {

68 }

Member Function Documentation

void MuonWithPFIsoProducer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 71 of file MuonWithPFIsoProducer.cc.

71 {

72 }

void MuonWithPFIsoProducer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 75 of file MuonWithPFIsoProducer.cc.

75 {

76 }

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

overrideprivate

Definition at line 79 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));
 }