Inheritance diagram for PhotonIDValueMapProducer:

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

	~PhotonIDValueMapProducer () override

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

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

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

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, ModuleToResolverIndicies 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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) 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
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, float dRvetoBarrel, float dRvetoEndcap, float ptMin)

std::pair< float, float >	getTrackDxyDz (const edm::Ptr< reco::Candidate > &candidate, const reco::Particle::Point &vtxpos, bool isAOD)

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_

bool	usesES_

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"

static char	phoWorstChargedIsolationWithConeVeto_ [] = "phoWorstChargedIsolationWithConeVeto"

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
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

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

References ebReducedRecHitCollection_, ebReducedRecHitCollectionMiniAOD_, eeReducedRecHitCollection_, eeReducedRecHitCollectionMiniAOD_, esReducedRecHitCollection_, esReducedRecHitCollectionMiniAOD_, edm::ParameterSet::getParameter(), edm::InputTag::label(), diffTwoXMLs::label, particleBasedIsolationToken_, pfCandidatesToken_, pfCandidatesTokenMiniAOD_, phoChargedIsolation_, phoESEffSigmaRR_, phoFull5x5E1x3_, phoFull5x5E2x2_, phoFull5x5E2x5Max_, phoFull5x5E5x5_, phoFull5x5SigmaIEtaIEta_, phoFull5x5SigmaIEtaIPhi_, phoNeutralHadronIsolation_, phoPhotonIsolation_, phoWorstChargedIsolation_, phoWorstChargedIsolationWithConeVeto_, src_, srcMiniAOD_, usesES_, 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"));
 
   if (!iConfig.getParameter<edm::InputTag>("esReducedRecHitCollection").label().empty() ||
       !iConfig.getParameter<edm::InputTag>("esReducedRecHitCollectionMiniAOD").label().empty()) {
       usesES_ = true;
       esReducedRecHitCollection_        = mayConsume<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>
                                                                            ("esReducedRecHitCollection"));
       esReducedRecHitCollectionMiniAOD_ = mayConsume<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>
                                                                            ("esReducedRecHitCollectionMiniAOD"));
       
   } else {
       usesES_ = false;
   }
 
   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_);  
   produces<edm::ValueMap<float> >(phoWorstChargedIsolationWithConeVeto_);  
 
 }

PhotonIDValueMapProducer::~PhotonIDValueMapProducer ( )

override

Definition at line 203 of file PhotonIDValueMapProducer.cc.

203 {

204 }

Member Function Documentation

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

private

Definition at line 529 of file PhotonIDValueMapProducer.cc.

References funct::abs(), reco::PFCandidate::gamma, reco::PFCandidate::h, reco::PFCandidate::h0, common_cff::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,
		float	dRvetoBarrel,
		float	dRvetoEndcap,
		float	ptMin
	)

private

Definition at line 469 of file PhotonIDValueMapProducer.cc.

References candidatePdgId(), reco::deltaR2(), AlignmentTrackSelector_cfi::dzMax, getTrackDxyDz(), reco::PFCandidate::h, mps_fire::i, ALCARECOTkAlBeamHalo_cff::ptMin, and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by fillDescriptions(), and produce().

                                                                      {
 
 
   float worstIsolation = 999;
   std::vector<float> allIsolations;
 
   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;
 
       auto dxydz = getTrackDxyDz(iCand, vtx->position(), isAOD);
       if ( fabs(dxydz.first) > dxyMax) continue;
       if ( fabs(dxydz.second) > 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.empty() )
     worstIsolation = * std::max_element( allIsolations.begin(), allIsolations.end() );
   
   return worstIsolation;
 }

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

static

Definition at line 457 of file PhotonIDValueMapProducer.cc.

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

std::pair< float, float > PhotonIDValueMapProducer::getTrackDxyDz	(	const edm::Ptr< reco::Candidate > &	candidate,
		const reco::Particle::Point &	vtxpos,
		bool	isAOD
	)

private

Definition at line 550 of file PhotonIDValueMapProducer.cc.

References DEFINE_FWK_MODULE, reco::TrackBase::dxy(), pat::PackedCandidate::dxy(), reco::TrackBase::dz(), and pat::PackedCandidate::dz().

Referenced by computeWorstPFChargedIsolation(), and produce().

                                                                                                                              {
 
   if( isAOD ) {
     const reco::Track & theTrack = *recoCandPtr(candidate)->trackRef();
     return std::make_pair(theTrack.dxy(vtxpos),theTrack.dz(vtxpos));
   } else {
     const pat::PackedCandidate & theCand = *(patCandPtr(candidate));
     return std::make_pair(theCand.dxy(vtxpos),theCand.dz(vtxpos));
   }
 
 }

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

overrideprivate

Definition at line 206 of file PhotonIDValueMapProducer.cc.

References candidatePdgId(), computeWorstPFChargedIsolation(), reco::deltaR2(), AlignmentTrackSelector_cfi::dzMax, heepElectronID_HEEPV50_CSA14_25ns_cff::e5x5, ebReducedRecHitCollection_, ebReducedRecHitCollectionMiniAOD_, eeReducedRecHitCollection_, eeReducedRecHitCollectionMiniAOD_, esReducedRecHitCollection_, esReducedRecHitCollectionMiniAOD_, Exception, reco::PFCandidate::gamma, edm::Event::getByToken(), getTrackDxyDz(), reco::PFCandidate::h, reco::PFCandidate::h0, iEvent, isInFootprint(), edm::detail::isnan(), edm::HandleBase::isValid(), lazyToolnoZS, particleBasedIsolationToken_, pfCandidatesToken_, pfCandidatesTokenMiniAOD_, egammaObjectModificationsInMiniAOD_cff::phoChargedIsolation, phoChargedIsolation_, phoESEffSigmaRR_, phoFull5x5E1x3_, phoFull5x5E2x2_, phoFull5x5E2x5Max_, phoFull5x5E5x5_, phoFull5x5SigmaIEtaIEta_, phoFull5x5SigmaIEtaIPhi_, egammaObjectModificationsInMiniAOD_cff::phoNeutralHadronIsolation, phoNeutralHadronIsolation_, egammaObjectModificationsInMiniAOD_cff::phoPhotonIsolation, phoPhotonIsolation_, egammaObjectModificationsInMiniAOD_cff::phoWorstChargedIsolation, phoWorstChargedIsolation_, phoWorstChargedIsolationWithConeVeto_, reco::Vertex::position(), ALCARECOTkAlBeamHalo_cff::ptMin, MetAnalyzer::pv(), mathSSE::sqrt(), TrackRefitter_38T_cff::src, src_, srcMiniAOD_, PFTauMVAInputDiscriminatorTranslator_cfi::test, usesES_, electrons_cff::vertices, vtxToken_, vtxTokenMiniAOD_, writeValueMap(), reco::Vertex::x(), reco::Vertex::y(), and reco::Vertex::z().

                                                                                     {
 
   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 (usesES_) {
       if( isAOD )
         lazyToolnoZS = std::make_unique<noZS::EcalClusterLazyTools>(iEvent, iSetup, 
                                                       ebReducedRecHitCollection_,
                                                       eeReducedRecHitCollection_,
                                                       esReducedRecHitCollection_);
       else
         lazyToolnoZS = std::make_unique<noZS::EcalClusterLazyTools>(iEvent, iSetup, 
                                                       ebReducedRecHitCollectionMiniAOD_,
                                                       eeReducedRecHitCollectionMiniAOD_,
                                                       esReducedRecHitCollectionMiniAOD_); 
   } else {
       if( isAOD )
         lazyToolnoZS = std::make_unique<noZS::EcalClusterLazyTools>(iEvent, iSetup, 
                                                       ebReducedRecHitCollection_,
                                                       eeReducedRecHitCollection_);
       else
         lazyToolnoZS = std::make_unique<noZS::EcalClusterLazyTools>(iEvent, iSetup, 
                                                       ebReducedRecHitCollectionMiniAOD_,
                                                       eeReducedRecHitCollectionMiniAOD_); 
 
   }
   
   // 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->empty() ) {
     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;
   std::vector<float> phoWorstChargedIsolationWithConeVeto;
   
   // 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
 
         auto dxydz = getTrackDxyDz(iCand, pv.position(), isAOD);
         if ( fabs(dxydz.first) > dxyMax) continue;
         if ( fabs(dxydz.second) > 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        );
 
     // Worst isolation computed with no vetos or ptMin cut, as in
     // Run 1 Hgg code.
     float dRvetoBarrel = 0.0;
     float dRvetoEndcap = 0.0;
     float ptMin = 0.0;
     float worstChargedIso =
       computeWorstPFChargedIsolation(iPho, pfCandidatesHandle, vertices, 
                      isAOD, coneSizeDR, dxyMax, dzMax,
                      dRvetoBarrel, dRvetoEndcap, ptMin);
     phoWorstChargedIsolation .push_back( worstChargedIso );
 
     // Worst isolation computed with cone vetos and a ptMin cut, as in 
     // Run 2 Hgg code.
     dRvetoBarrel = 0.02;
     dRvetoEndcap = 0.02;
     ptMin = 0.1;
     float worstChargedIsoWithConeVeto =
       computeWorstPFChargedIsolation(iPho, pfCandidatesHandle, vertices, 
                      isAOD, coneSizeDR, dxyMax, dzMax,
                      dRvetoBarrel, dRvetoEndcap, ptMin);
     phoWorstChargedIsolationWithConeVeto .push_back( worstChargedIsoWithConeVeto );
 
     
 
   }
   
   // 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OB
   writeValueMap(iEvent, src, phoChargedIsolation, phoChargedIsolation_);  
   writeValueMap(iEvent, src, phoNeutralHadronIsolation, phoNeutralHadronIsolation_);  
   writeValueMap(iEvent, src, phoPhotonIsolation, phoPhotonIsolation_);  
   writeValueMap(iEvent, src, phoWorstChargedIsolation, phoWorstChargedIsolation_);  
   writeValueMap(iEvent, src, phoWorstChargedIsolationWithConeVeto, phoWorstChargedIsolationWithConeVeto_);  
 }

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

References objects.autophobj::filler, cmsBatch::handle, eostools::move(), and edm::Event::put().

Referenced by produce().

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