#include <ParticleBasedIsoProducer.h>

Inheritance diagram for ParticleBasedIsoProducer:

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

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

	ParticleBasedIsoProducer (const edm::ParameterSet &conf)

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

	~ParticleBasedIsoProducer ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	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
	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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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::EDProducer
typedef EDProducer	ModuleType

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

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::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

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 ParticleBasedIsoProducer.h.

Constructor & Destructor Documentation

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

Definition at line 10 of file ParticleBasedIsoProducer.cc.

References conf_, electronProducer_, electronProducerT_, electronTmpProducer_, electronTmpProducerT_, edm::ParameterSet::getParameter(), 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 ( )

Definition at line 55 of file ParticleBasedIsoProducer.cc.

                                                     {
 
 }

Member Function Documentation

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

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 61 of file ParticleBasedIsoProducer.cc.

References conf_, edm::ParameterSet::getParameter(), PfBlockBasedIsolation::setup(), and thePFBlockBasedIsolation_.

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

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

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 69 of file ParticleBasedIsoProducer.cc.

References thePFBlockBasedIsolation_.

                                                                                 {
 
   delete thePFBlockBasedIsolation_;
 
 }

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

virtual

Implements edm::EDProducer.

Definition at line 77 of file ParticleBasedIsoProducer.cc.

References PfBlockBasedIsolation::calculate(), electronProducerT_, electronTmpProducerT_, edm::Event::getByToken(), edm::Ref< C, T, F >::isNonnull(), 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); 
 }
  
 
 
 
 
   std::auto_ptr<edm::ValueMap<std::vector<reco::PFCandidateRef>> >  
     phoToPFCandIsoMap_p(new 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(phoToPFCandIsoMap_p,valueMapPhoPFCandIso_);
 
 
   std::auto_ptr<edm::ValueMap<std::vector<reco::PFCandidateRef>> >  
     eleToPFCandIsoMap_p(new 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(eleToPFCandIsoMap_p,valueMapElePFCandIso_);
 
 
 
 
 
 
 
 
 
  
 }