#include <ParticleBasedIsoProducer.h>

Inheritance diagram for ParticleBasedIsoProducer:

Public Member Functions
void	beginRun (edm::Run const &r, edm::EventSetup const &es) override

void	endRun (edm::Run const &, edm::EventSetup const &) override

	ParticleBasedIsoProducer (const edm::ParameterSet &conf)

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

	~ParticleBasedIsoProducer () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Attributes
edm::ParameterSet	conf_

std::string	electronCollection_

edm::InputTag	electronProducer_

edm::EDGetTokenT< reco::GsfElectronCollection >	electronProducerT_

edm::InputTag	electronTmpProducer_

edm::EDGetTokenT< reco::GsfElectronCollection >	electronTmpProducerT_

edm::EDGetTokenT< reco::PFCandidateCollection >	pfCandidates_

edm::EDGetTokenT< reco::PFCandidateCollection >	pfEgammaCandidates_

std::string	photonCollection_

edm::InputTag	photonProducer_

edm::EDGetTokenT< reco::PhotonCollection >	photonProducerT_

edm::InputTag	photonTmpProducer_

edm::EDGetTokenT< reco::PhotonCollection >	photonTmpProducerT_

PFBlockBasedIsolation *	thePFBlockBasedIsolation_

edm::EDGetTokenT< edm::ValueMap< reco::GsfElectronRef > >	valMapPFCandToEle_

edm::EDGetTokenT< edm::ValueMap< reco::PhotonRef > >	valMapPFCandToPhoton_

std::string	valueMapElePFCandIso_

std::string	valueMapPFCandEle_

std::string	valueMapPFCandPhoton_

std::string	valueMapPhoPFCandIso_

Additional Inherited Members
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

Detailed Description

Definition at line 17 of file ParticleBasedIsoProducer.h.

Constructor & Destructor Documentation

ParticleBasedIsoProducer::ParticleBasedIsoProducer ( const edm::ParameterSet & conf )

Definition at line 8 of file ParticleBasedIsoProducer.cc.

References conf_, electronProducer_, electronProducerT_, electronTmpProducer_, electronTmpProducerT_, edm::ParameterSet::getParameter(), HLT_2018_cff::InputTag, pfCandidates_, pfEgammaCandidates_, photonProducer_, photonProducerT_, photonTmpProducer_, photonTmpProducerT_, AlCaHLTBitMon_QueryRunRegistry::string, valMapPFCandToEle_, valMapPFCandToPhoton_, valueMapElePFCandIso_, valueMapPFCandEle_, valueMapPFCandPhoton_, and valueMapPhoPFCandIso_.

                                                                               : conf_(conf) {
   photonTmpProducer_ = conf_.getParameter<edm::InputTag>("photonTmpProducer");
   photonProducer_ = conf_.getParameter<edm::InputTag>("photonProducer");
   electronProducer_ = conf_.getParameter<edm::InputTag>("electronProducer");
   electronTmpProducer_ = conf_.getParameter<edm::InputTag>("electronTmpProducer");
 
   photonProducerT_ = consumes<reco::PhotonCollection>(photonProducer_);
 
   photonTmpProducerT_ = consumes<reco::PhotonCollection>(photonTmpProducer_);
 
   electronProducerT_ = consumes<reco::GsfElectronCollection>(electronProducer_);
 
   electronTmpProducerT_ = consumes<reco::GsfElectronCollection>(electronTmpProducer_);
 
   pfCandidates_ = consumes<reco::PFCandidateCollection>(conf_.getParameter<edm::InputTag>("pfCandidates"));
 
   pfEgammaCandidates_ = consumes<reco::PFCandidateCollection>(conf_.getParameter<edm::InputTag>("pfEgammaCandidates"));
 
   valueMapPFCandPhoton_ = conf_.getParameter<std::string>("valueMapPhoToEG");
   valueMapPFCandEle_ = conf_.getParameter<std::string>("valueMapEleToEG");
 
   valMapPFCandToPhoton_ =
       consumes<edm::ValueMap<reco::PhotonRef>>(edm::InputTag("gedPhotonsTmp", valueMapPFCandPhoton_));
 
   valMapPFCandToEle_ =
       consumes<edm::ValueMap<reco::GsfElectronRef>>(edm::InputTag("gedGsfElectronsTmp", valueMapPFCandEle_));
 
   valueMapPhoPFCandIso_ = conf_.getParameter<std::string>("valueMapPhoPFblockIso");
   valueMapElePFCandIso_ = conf_.getParameter<std::string>("valueMapElePFblockIso");
 
   produces<edm::ValueMap<std::vector<reco::PFCandidateRef>>>(valueMapPhoPFCandIso_);
   produces<edm::ValueMap<std::vector<reco::PFCandidateRef>>>(valueMapElePFCandIso_);
 }

ParticleBasedIsoProducer::~ParticleBasedIsoProducer ( )

override

Definition at line 42 of file ParticleBasedIsoProducer.cc.

42 {}

Member Function Documentation

void ParticleBasedIsoProducer::beginRun	(	edm::Run const &	r,
		edm::EventSetup const &	es
	)

override

Definition at line 44 of file ParticleBasedIsoProducer.cc.

References conf_, edm::ParameterSet::getParameter(), particleBasedIsoProducer_cfi::pfBlockBasedIsolationSetUp, PFBlockBasedIsolation::setup(), and thePFBlockBasedIsolation_.

                                                                                  {
   thePFBlockBasedIsolation_ = new PFBlockBasedIsolation();
   edm::ParameterSet pfBlockBasedIsolationSetUp = conf_.getParameter<edm::ParameterSet>("pfBlockBasedIsolationSetUp");
   thePFBlockBasedIsolation_->setup(pfBlockBasedIsolationSetUp);
 }

void ParticleBasedIsoProducer::endRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

override

Definition at line 50 of file ParticleBasedIsoProducer.cc.

References thePFBlockBasedIsolation_.

                                                                                {
   delete thePFBlockBasedIsolation_;
 }

void ParticleBasedIsoProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

override

Definition at line 54 of file ParticleBasedIsoProducer.cc.

References PFBlockBasedIsolation::calculate(), electronProducerT_, electronTmpProducerT_, edm::Event::getByToken(), edm::Ref< C, T, F >::isNonnull(), eostools::move(), pfCandidates_, pfEgammaCandidates_, photonProducerT_, photonTmpProducerT_, edm::Handle< T >::product(), edm::Event::put(), thePFBlockBasedIsolation_, valMapPFCandToEle_, valMapPFCandToPhoton_, valueMapElePFCandIso_, and valueMapPhoPFCandIso_.

                                                                                  {
   edm::Handle<reco::PhotonCollection> photonHandle;
   theEvent.getByToken(photonProducerT_, photonHandle);
 
   edm::Handle<reco::PhotonCollection> photonTmpHandle;
   theEvent.getByToken(photonTmpProducerT_, photonTmpHandle);
 
   edm::Handle<reco::GsfElectronCollection> electronTmpHandle;
   theEvent.getByToken(electronTmpProducerT_, electronTmpHandle);
 
   edm::Handle<reco::GsfElectronCollection> electronHandle;
   theEvent.getByToken(electronProducerT_, electronHandle);
 
   edm::Handle<reco::PFCandidateCollection> pfEGCandidateHandle;
   // Get the  PF refined cluster  collection
   theEvent.getByToken(pfEgammaCandidates_, pfEGCandidateHandle);
 
   edm::Handle<reco::PFCandidateCollection> pfCandidateHandle;
   // Get the  PF candidates collection
   theEvent.getByToken(pfCandidates_, pfCandidateHandle);
 
   edm::ValueMap<reco::PhotonRef> pfEGCandToPhotonMap;
   edm::Handle<edm::ValueMap<reco::PhotonRef>> pfEGCandToPhotonMapHandle;
   theEvent.getByToken(valMapPFCandToPhoton_, pfEGCandToPhotonMapHandle);
   pfEGCandToPhotonMap = *(pfEGCandToPhotonMapHandle.product());
 
   edm::ValueMap<reco::GsfElectronRef> pfEGCandToElectronMap;
   edm::Handle<edm::ValueMap<reco::GsfElectronRef>> pfEGCandToElectronMapHandle;
   theEvent.getByToken(valMapPFCandToEle_, pfEGCandToElectronMapHandle);
   pfEGCandToElectronMap = *(pfEGCandToElectronMapHandle.product());
 
   std::vector<std::vector<reco::PFCandidateRef>> pfCandIsoPairVecPho;
 
   //  std::cout << " ParticleBasedIsoProducer  photonHandle size " << photonHandle->size() << std::endl;
   for (unsigned int lSC = 0; lSC < photonTmpHandle->size(); lSC++) {
     reco::PhotonRef phoRef(reco::PhotonRef(photonTmpHandle, lSC));
 
     // loop over the unbiased candidates to retrieve the ref to the unbiased candidate corresponding to this photon
     unsigned nObj = pfEGCandidateHandle->size();
     reco::PFCandidateRef pfEGCandRef;
 
     std::vector<reco::PFCandidateRef> pfCandIsoPairPho;
     for (unsigned int lCand = 0; lCand < nObj; lCand++) {
       pfEGCandRef = reco::PFCandidateRef(pfEGCandidateHandle, lCand);
       reco::PhotonRef myPho = (pfEGCandToPhotonMap)[pfEGCandRef];
 
       if (myPho.isNonnull()) {
         //std::cout << "ParticleBasedIsoProducer photons PF SC " << pfEGCandRef->superClusterRef()->energy() << " Photon SC " << myPho->superCluster()->energy() << std::endl;
         if (myPho != phoRef)
           continue;
         //  std::cout << " ParticleBasedIsoProducer photons This is my egammaunbiased guy energy " <<  pfEGCandRef->superClusterRef()->energy() << std::endl;
         pfCandIsoPairPho = thePFBlockBasedIsolation_->calculate(myPho->p4(), pfEGCandRef, pfCandidateHandle);
 
         //  for ( std::vector<reco::PFCandidateRef>::const_iterator iPair=pfCandIsoPairPho.begin(); iPair<pfCandIsoPairPho.end(); iPair++) {
         // float dR= deltaR(myPho->eta(),  myPho->phi(), (*iPair)->eta(),  (*iPair)->phi() );
         // std::cout << " ParticleBasedIsoProducer photons  checking the pfCand bool pair " << (*iPair)->particleId() << " dR " << dR << " pt " <<  (*iPair)->pt() << std::endl;
         //  }
       }
     }
 
     pfCandIsoPairVecPho.push_back(pfCandIsoPairPho);
   }
 
   std::vector<std::vector<reco::PFCandidateRef>> pfCandIsoPairVecEle;
   //  std::cout << " ParticleBasedIsoProducer  electronHandle size " << electronHandle->size() << std::endl;
   for (unsigned int lSC = 0; lSC < electronTmpHandle->size(); lSC++) {
     reco::GsfElectronRef eleRef(reco::GsfElectronRef(electronTmpHandle, lSC));
 
     // loop over the unbiased candidates to retrieve the ref to the unbiased candidate corresponding to this electron
     unsigned nObj = pfEGCandidateHandle->size();
     reco::PFCandidateRef pfEGCandRef;
 
     std::vector<reco::PFCandidateRef> pfCandIsoPairEle;
     for (unsigned int lCand = 0; lCand < nObj; lCand++) {
       pfEGCandRef = reco::PFCandidateRef(pfEGCandidateHandle, lCand);
       reco::GsfElectronRef myEle = (pfEGCandToElectronMap)[pfEGCandRef];
 
       if (myEle.isNonnull()) {
         //  std::cout << "ParticleBasedIsoProducer Electorns PF SC " << pfEGCandRef->superClusterRef()->energy() << " Electron SC " << myEle->superCluster()->energy() << std::endl;
         if (myEle != eleRef)
           continue;
 
         //math::XYZVector candidateMomentum(myEle->p4().px(),myEle->p4().py(),myEle->p4().pz());
         //math::XYZVector myDir=candidateMomentum.Unit();
         //  std::cout << " ParticleBasedIsoProducer  Electrons This is my egammaunbiased guy energy " <<  pfEGCandRef->superClusterRef()->energy()  << std::endl;
         //  std::cout << " Ele  direction " << myDir << " eta " << myEle->eta() << " phi " << myEle->phi() << std::endl;
         pfCandIsoPairEle = thePFBlockBasedIsolation_->calculate(myEle->p4(), pfEGCandRef, pfCandidateHandle);
         //for ( std::vector<reco::PFCandidateRef>::const_iterator iPair=pfCandIsoPairEle.begin(); iPair<pfCandIsoPairEle.end(); iPair++) {
         // float dR= deltaR(myEle->eta(),  myEle->phi(), (*iPair)->eta(),  (*iPair)->phi() );
         // std::cout << " ParticleBasedIsoProducer Electron  checking the pfCand bool pair " << (*iPair)->particleId() << " dR " << dR << " pt " <<  (*iPair)->pt() << " eta " << (*iPair)->eta() << " phi " << (*iPair)->phi() <<  std::endl;
         //  }
       }
     }
 
     pfCandIsoPairVecEle.push_back(pfCandIsoPairEle);
   }
 
   auto phoToPFCandIsoMap_p = std::make_unique<edm::ValueMap<std::vector<reco::PFCandidateRef>>>();
   edm::ValueMap<std::vector<reco::PFCandidateRef>>::Filler fillerPhotons(*phoToPFCandIsoMap_p);
 
   fillerPhotons.insert(photonHandle, pfCandIsoPairVecPho.begin(), pfCandIsoPairVecPho.end());
   fillerPhotons.fill();
   theEvent.put(std::move(phoToPFCandIsoMap_p), valueMapPhoPFCandIso_);
 
   auto eleToPFCandIsoMap_p = std::make_unique<edm::ValueMap<std::vector<reco::PFCandidateRef>>>();
   edm::ValueMap<std::vector<reco::PFCandidateRef>>::Filler fillerElectrons(*eleToPFCandIsoMap_p);
 
   fillerElectrons.insert(electronHandle, pfCandIsoPairVecEle.begin(), pfCandIsoPairVecEle.end());
   fillerElectrons.fill();
   theEvent.put(std::move(eleToPFCandIsoMap_p), valueMapElePFCandIso_);
 }