Inheritance diagram for PuppiPhoton:

Public Types
typedef edm::View< reco::Candidate >	CandidateView

typedef math::XYZTLorentzVector	LorentzVector

typedef std::vector< LorentzVector >	LorentzVectorCollection

typedef std::vector< reco::PFCandidate >	PFOutputCollection

typedef edm::View< reco::PFCandidate >	PFView

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

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

	~PuppiPhoton () 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 Member Functions
bool	matchPFCandidate (const reco::Candidate iPF, const reco::Candidate iPho)

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

Private Attributes
std::unique_ptr< PFOutputCollection >	corrCandidates_

std::vector< double >	dRMatch_

double	eta_

std::vector< int32_t >	pdgIds_

double	pt_

edm::EDGetTokenT< edm::ValueMap< std::vector< reco::PFCandidateRef > > >	reco2pf_

bool	runOnMiniAOD_

edm::EDGetTokenT< CandidateView >	tokenPFCandidates_

edm::EDGetTokenT< CandidateView >	tokenPhotonCandidates_

edm::EDGetTokenT< edm::ValueMap< bool > >	tokenPhotonId_

edm::EDGetTokenT< CandidateView >	tokenPuppiCandidates_

edm::EDGetTokenT< edm::ValueMap< float > >	tokenWeights_

bool	usePFphotons_

bool	usePFRef_

bool	usePhotonId_

bool	useValueMap_

double	weight_

Detailed Description

Definition at line 26 of file PuppiPhoton.cc.

Member Typedef Documentation

◆ CandidateView

typedef edm::View<reco::Candidate> PuppiPhoton::CandidateView

Definition at line 34 of file PuppiPhoton.cc.

◆ LorentzVector

typedef math::XYZTLorentzVector PuppiPhoton::LorentzVector

Definition at line 32 of file PuppiPhoton.cc.

◆ LorentzVectorCollection

typedef std::vector<LorentzVector> PuppiPhoton::LorentzVectorCollection

Definition at line 33 of file PuppiPhoton.cc.

◆ PFOutputCollection

typedef std::vector<reco::PFCandidate> PuppiPhoton::PFOutputCollection

Definition at line 35 of file PuppiPhoton.cc.

◆ PFView

typedef edm::View<reco::PFCandidate> PuppiPhoton::PFView

Definition at line 36 of file PuppiPhoton.cc.

Constructor & Destructor Documentation

◆ PuppiPhoton()

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

explicit

Definition at line 61 of file PuppiPhoton.cc.

References dRMatch_, eta_, edm::ParameterSet::getParameter(), pdgIds_, pt_, reco2pf_, runOnMiniAOD_, tokenPFCandidates_, tokenPhotonCandidates_, tokenPhotonId_, tokenPuppiCandidates_, tokenWeights_, usePFphotons_, usePFRef_, usePhotonId_, useValueMap_, and weight_.

                                                        {
   tokenPFCandidates_ = consumes<CandidateView>(iConfig.getParameter<edm::InputTag>("candName"));
   tokenPuppiCandidates_ = consumes<CandidateView>(iConfig.getParameter<edm::InputTag>("puppiCandName"));
   usePFphotons_ = iConfig.getParameter<bool>("usePFphotons");
   if (!usePFphotons_)
     tokenPhotonCandidates_ = consumes<CandidateView>(iConfig.getParameter<edm::InputTag>("photonName"));
   usePhotonId_ = !(iConfig.getParameter<edm::InputTag>("photonId")).label().empty();
   if (usePhotonId_)
     tokenPhotonId_ = consumes<edm::ValueMap<bool>>(iConfig.getParameter<edm::InputTag>("photonId"));
   runOnMiniAOD_ = iConfig.getParameter<bool>("runOnMiniAOD");
   if (!runOnMiniAOD_)
     reco2pf_ =
         consumes<edm::ValueMap<std::vector<reco::PFCandidateRef>>>(iConfig.getParameter<edm::InputTag>("recoToPFMap"));
   useValueMap_ = iConfig.getParameter<bool>("useValueMap");
   if (useValueMap_)
     tokenWeights_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("weightsName"));
 
   pt_ = iConfig.getParameter<double>("pt");
   eta_ = iConfig.getParameter<double>("eta");
   dRMatch_ = iConfig.getParameter<std::vector<double>>("dRMatch");
   pdgIds_ = iConfig.getParameter<std::vector<int32_t>>("pdgids");
   usePFRef_ = iConfig.getParameter<bool>("useRefs");
   weight_ = iConfig.getParameter<double>("weight");
   produces<PFOutputCollection>();
   produces<edm::ValueMap<reco::CandidatePtr>>();
 }

◆ ~PuppiPhoton()

PuppiPhoton::~PuppiPhoton ( )

override

Definition at line 88 of file PuppiPhoton.cc.

88 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 270 of file PuppiPhoton.cc.

References edm::ConfigurationDescriptions::addDefault(), and submitPVResolutionJobs::desc.

                                                                              {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

◆ matchPFCandidate()

bool PuppiPhoton::matchPFCandidate	(	const reco::Candidate *	iPF,
		const reco::Candidate *	iPho
	)

private

Definition at line 259 of file PuppiPhoton.cc.

References funct::abs(), PbPb_ZMuSkimMuonDPG_cff::deltaR, dRMatch_, reco::Candidate::eta(), reco::Candidate::pdgId(), pdgIds_, and reco::Candidate::phi().

Referenced by produce().

                                                                                       {
   if (iPF->pdgId() != iPho->pdgId())
     return false;
   double lDR = deltaR(iPF->eta(), iPF->phi(), iPho->eta(), iPho->phi());
   for (unsigned int i0 = 0; i0 < pdgIds_.size(); i0++) {
     if (std::abs(iPF->pdgId()) == pdgIds_[i0] && lDR < dRMatch_[i0])
       return true;
   }
   return false;
 }

◆ produce()

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

overrideprivate

Definition at line 90 of file PuppiPhoton.cc.

References funct::abs(), pat::Electron::associatedPackedPFCandidates(), pat::Photon::associatedPackedPFCandidates(), edm::View< T >::begin(), ALCARECOTkAlJpsiMuMu_cff::charge, corrCandidates_, edm::View< T >::end(), HCALHighEnergyHPDFilter_cfi::energy, eta_, trigObjTnPSource_cfi::filler, triggerObjects_cff::id, iEvent, matchPFCandidate(), eostools::move(), EgammaValidation_cff::pdgId, edm::Handle< T >::product(), DiDispStaMuonMonitor_cfi::pt, pt_, edm::View< T >::ptrAt(), multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, reco2pf_, edm::View< T >::refAt(), runOnMiniAOD_, reco::LeafCandidate::setP4(), reco::PFCandidate::setSourceCandidatePtr(), edm::View< T >::size(), tokenPFCandidates_, tokenPhotonCandidates_, tokenPhotonId_, tokenPuppiCandidates_, tokenWeights_, reco::PFCandidate::translatePdgIdToType(), usePFphotons_, usePFRef_, usePhotonId_, useValueMap_, contentValuesCheck::values, and weight_.

                                                                        {
   int iC = -1;
   std::vector<const reco::Candidate *> phoCands;
   std::vector<uint16_t> phoIndx;
 
   edm::Handle<edm::ValueMap<std::vector<reco::PFCandidateRef>>> reco2pf;
   if (!runOnMiniAOD_)
     iEvent.getByToken(reco2pf_, reco2pf);
 
   // Get PFCandidate Collection
   edm::Handle<CandidateView> hPFProduct;
   iEvent.getByToken(tokenPFCandidates_, hPFProduct);
   const CandidateView *pfCol = hPFProduct.product();
 
   edm::Handle<CandidateView> hPuppiProduct;
   iEvent.getByToken(tokenPuppiCandidates_, hPuppiProduct);
   const CandidateView *pupCol = hPuppiProduct.product();
   if (usePFphotons_) {
     for (const auto &pho : *pfCol) {
       iC++;
       if (pho.pt() < pt_)
         continue;
       if (std::abs(pho.pdgId()) != 22)
         continue;
       if (fabs(pho.eta()) < eta_) {
         phoIndx.push_back(iC);
         phoCands.push_back(&pho);
       }
     }
   } else {
     edm::Handle<CandidateView> hPhoProduct;
     iEvent.getByToken(tokenPhotonCandidates_, hPhoProduct);
     const CandidateView *phoCol = hPhoProduct.product();
 
     edm::Handle<edm::ValueMap<bool>> photonId;
     if (usePhotonId_)
       iEvent.getByToken(tokenPhotonId_, photonId);
 
     for (CandidateView::const_iterator itPho = phoCol->begin(); itPho != phoCol->end(); itPho++) {
       iC++;
       bool passObject = false;
       if (itPho->isPhoton() && usePhotonId_)
         passObject = (*photonId)[phoCol->ptrAt(iC)];
       if (itPho->pt() < pt_)
         continue;
       if (!passObject && usePhotonId_)
         continue;
       if (runOnMiniAOD_) {
         const pat::Photon *pPho = dynamic_cast<const pat::Photon *>(&(*itPho));
         if (pPho != nullptr) {
           for (const edm::Ref<pat::PackedCandidateCollection> &ref : pPho->associatedPackedPFCandidates()) {
             if (fabs(ref->eta()) < eta_) {
               phoIndx.push_back(ref.key());
               phoCands.push_back(&(*(pfCol->ptrAt(ref.key()))));
             }
           }
           continue;
         }
         const pat::Electron *pElectron = dynamic_cast<const pat::Electron *>(&(*itPho));
         if (pElectron != nullptr) {
           for (const edm::Ref<pat::PackedCandidateCollection> &ref : pElectron->associatedPackedPFCandidates())
             if (fabs(ref->eta()) < eta_) {
               phoIndx.push_back(ref.key());
               phoCands.push_back(&(*(pfCol->ptrAt(ref.key()))));
             }
         }
       } else {
         for (const edm::Ref<std::vector<reco::PFCandidate>> &ref : (*reco2pf)[phoCol->ptrAt(iC)]) {
           if (fabs(ref->eta()) < eta_) {
             phoIndx.push_back(ref.key());
             phoCands.push_back(&(*(pfCol->ptrAt(ref.key()))));
           }
         }
       }
     }
   }
   //Get Weights
   edm::Handle<edm::ValueMap<float>> pupWeights;
   if (useValueMap_)
     iEvent.getByToken(tokenWeights_, pupWeights);
   std::unique_ptr<edm::ValueMap<LorentzVector>> p4PupOut(new edm::ValueMap<LorentzVector>());
   LorentzVectorCollection puppiP4s;
   std::vector<reco::CandidatePtr> values(hPFProduct->size());
   int iPF = 0;
   std::vector<float> lWeights;
   static const reco::PFCandidate dummySinceTranslateIsNotStatic;
   corrCandidates_ = std::make_unique<PFOutputCollection>();
   std::set<int> foundPhoIndex;
   for (CandidateView::const_iterator itPF = pupCol->begin(); itPF != pupCol->end(); itPF++) {
     auto id = dummySinceTranslateIsNotStatic.translatePdgIdToType(itPF->pdgId());
     const reco::PFCandidate *pPF = dynamic_cast<const reco::PFCandidate *>(&(*itPF));
     reco::PFCandidate pCand(pPF ? *pPF : reco::PFCandidate(itPF->charge(), itPF->p4(), id));
     LorentzVector pVec = itPF->p4();
     float pWeight = 1.;
     if (useValueMap_)
       pWeight = (*pupWeights)[pupCol->ptrAt(iPF)];
     if (!usePFRef_) {
       int iPho = -1;
       for (std::vector<const reco::Candidate *>::iterator itPho = phoCands.begin(); itPho != phoCands.end(); itPho++) {
         iPho++;
         if ((!matchPFCandidate(&(*itPF), *itPho)) || (foundPhoIndex.count(iPho) != 0))
           continue;
         pWeight = weight_;
         if (!useValueMap_ && itPF->pt() != 0)
           pWeight = pWeight * (phoCands[iPho]->pt() / itPF->pt());
         if (!useValueMap_ && itPF->pt() == 0)
           pVec.SetPxPyPzE(phoCands[iPho]->px() * pWeight,
                           phoCands[iPho]->py() * pWeight,
                           phoCands[iPho]->pz() * pWeight,
                           phoCands[iPho]->energy() * pWeight);
         foundPhoIndex.insert(iPho);
       }
     } else {
       int iPho = -1;
       for (std::vector<uint16_t>::const_iterator itPho = phoIndx.begin(); itPho != phoIndx.end(); itPho++) {
         iPho++;
         if (pupCol->refAt(iPF).key() != *itPho)
           continue;
         pWeight = weight_;
         if (!useValueMap_ && itPF->pt() != 0)
           pWeight = pWeight * (phoCands[iPho]->pt() / itPF->pt());
         if (!useValueMap_ && itPF->pt() == 0)
           pVec.SetPxPyPzE(phoCands[iPho]->px() * pWeight,
                           phoCands[iPho]->py() * pWeight,
                           phoCands[iPho]->pz() * pWeight,
                           phoCands[iPho]->energy() * pWeight);
         foundPhoIndex.insert(iPho);
       }
     }
     if (itPF->pt() != 0)
       pVec.SetPxPyPzE(itPF->px() * pWeight, itPF->py() * pWeight, itPF->pz() * pWeight, itPF->energy() * pWeight);
 
     lWeights.push_back(pWeight);
     pCand.setP4(pVec);
     puppiP4s.push_back(pVec);
     pCand.setSourceCandidatePtr(itPF->sourceCandidatePtr(0));
     corrCandidates_->push_back(pCand);
     iPF++;
   }
   //Add the missing pfcandidates
   for (unsigned int iPho = 0; iPho < phoCands.size(); iPho++) {
     if (foundPhoIndex.count(iPho) != 0)
       continue;
     auto id = dummySinceTranslateIsNotStatic.translatePdgIdToType(phoCands[iPho]->pdgId());
     reco::PFCandidate pCand(reco::PFCandidate(phoCands[iPho]->charge(), phoCands[iPho]->p4(), id));
     pCand.setSourceCandidatePtr(phoCands[iPho]->sourceCandidatePtr(0));
     LorentzVector pVec = phoCands[iPho]->p4();
     pVec.SetPxPyPzE(phoCands[iPho]->px() * weight_,
                     phoCands[iPho]->py() * weight_,
                     phoCands[iPho]->pz() * weight_,
                     phoCands[iPho]->energy() * weight_);
     pCand.setP4(pVec);
     lWeights.push_back(weight_);
     puppiP4s.push_back(pVec);
     corrCandidates_->push_back(pCand);
   }
   //Fill it into the event
   edm::OrphanHandle<reco::PFCandidateCollection> oh = iEvent.put(std::move(corrCandidates_));
   for (unsigned int ic = 0, nc = pupCol->size(); ic < nc; ++ic) {
     reco::CandidatePtr pkref(oh, ic);
     values[ic] = pkref;
   }
   std::unique_ptr<edm::ValueMap<reco::CandidatePtr>> pfMap_p(new edm::ValueMap<reco::CandidatePtr>());
   edm::ValueMap<reco::CandidatePtr>::Filler filler(*pfMap_p);
   filler.insert(hPFProduct, values.begin(), values.end());
   filler.fill();
   iEvent.put(std::move(pfMap_p));
 }

Member Data Documentation

◆ corrCandidates_

std::unique_ptr<PFOutputCollection> PuppiPhoton::corrCandidates_

private

Definition at line 55 of file PuppiPhoton.cc.

Referenced by produce().

◆ dRMatch_

std::vector<double> PuppiPhoton::dRMatch_

private

Definition at line 53 of file PuppiPhoton.cc.

Referenced by matchPFCandidate(), and PuppiPhoton().

◆ eta_

double PuppiPhoton::eta_

private

Definition at line 48 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ pdgIds_

std::vector<int32_t> PuppiPhoton::pdgIds_

private

Definition at line 54 of file PuppiPhoton.cc.

Referenced by matchPFCandidate(), and PuppiPhoton().

◆ pt_

double PuppiPhoton::pt_

private

Definition at line 47 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ reco2pf_

edm::EDGetTokenT<edm::ValueMap<std::vector<reco::PFCandidateRef> > > PuppiPhoton::reco2pf_

private

Definition at line 44 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ runOnMiniAOD_

bool PuppiPhoton::runOnMiniAOD_

private

Definition at line 51 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ tokenPFCandidates_

edm::EDGetTokenT<CandidateView> PuppiPhoton::tokenPFCandidates_

private

Definition at line 41 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ tokenPhotonCandidates_

edm::EDGetTokenT<CandidateView> PuppiPhoton::tokenPhotonCandidates_

private

Definition at line 43 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ tokenPhotonId_

edm::EDGetTokenT<edm::ValueMap<bool> > PuppiPhoton::tokenPhotonId_

private

Definition at line 46 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ tokenPuppiCandidates_

edm::EDGetTokenT<CandidateView> PuppiPhoton::tokenPuppiCandidates_

private

Definition at line 42 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ tokenWeights_

edm::EDGetTokenT<edm::ValueMap<float> > PuppiPhoton::tokenWeights_

private

Definition at line 45 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ usePFphotons_

bool PuppiPhoton::usePFphotons_

private

Definition at line 50 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ usePFRef_

bool PuppiPhoton::usePFRef_

private

Definition at line 49 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ usePhotonId_

bool PuppiPhoton::usePhotonId_

private

Definition at line 52 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ useValueMap_

bool PuppiPhoton::useValueMap_

private

Definition at line 57 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

◆ weight_

double PuppiPhoton::weight_

private

Definition at line 56 of file PuppiPhoton.cc.

Referenced by produce(), and PuppiPhoton().

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ CandidateView

◆ LorentzVector

◆ LorentzVectorCollection

◆ PFOutputCollection

◆ PFView

Constructor & Destructor Documentation

◆ PuppiPhoton()

◆ ~PuppiPhoton()

Member Function Documentation

◆ fillDescriptions()

◆ matchPFCandidate()

◆ produce()

Member Data Documentation

◆ corrCandidates_

◆ dRMatch_

◆ eta_

◆ pdgIds_

◆ pt_

◆ reco2pf_

◆ runOnMiniAOD_

◆ tokenPFCandidates_

◆ tokenPhotonCandidates_

◆ tokenPhotonId_

◆ tokenPuppiCandidates_

◆ tokenWeights_

◆ usePFphotons_

◆ usePFRef_

◆ usePhotonId_

◆ useValueMap_

◆ weight_