#include <PuppiPhoton.h>

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<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

	~PuppiPhoton ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > 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)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
bool	matchPFCandidate (const reco::Candidate iPF, const reco::Candidate iPho)

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

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_

Additional Inherited Members
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 18 of file PuppiPhoton.h.

Member Typedef Documentation

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

Definition at line 27 of file PuppiPhoton.h.

typedef math::XYZTLorentzVector PuppiPhoton::LorentzVector

Definition at line 25 of file PuppiPhoton.h.

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

Definition at line 26 of file PuppiPhoton.h.

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

Definition at line 28 of file PuppiPhoton.h.

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

Definition at line 29 of file PuppiPhoton.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 30 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().size() != 0;
   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 ( )

Definition at line 56 of file PuppiPhoton.cc.

56 {}

Member Function Documentation

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

static

Definition at line 211 of file PuppiPhoton.cc.

References edm::ConfigurationDescriptions::addDefault(), DEFINE_FWK_MODULE, 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 202 of file PuppiPhoton.cc.

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

privatevirtual

Definition at line 58 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(), eta_, edm::helper::Filler< Map >::fill(), objects.autophobj::filler, edm::Event::getByToken(), hcalTTPDigis_cfi::id, edm::helper::Filler< Map >::insert(), matchPFCandidate(), eostools::move(), p4, cosmictrackingParticleSelector_cfi::pdgId, edm::Handle< T >::product(), EnergyCorrector::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_, MuonErrorMatrixValues_cff::values, and weight_.

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

                                                                        {
   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 != 0) {
         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 != 0) {
         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_.reset( new 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));
 }