Inheritance diagram for MuonWithPFIsoProducerCopy:

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

	~MuonWithPFIsoProducerCopy ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

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

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
virtual void	beginJob ()

virtual void	endJob ()

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

Private Attributes
double	gammaIsoVeto_

edm::InputTag	muonTag_

double	neutralHadronIsoVeto_

edm::InputTag	pfTag_

double	trackIsoVeto_

bool	usePfMuonsOnly_

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

Public Types inherited from edm::ProducerBase
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 12 of file MuonWithPFIsoProducerCopy.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 44 of file MuonWithPFIsoProducerCopy.cc.

References gammaIsoVeto_, edm::ParameterSet::getUntrackedParameter(), HLT_FULL_cff::InputTag, muonTag_, neutralHadronIsoVeto_, pfTag_, trackIsoVeto_, and usePfMuonsOnly_.

                                                                                 {
 
   // What is being produced
       produces<std::vector<reco::Muon> >();
 
   // Muon collection
       muonTag_ = pset.getUntrackedParameter<edm::InputTag> ("MuonTag", edm::InputTag("muons"));
 
   // PF candidate collection
       pfTag_ = 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);
 
 } 

MuonWithPFIsoProducerCopy::~MuonWithPFIsoProducerCopy ( )

Definition at line 66 of file MuonWithPFIsoProducerCopy.cc.

66 {

67 }

Member Function Documentation

void MuonWithPFIsoProducerCopy::beginJob ( void )

privatevirtual

Reimplemented from edm::EDProducer.

Definition at line 70 of file MuonWithPFIsoProducerCopy.cc.

70 {

71 }

void MuonWithPFIsoProducerCopy::endJob ( void )

privatevirtual

Reimplemented from edm::EDProducer.

Definition at line 74 of file MuonWithPFIsoProducerCopy.cc.

74 {

75 }

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

privatevirtual

Implements edm::EDProducer.

Definition at line 78 of file MuonWithPFIsoProducerCopy.cc.

References reco::Muon::clone(), deltaR(), reco::PFCandidate::e, reco::PFCandidate::egamma_HF, reco::MuonIsolation::emEt, reco::MuonIsolation::emVetoEt, reco::PFCandidate::gamma, gammaIsoVeto_, edm::Event::getByLabel(), reco::PFCandidate::h, reco::PFCandidate::h0, reco::PFCandidate::h_HF, reco::MuonIsolation::hadEt, reco::MuonIsolation::hadVetoEt, i, reco::Muon::innerTrack(), edm::Ref< C, T, F >::isNonnull(), j, reco::LeafCandidate::momentum(), RPCpg::mu, reco::PFCandidate::mu, muonTag_, neutralHadronIsoVeto_, MuonAlignmentFromReference_cff::newmuons, reco::MuonIsolation::nTracks, reco::PFCandidate::particleId(), pfTag_, reco::LeafCandidate::pt(), edm::Event::put(), reco::Muon::setIsolation(), reco::MuonIsolation::sumPt, reco::MuonIsolation::trackerVetoPt, trackIsoVeto_, reco::PFCandidate::trackRef(), and usePfMuonsOnly_.

                                                                                  {
 
       // Initialize pointer to new output muon collection
       std::auto_ptr<reco::MuonCollection> newmuons (new reco::MuonCollection);
 
       // Get Muon collection
       edm::Handle<edm::View<reco::Muon> > muonCollection;
       if (!ev.getByLabel(muonTag_, muonCollection)) {
             edm::LogError("") << ">>> Muon collection does not exist !!!";
             ev.put(newmuons);
             return;
       }
 
       // Get PFCandidate collection
       edm::Handle<edm::View<reco::PFCandidate> > pfCollection;
       if (!ev.getByLabel(pfTag_, pfCollection)) {
             edm::LogError("") << ">>> PFCandidate collection does not exist !!!";
             ev.put(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(newmuons);
 }