Inheritance diagram for PhotonIDValueMapProducer:

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

	~PhotonIDValueMapProducer ()

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)

	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
std::vector< ConsumesInfo >	consumesInfo () const

	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

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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
reco::PFCandidate::ParticleType	candidatePdgId (const edm::Ptr< reco::Candidate > candidate, bool isAOD)

template<class T , class U >
float	computeWorstPFChargedIsolation (const T &photon, const U &pfCandidates, const edm::Handle< reco::VertexCollection > vertices, bool isAOD, float dRmax, float dxyMax, float dzMax)

const reco::Track *	getTrackPointer (const edm::Ptr< reco::Candidate > candidate, bool isAOD)

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

void	writeValueMap (edm::Event &iEvent, const edm::Handle< edm::View< reco::Photon > > &handle, const std::vector< float > &values, const std::string &label) const

Private Attributes
edm::EDGetTokenT < EcalRecHitCollection >	ebReducedRecHitCollection_

edm::EDGetTokenT < EcalRecHitCollection >	ebReducedRecHitCollectionMiniAOD_

edm::EDGetTokenT < EcalRecHitCollection >	eeReducedRecHitCollection_

edm::EDGetTokenT < EcalRecHitCollection >	eeReducedRecHitCollectionMiniAOD_

edm::EDGetTokenT < EcalRecHitCollection >	esReducedRecHitCollection_

edm::EDGetTokenT < EcalRecHitCollection >	esReducedRecHitCollectionMiniAOD_

std::unique_ptr < noZS::EcalClusterLazyTools >	lazyToolnoZS

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

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

edm::EDGetTokenT< edm::View < reco::Candidate > >	pfCandidatesToken_

edm::EDGetTokenT< edm::View < reco::Candidate > >	pfCandidatesTokenMiniAOD_

edm::EDGetToken	src_

edm::EDGetToken	srcMiniAOD_

edm::EDGetTokenT < reco::VertexCollection >	vtxToken_

edm::EDGetTokenT < reco::VertexCollection >	vtxTokenMiniAOD_

Static Private Attributes
static char	phoChargedIsolation_ [] = "phoChargedIsolation"

static char	phoESEffSigmaRR_ [] = "phoESEffSigmaRR"

static char	phoFull5x5E1x3_ [] = "phoFull5x5E1x3"

static char	phoFull5x5E2x2_ [] = "phoFull5x5E2x2"

static char	phoFull5x5E2x5Max_ [] = "phoFull5x5E2x5Max"

static char	phoFull5x5E5x5_ [] = "phoFull5x5E5x5"

static char	phoFull5x5SigmaIEtaIEta_ [] = "phoFull5x5SigmaIEtaIEta"

static char	phoFull5x5SigmaIEtaIPhi_ [] = "phoFull5x5SigmaIEtaIPhi"

static char	phoNeutralHadronIsolation_ [] = "phoNeutralHadronIsolation"

static char	phoPhotonIsolation_ [] = "phoPhotonIsolation"

static char	phoWorstChargedIsolation_ [] = "phoWorstChargedIsolation"

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

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

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 40 of file PhotonIDValueMapProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 132 of file PhotonIDValueMapProducer.cc.

References ebReducedRecHitCollection_, ebReducedRecHitCollectionMiniAOD_, eeReducedRecHitCollection_, eeReducedRecHitCollectionMiniAOD_, esReducedRecHitCollection_, esReducedRecHitCollectionMiniAOD_, edm::ParameterSet::getParameter(), particleBasedIsolationToken_, pfCandidatesToken_, pfCandidatesTokenMiniAOD_, phoChargedIsolation_, phoESEffSigmaRR_, phoFull5x5E1x3_, phoFull5x5E2x2_, phoFull5x5E2x5Max_, phoFull5x5E5x5_, phoFull5x5SigmaIEtaIEta_, phoFull5x5SigmaIEtaIPhi_, phoNeutralHadronIsolation_, phoPhotonIsolation_, phoWorstChargedIsolation_, src_, srcMiniAOD_, vtxToken_, and vtxTokenMiniAOD_.

                                                                                  {
 
   //
   // Declare consummables, handle both AOD and miniAOD case
   //
   ebReducedRecHitCollection_        = mayConsume<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>
                                        ("ebReducedRecHitCollection"));
   ebReducedRecHitCollectionMiniAOD_ = mayConsume<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>
                                        ("ebReducedRecHitCollectionMiniAOD"));
 
   eeReducedRecHitCollection_        = mayConsume<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>
                                        ("eeReducedRecHitCollection"));
   eeReducedRecHitCollectionMiniAOD_ = mayConsume<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>
                                        ("eeReducedRecHitCollectionMiniAOD"));
 
   esReducedRecHitCollection_        = mayConsume<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>
                                        ("esReducedRecHitCollection"));
   esReducedRecHitCollectionMiniAOD_ = mayConsume<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>
                                        ("esReducedRecHitCollectionMiniAOD"));
 
   vtxToken_        = mayConsume<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertices"));
   vtxTokenMiniAOD_ = mayConsume<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("verticesMiniAOD"));
 
   // reco photons are castable into pat photons, so no need to handle reco/pat seprately
   src_        = mayConsume<edm::View<reco::Photon> >(iConfig.getParameter<edm::InputTag>("src"));
   srcMiniAOD_ = mayConsume<edm::View<reco::Photon> >(iConfig.getParameter<edm::InputTag>("srcMiniAOD"));
 
   // The particleBasedIsolation object is relevant only for AOD, RECO format
   particleBasedIsolationToken_ = mayConsume<edm::ValueMap<std::vector<reco::PFCandidateRef > > >
     (iConfig.getParameter<edm::InputTag>("particleBasedIsolation"));
   
   // AOD has reco::PFCandidate vector, and miniAOD has pat::PackedCandidate vector.
   // Both inherit from reco::Candidate, so we go to the base class. We can cast into
   // the full type later if needed. Since the collection names are different, we
   // introduce both collections
   pfCandidatesToken_        = mayConsume< edm::View<reco::Candidate> >(iConfig.getParameter<edm::InputTag>("pfCandidates")); 
   pfCandidatesTokenMiniAOD_ = mayConsume< edm::View<reco::Candidate> >(iConfig.getParameter<edm::InputTag>("pfCandidatesMiniAOD")); 
 
   //
   // Declare producibles
   //
   // Cluster shapes
   produces<edm::ValueMap<float> >(phoFull5x5SigmaIEtaIEta_);  
   produces<edm::ValueMap<float> >(phoFull5x5SigmaIEtaIPhi_);  
   produces<edm::ValueMap<float> >(phoFull5x5E1x3_);  
   produces<edm::ValueMap<float> >(phoFull5x5E2x2_);  
   produces<edm::ValueMap<float> >(phoFull5x5E2x5Max_);  
   produces<edm::ValueMap<float> >(phoFull5x5E5x5_);  
   produces<edm::ValueMap<float> >(phoESEffSigmaRR_);  
   // Isolations
   produces<edm::ValueMap<float> >(phoChargedIsolation_);  
   produces<edm::ValueMap<float> >(phoNeutralHadronIsolation_);  
   produces<edm::ValueMap<float> >(phoPhotonIsolation_);  
   produces<edm::ValueMap<float> >(phoWorstChargedIsolation_);  
 
 }

PhotonIDValueMapProducer::~PhotonIDValueMapProducer ( )

Definition at line 189 of file PhotonIDValueMapProducer.cc.

189 {

190 }

Member Function Documentation

reco::PFCandidate::ParticleType PhotonIDValueMapProducer::candidatePdgId	(	const edm::Ptr< reco::Candidate >	candidate,
		bool	isAOD
	)

private

Definition at line 493 of file PhotonIDValueMapProducer.cc.

References funct::abs(), reco::PFCandidate::gamma, reco::PFCandidate::h, reco::PFCandidate::h0, SingleMuPt40Fwdv2_cfi_GEN_SIM::pdgId, and reco::PFCandidate::X.

Referenced by computeWorstPFChargedIsolation(), and produce().

                                 {
   
   reco::PFCandidate::ParticleType thisCandidateType = reco::PFCandidate::X;
   if( isAOD )
     thisCandidateType = ( (const recoCandPtr)candidate)->particleId();
   else {
     // the neutral hadrons and charged hadrons can be of pdgId types
     // only 130 (K0L) and +-211 (pi+-) in packed candidates
     const int pdgId = ( (const patCandPtr)candidate)->pdgId();
     if( pdgId == 22 )
       thisCandidateType = reco::PFCandidate::gamma;
     else if( abs(pdgId) == 130) // PDG ID for K0L
       thisCandidateType = reco::PFCandidate::h0;
     else if( abs(pdgId) == 211) // PDG ID for pi+-
       thisCandidateType = reco::PFCandidate::h;
   }
   return thisCandidateType;
 }

template<class T , class U >

float PhotonIDValueMapProducer::computeWorstPFChargedIsolation	(	const T &	photon,
		const U &	pfCandidates,
		const edm::Handle< reco::VertexCollection >	vertices,
		bool	isAOD,
		float	dRmax,
		float	dxyMax,
		float	dzMax
	)

private

Definition at line 426 of file PhotonIDValueMapProducer.cc.

References candidatePdgId(), reco::deltaR2(), reco::TrackBase::dxy(), reco::TrackBase::dz(), objects.IsoTrackAnalyzer::dzMax, getTrackPointer(), reco::PFCandidate::h, i, and PtMinSelector_cfg::ptMin.

Referenced by produce().

                                                         {
 
   float worstIsolation = 999;
   std::vector<float> allIsolations;
 
   // Constants below: there are no vetos and no min pt requirement,
   // just like in the original H->gamma gamma code.
   const float dRvetoBarrel = 0.0;
   const float dRvetoEndcap = 0.0;
   const float ptMin = 0.0;
   
   float dRveto;
   if (photon->isEB())
     dRveto = dRvetoBarrel;
   else
     dRveto = dRvetoEndcap;
 
   //Calculate isolation sum separately for each vertex
   for(unsigned int ivtx=0; ivtx<vertices->size(); ++ivtx) {
     
     // Shift the photon according to the vertex
     reco::VertexRef vtx(vertices, ivtx);
     math::XYZVector photon_directionWrtVtx(photon->superCluster()->x() - vtx->x(),
                        photon->superCluster()->y() - vtx->y(),
                        photon->superCluster()->z() - vtx->z());
     
     float sum = 0;
     // Loop over the PFCandidates
     for(unsigned i=0; i<pfCandidates->size(); i++) {
       
       const auto& iCand = pfCandidates->ptrAt(i);
 
       //require that PFCandidate is a charged hadron
       reco::PFCandidate::ParticleType thisCandidateType = candidatePdgId(iCand, isAOD);
       if (thisCandidateType != reco::PFCandidate::h) 
     continue;
 
       if (iCand->pt() < ptMin)
     continue;
       
       const reco::Track *theTrack = getTrackPointer( iCand, isAOD );
       float dxy = theTrack->dxy(vtx->position());
       if( fabs(dxy) > dxyMax) continue;
       
       float dz = theTrack->dz(vtx->position());
       if ( fabs(dz) > dzMax) continue;
       
       float dR2 = deltaR2(photon_directionWrtVtx.Eta(), photon_directionWrtVtx.Phi(), 
                           iCand->eta(),      iCand->phi());
       if(dR2 > dRmax*dRmax || dR2 < dRveto*dRveto) continue;
       
       sum += iCand->pt();
     }
 
     allIsolations.push_back(sum);
   }
 
   if( allIsolations.size()>0 )
     worstIsolation = * std::max_element( allIsolations.begin(), allIsolations.end() );
   
   return worstIsolation;
 }

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

static

Definition at line 414 of file PhotonIDValueMapProducer.cc.

References edm::ConfigurationDescriptions::addDefault(), 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);
 }

const reco::Track * PhotonIDValueMapProducer::getTrackPointer	(	const edm::Ptr< reco::Candidate >	candidate,
		bool	isAOD
	)

private

Definition at line 514 of file PhotonIDValueMapProducer.cc.

Referenced by computeWorstPFChargedIsolation(), and produce().

                                                                                           {
 
   const reco::Track* theTrack = nullptr;
   if( isAOD )
     theTrack = &*( ((const recoCandPtr) candidate)->trackRef());
   else
     theTrack = &( ((const patCandPtr) candidate)->pseudoTrack());
 
   return theTrack;
 }

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

overrideprivatevirtual

Implements edm::stream::EDProducerBase.

Definition at line 192 of file PhotonIDValueMapProducer.cc.

References candidatePdgId(), computeWorstPFChargedIsolation(), reco::deltaR2(), reco::TrackBase::dxy(), reco::TrackBase::dz(), objects.IsoTrackAnalyzer::dzMax, ebReducedRecHitCollection_, ebReducedRecHitCollectionMiniAOD_, eeReducedRecHitCollection_, eeReducedRecHitCollectionMiniAOD_, esReducedRecHitCollection_, esReducedRecHitCollectionMiniAOD_, Exception, reco::PFCandidate::gamma, edm::Event::getByToken(), getTrackPointer(), reco::PFCandidate::h, reco::PFCandidate::h0, isInFootprint(), edm::detail::isnan(), lazyToolnoZS, particleBasedIsolationToken_, pfCandidatesToken_, pfCandidatesTokenMiniAOD_, phoChargedIsolation_, phoESEffSigmaRR_, phoFull5x5E1x3_, phoFull5x5E2x2_, phoFull5x5E2x5Max_, phoFull5x5E5x5_, phoFull5x5SigmaIEtaIEta_, phoFull5x5SigmaIEtaIPhi_, phoNeutralHadronIsolation_, phoPhotonIsolation_, phoWorstChargedIsolation_, MetAnalyzer::pv(), cmsHarvester::sep, mathSSE::sqrt(), alcazmumu_cfi::src, src_, srcMiniAOD_, FrontierCondition_GT_autoExpress_cfi::test, HLT_25ns10e33_v2_cff::vertices, vtxToken_, vtxTokenMiniAOD_, and writeValueMap().

                                                                                     {
 
   using namespace edm;
 
   // Constants 
   const float coneSizeDR = 0.3;
   const float dxyMax = 0.1;
   const float dzMax  = 0.2;
 
   edm::Handle<edm::View<reco::Photon> > src;
 
   bool isAOD = true;
   iEvent.getByToken(src_, src);
   if( !src.isValid() ){
     isAOD = false;
     iEvent.getByToken(srcMiniAOD_,src);
   }
   if( !src.isValid() ) {
     throw cms::Exception("IllDefinedDataTier")
       << "DataFormat does not contain a photon source!";
   }
 
   // Configure Lazy Tools
   if( isAOD )
     lazyToolnoZS = std::unique_ptr<noZS::EcalClusterLazyTools>(new noZS::EcalClusterLazyTools(iEvent, iSetup, 
                           ebReducedRecHitCollection_,
                           eeReducedRecHitCollection_,
                           esReducedRecHitCollection_));
   else
     lazyToolnoZS = std::unique_ptr<noZS::EcalClusterLazyTools>(new noZS::EcalClusterLazyTools(iEvent, iSetup, 
                           ebReducedRecHitCollectionMiniAOD_,
               eeReducedRecHitCollectionMiniAOD_,
               esReducedRecHitCollectionMiniAOD_)); 
   
   // Get PV
   edm::Handle<reco::VertexCollection> vertices;
   iEvent.getByToken(vtxToken_, vertices);
   if( !vertices.isValid() )
     iEvent.getByToken(vtxTokenMiniAOD_, vertices);
   if (vertices->empty()) return; // skip the event if no PV found
   const reco::Vertex &pv = vertices->front();
   
   edm::Handle< edm::ValueMap<std::vector<reco::PFCandidateRef > > > particleBasedIsolationMap;
   if( isAOD ){
     // this exists only in AOD
     iEvent.getByToken(particleBasedIsolationToken_, particleBasedIsolationMap);
   }
 
   edm::Handle< edm::View<reco::Candidate> > pfCandidatesHandle;
 
   iEvent.getByToken(pfCandidatesToken_, pfCandidatesHandle);
   if( !pfCandidatesHandle.isValid() )
     iEvent.getByToken(pfCandidatesTokenMiniAOD_, pfCandidatesHandle);
 
   if( !isAOD && src->size() ) {
     edm::Ptr<pat::Photon> test(src->ptrAt(0));
     if( test.isNull() || !test.isAvailable() ) {
       throw cms::Exception("InvalidConfiguration")
     <<"DataFormat is detected as miniAOD but cannot cast to pat::Photon!";
     }
   }
 
   // size_t n = src->size();
   // Cluster shapes
   std::vector<float> phoFull5x5SigmaIEtaIEta;
   std::vector<float> phoFull5x5SigmaIEtaIPhi;
   std::vector<float> phoFull5x5E1x3;
   std::vector<float> phoFull5x5E2x2;
   std::vector<float> phoFull5x5E2x5Max;
   std::vector<float> phoFull5x5E5x5;
   std::vector<float> phoESEffSigmaRR;
   // Isolations
   std::vector<float> phoChargedIsolation;
   std::vector<float> phoNeutralHadronIsolation;
   std::vector<float> phoPhotonIsolation;
   std::vector<float> phoWorstChargedIsolation;
   
   // reco::Photon::superCluster() is virtual so we can exploit polymorphism
   for (unsigned idxpho = 0; idxpho < src->size(); ++idxpho) {
     const auto& iPho = src->ptrAt(idxpho);
 
     //    
     // Compute full 5x5 quantities
     //
     const auto& theseed = *(iPho->superCluster()->seed());
     
     // For full5x5_sigmaIetaIeta, for 720 we use: lazy tools for AOD,
     // and userFloats or lazy tools for miniAOD. From some point in 72X and on, one can
     // retrieve the full5x5 directly from the object with ->full5x5_sigmaIetaIeta()
     // for both formats.
     float see = -999;
     std::vector<float> vCov = lazyToolnoZS->localCovariances( theseed );
     see = (isnan(vCov[0]) ? 0. : sqrt(vCov[0]));
     float sep = vCov[1];
     phoFull5x5SigmaIEtaIEta.push_back(see);
     phoFull5x5SigmaIEtaIPhi.push_back(sep);
 
     phoFull5x5E1x3   .push_back(lazyToolnoZS-> e1x3   (theseed) );
     phoFull5x5E2x2   .push_back(lazyToolnoZS-> e2x2   (theseed) );
     phoFull5x5E2x5Max.push_back(lazyToolnoZS-> e2x5Max(theseed) );
     phoFull5x5E5x5   .push_back(lazyToolnoZS-> e5x5   (theseed) );
 
     phoESEffSigmaRR  .push_back(lazyToolnoZS->eseffsirir( *(iPho->superCluster()) ) );
 
     // 
     // Compute absolute uncorrected isolations with footprint removal
     //
     
     // First, find photon direction with respect to the good PV
     math::XYZVector photon_directionWrtVtx(iPho->superCluster()->x() - pv.x(),
                                            iPho->superCluster()->y() - pv.y(),
                                            iPho->superCluster()->z() - pv.z());
 
     // Zero the isolation sums
     float chargedIsoSum = 0;
     float neutralHadronIsoSum = 0;
     float photonIsoSum = 0;
 
     // Loop over all PF candidates
     for (unsigned idxcand = 0; idxcand < pfCandidatesHandle->size(); ++idxcand ){
 
       // Here, the type will be a simple reco::Candidate. We cast it
       // for full PFCandidate or PackedCandidate below as necessary
       const auto& iCand = pfCandidatesHandle->ptrAt(idxcand);
 
       // One would think that we should check that this iCand from 
       // the generic PF collection is not identical to the iPho photon
       // for which we are computing the isolations. However, it turns out
       // to be unnecessary. Below, in the function isInFootprint(), we drop
       // this iCand if it is in the footprint, and this always removes
       // the iCand if it matches the iPho.
       //     The explicit check at this point is not totally trivial because
       // of non-triviality of implementation of this check for miniAOD (PackedCandidates
       // of the PF collection do not contain the supercluser link, so can't use that).
       // if( isAOD ){
       //    if( ((const recoCandPtr)iCand)->superClusterRef() == iPho->superCluster() ) continue;
       // }
 
 
       // Check if this candidate is within the isolation cone
       float dR2 = deltaR2(photon_directionWrtVtx.Eta(),photon_directionWrtVtx.Phi(), 
             iCand->eta(), iCand->phi());
       if( dR2 > coneSizeDR*coneSizeDR ) continue;
 
       // Check if this candidate is not in the footprint
       bool inFootprint = false;
       if(isAOD) {
         inFootprint = isInFootprint( (*particleBasedIsolationMap)[iPho], iCand );
       } else {  
         edm::Ptr<pat::Photon> patPhotonPtr(src->ptrAt(idxpho));
         inFootprint = isInFootprint(patPhotonPtr->associatedPackedPFCandidates(), iCand);
       }
 
       if( inFootprint ) continue;
 
       // Find candidate type
       reco::PFCandidate::ParticleType thisCandidateType = candidatePdgId(iCand, isAOD);
 
       // Increment the appropriate isolation sum
       if( thisCandidateType == reco::PFCandidate::h ){
     // for charged hadrons, additionally check consistency
     // with the PV
     const reco::Track *theTrack = getTrackPointer( iCand, isAOD );
 
     float dxy = theTrack->dxy(pv.position());
     if(fabs(dxy) > dxyMax) continue;
 
     float dz  = theTrack->dz(pv.position());
     if (fabs(dz) > dzMax) continue;
 
     // The candidate is eligible, increment the isolaiton
     chargedIsoSum += iCand->pt();
       }
 
       if( thisCandidateType == reco::PFCandidate::h0 )
     neutralHadronIsoSum += iCand->pt();
 
       if( thisCandidateType == reco::PFCandidate::gamma )
     photonIsoSum += iCand->pt();
     }
 
     phoChargedIsolation      .push_back( chargedIsoSum       );
     phoNeutralHadronIsolation.push_back( neutralHadronIsoSum );
     phoPhotonIsolation       .push_back( photonIsoSum        );
 
     float worstChargedIso =
       computeWorstPFChargedIsolation(iPho, pfCandidatesHandle, vertices, 
                      isAOD, coneSizeDR, dxyMax, dzMax);
     phoWorstChargedIsolation .push_back( worstChargedIso );
     
 
   }
   
   // Cluster shapes
   writeValueMap(iEvent, src, phoFull5x5SigmaIEtaIEta, phoFull5x5SigmaIEtaIEta_);  
   writeValueMap(iEvent, src, phoFull5x5SigmaIEtaIPhi, phoFull5x5SigmaIEtaIPhi_);  
   writeValueMap(iEvent, src, phoFull5x5E1x3   , phoFull5x5E1x3_);  
   writeValueMap(iEvent, src, phoFull5x5E2x2   , phoFull5x5E2x2_);  
   writeValueMap(iEvent, src, phoFull5x5E2x5Max, phoFull5x5E2x5Max_);  
   writeValueMap(iEvent, src, phoFull5x5E5x5   , phoFull5x5E5x5_);  
   writeValueMap(iEvent, src, phoESEffSigmaRR  , phoESEffSigmaRR_);  
   // Isolations
   writeValueMap(iEvent, src, phoChargedIsolation, phoChargedIsolation_);  
   writeValueMap(iEvent, src, phoNeutralHadronIsolation, phoNeutralHadronIsolation_);  
   writeValueMap(iEvent, src, phoPhotonIsolation, phoPhotonIsolation_);  
   writeValueMap(iEvent, src, phoWorstChargedIsolation, phoWorstChargedIsolation_);  
 }

void PhotonIDValueMapProducer::writeValueMap	(	edm::Event &	iEvent,
		const edm::Handle< edm::View< reco::Photon > > &	handle,
		const std::vector< float > &	values,
		const std::string &	label
	)		const

private

Definition at line 400 of file PhotonIDValueMapProducer.cc.

References edm::helper::Filler< Map >::fill(), patZpeak::handle, edm::helper::Filler< Map >::insert(), and edm::Event::put().

Referenced by produce().

 {
   using namespace edm; 
   using namespace std;
   auto_ptr<ValueMap<float> > valMap(new ValueMap<float>());
   edm::ValueMap<float>::Filler filler(*valMap);
   filler.insert(handle, values.begin(), values.end());
   filler.fill();
   iEvent.put(valMap, label);
 }