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 28 of file PuppiPhoton.cc.

Member Typedef Documentation

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

Definition at line 36 of file PuppiPhoton.cc.

typedef math::XYZTLorentzVector PuppiPhoton::LorentzVector

Definition at line 34 of file PuppiPhoton.cc.

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

Definition at line 35 of file PuppiPhoton.cc.

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

Definition at line 37 of file PuppiPhoton.cc.

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

Definition at line 38 of file PuppiPhoton.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 63 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 ( )

override

Definition at line 90 of file PuppiPhoton.cc.

90 {}

Member Function Documentation

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

static

Definition at line 272 of file PuppiPhoton.cc.

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

                                                                              {
   //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);
 }

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

private

Definition at line 261 of file PuppiPhoton.cc.

References funct::abs(), HLT_FULL_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;
 }

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

overrideprivate

Definition at line 92 of file PuppiPhoton.cc.

References funct::abs(), pat::Electron::associatedPackedPFCandidates(), pat::Photon::associatedPackedPFCandidates(), edm::View< T >::begin(), RecoTauCleanerPlugins::charge, corrCandidates_, edm::View< T >::end(), relval_parameters_module::energy, eta_, edm::helper::Filler< Map >::fill(), edm::Event::getByToken(), gpuClustering::id, edm::helper::Filler< Map >::insert(), matchPFCandidate(), eostools::move(), edm::Handle< T >::product(), DiDispStaMuonMonitor_cfi::pt, pt_, edm::View< T >::ptrAt(), edm::Event::put(), 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_, makeHLTPrescaleTable::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));
 }