#include "PhysicsTools/PatAlgos/interface/PATPhotonProducer.h"

Inheritance diagram for pat::PATPhotonProducer:

Public Member Functions
	PATPhotonProducer (const edm::ParameterSet &iConfig)

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

	~PATPhotonProducer () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Private Types
typedef std::vector< edm::Handle< edm::ValueMap< IsoDeposit > > >	IsoDepositMaps

typedef std::pair< pat::IsolationKeys, edm::InputTag >	IsolationLabel

typedef std::vector< IsolationLabel >	IsolationLabels

typedef std::vector< edm::Handle< edm::ValueMap< double > > >	IsolationValueMaps

typedef std::pair< std::string, edm::InputTag >	NameTag

Private Member Functions
template<typename T >
void	readIsolationLabels (const edm::ParameterSet &iConfig, const char *psetName, IsolationLabels &labels, std::vector< edm::EDGetTokenT< edm::ValueMap< T > > > &tokens)

Private Attributes
bool	addEfficiencies_

bool	addGenMatch_

bool	addPFClusterIso_

bool	addPhotonID_

bool	addPuppiIsolation_

bool	addResolutions_

edm::EDGetTokenT< reco::BeamSpot >	beamLineToken_

const EcalClusterLazyTools::ESGetTokens	ecalClusterToolsESGetTokens_

const CaloGeometry *	ecalGeometry_

edm::EDGetTokenT< edm::ValueMap< float > >	ecalPFClusterIsoT_

const CaloTopology *	ecalTopology_

pat::helper::EfficiencyLoader	efficiencyLoader_

edm::EDGetTokenT< reco::GsfElectronCollection >	electronToken_

bool	embedBasicClusters_

bool	embedGenMatch_

bool	embedPreshowerClusters_

bool	embedRecHits_

bool	embedSeedCluster_

bool	embedSuperCluster_

GreaterByEt< Photon >	eTComparator_

std::vector< edm::EDGetTokenT< edm::Association< reco::GenParticleCollection > > >	genMatchTokens_

edm::EDGetTokenT< edm::ValueMap< float > >	hcalPFClusterIsoT_

edm::EDGetTokenT< reco::ConversionCollection >	hConversionsToken_

IsolationLabels	isoDepositLabels_

std::vector< edm::EDGetTokenT< edm::ValueMap< IsoDeposit > > >	isoDepositTokens_

IsolationLabels	isolationValueLabels_

std::vector< edm::EDGetTokenT< edm::ValueMap< double > > >	isolationValueTokens_

pat::helper::MultiIsolator	isolator_

pat::helper::MultiIsolator::IsolationValuePairs	isolatorTmpStorage_

std::vector< NameTag >	photIDSrcs_

std::vector< edm::EDGetTokenT< edm::ValueMap< Bool_t > > >	photIDTokens_

edm::EDGetTokenT< edm::View< reco::Photon > >	photonToken_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPIIsolation_charged_hadrons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPIIsolation_neutral_hadrons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPIIsolation_photons_

edm::InputTag	reducedBarrelRecHitCollection_

edm::EDGetTokenT< EcalRecHitCollection >	reducedBarrelRecHitCollectionToken_

edm::InputTag	reducedEndcapRecHitCollection_

edm::EDGetTokenT< EcalRecHitCollection >	reducedEndcapRecHitCollectionToken_

pat::helper::KinResolutionsLoader	resolutionLoader_

bool	saveRegressionData_

pat::PATUserDataHelper< pat::Photon >	userDataHelper_

bool	useUserData_

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

Produces the pat::Photon.

The PATPhotonProducer produces the analysis-level pat::Photon starting from a collection of objects of PhotonType.

Author: Steven Lowette

Version

Id: PATPhotonProducer.h,v 1.19 2009/06/25 23:49:35 gpetrucc Exp

Definition at line 52 of file PATPhotonProducer.h.

Member Typedef Documentation

◆ IsoDepositMaps

typedef std::vector<edm::Handle<edm::ValueMap<IsoDeposit> > > pat::PATPhotonProducer::IsoDepositMaps

private

Definition at line 93 of file PATPhotonProducer.h.

◆ IsolationLabel

typedef std::pair<pat::IsolationKeys, edm::InputTag> pat::PATPhotonProducer::IsolationLabel

private

Definition at line 95 of file PATPhotonProducer.h.

◆ IsolationLabels

typedef std::vector<IsolationLabel> pat::PATPhotonProducer::IsolationLabels

private

Definition at line 96 of file PATPhotonProducer.h.

◆ IsolationValueMaps

typedef std::vector<edm::Handle<edm::ValueMap<double> > > pat::PATPhotonProducer::IsolationValueMaps

private

Definition at line 94 of file PATPhotonProducer.h.

◆ NameTag

typedef std::pair<std::string, edm::InputTag> pat::PATPhotonProducer::NameTag

private

Definition at line 121 of file PATPhotonProducer.h.

Constructor & Destructor Documentation

◆ PATPhotonProducer()

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

explicit

Definition at line 31 of file PATPhotonProducer.cc.

     :
  
       ecalClusterToolsESGetTokens_{consumesCollector()},
       isolator_(iConfig.exists("userIsolation") ? iConfig.getParameter<edm::ParameterSet>("userIsolation")
                                                 : edm::ParameterSet(),
                 consumesCollector(),
                 false),
       useUserData_(iConfig.exists("userData")) {
   // initialize the configurables
   photonToken_ = consumes<edm::View<reco::Photon>>(iConfig.getParameter<edm::InputTag>("photonSource"));
   electronToken_ = consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("electronSource"));
   hConversionsToken_ = consumes<reco::ConversionCollection>(iConfig.getParameter<edm::InputTag>("conversionSource"));
   beamLineToken_ = consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamLineSrc"));
   embedSuperCluster_ = iConfig.getParameter<bool>("embedSuperCluster");
   embedSeedCluster_ = iConfig.getParameter<bool>("embedSeedCluster");
   embedBasicClusters_ = iConfig.getParameter<bool>("embedBasicClusters");
   embedPreshowerClusters_ = iConfig.getParameter<bool>("embedPreshowerClusters");
   embedRecHits_ = iConfig.getParameter<bool>("embedRecHits");
   reducedBarrelRecHitCollection_ = iConfig.getParameter<edm::InputTag>("reducedBarrelRecHitCollection");
   reducedBarrelRecHitCollectionToken_ = mayConsume<EcalRecHitCollection>(reducedBarrelRecHitCollection_);
   reducedEndcapRecHitCollection_ = iConfig.getParameter<edm::InputTag>("reducedEndcapRecHitCollection");
   reducedEndcapRecHitCollectionToken_ = mayConsume<EcalRecHitCollection>(reducedEndcapRecHitCollection_);
   // MC matching configurables
   addGenMatch_ = iConfig.getParameter<bool>("addGenMatch");
   if (addGenMatch_) {
     embedGenMatch_ = iConfig.getParameter<bool>("embedGenMatch");
     if (iConfig.existsAs<edm::InputTag>("genParticleMatch")) {
       genMatchTokens_.push_back(consumes<edm::Association<reco::GenParticleCollection>>(
           iConfig.getParameter<edm::InputTag>("genParticleMatch")));
     } else {
       genMatchTokens_ = edm::vector_transform(
           iConfig.getParameter<std::vector<edm::InputTag>>("genParticleMatch"),
           [this](edm::InputTag const &tag) { return consumes<edm::Association<reco::GenParticleCollection>>(tag); });
     }
   }
   // Efficiency configurables
   addEfficiencies_ = iConfig.getParameter<bool>("addEfficiencies");
   if (addEfficiencies_) {
     efficiencyLoader_ =
         pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"), consumesCollector());
   }
   // PFCluster Isolation maps
   addPuppiIsolation_ = iConfig.getParameter<bool>("addPuppiIsolation");
   if (addPuppiIsolation_) {
     PUPPIIsolation_charged_hadrons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationChargedHadrons"));
     PUPPIIsolation_neutral_hadrons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationNeutralHadrons"));
     PUPPIIsolation_photons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationPhotons"));
   }
   addPFClusterIso_ = iConfig.getParameter<bool>("addPFClusterIso");
   if (addPFClusterIso_) {
     ecalPFClusterIsoT_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("ecalPFClusterIsoMap"));
     auto hcPFC = iConfig.getParameter<edm::InputTag>("hcalPFClusterIsoMap");
     if (not hcPFC.label().empty())
       hcalPFClusterIsoT_ = consumes<edm::ValueMap<float>>(hcPFC);
   }
  
   // photon ID configurables
   addPhotonID_ = iConfig.getParameter<bool>("addPhotonID");
   if (addPhotonID_) {
     // it might be a single photon ID
     if (iConfig.existsAs<edm::InputTag>("photonIDSource")) {
       photIDSrcs_.push_back(NameTag("", iConfig.getParameter<edm::InputTag>("photonIDSource")));
     }
     // or there might be many of them
     if (iConfig.existsAs<edm::ParameterSet>("photonIDSources")) {
       // please don't configure me twice
       if (!photIDSrcs_.empty()) {
         throw cms::Exception("Configuration")
             << "PATPhotonProducer: you can't specify both 'photonIDSource' and 'photonIDSources'\n";
       }
       // read the different photon ID names
       edm::ParameterSet idps = iConfig.getParameter<edm::ParameterSet>("photonIDSources");
       std::vector<std::string> names = idps.getParameterNamesForType<edm::InputTag>();
       for (std::vector<std::string>::const_iterator it = names.begin(), ed = names.end(); it != ed; ++it) {
         photIDSrcs_.push_back(NameTag(*it, idps.getParameter<edm::InputTag>(*it)));
       }
     }
     // but in any case at least once
     if (photIDSrcs_.empty())
       throw cms::Exception("Configuration") << "PATPhotonProducer: id addPhotonID is true, you must specify either:\n"
                                             << "\tInputTag photonIDSource = <someTag>\n"
                                             << "or\n"
                                             << "\tPSet photonIDSources = { \n"
                                             << "\t\tInputTag <someName> = <someTag>   // as many as you want \n "
                                             << "\t}\n";
   }
   photIDTokens_ = edm::vector_transform(
       photIDSrcs_, [this](NameTag const &tag) { return mayConsume<edm::ValueMap<Bool_t>>(tag.second); });
   // Resolution configurables
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
   if (addResolutions_) {
     resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
   }
   // Check to see if the user wants to add user data
   if (useUserData_) {
     userDataHelper_ =
         PATUserDataHelper<Photon>(iConfig.getParameter<edm::ParameterSet>("userData"), consumesCollector());
   }
   // produces vector of photons
   produces<std::vector<Photon>>();
  
   // read isoDeposit labels, for direct embedding
   readIsolationLabels(iConfig, "isoDeposits", isoDepositLabels_, isoDepositTokens_);
   // read isolation value labels, for direct embedding
   readIsolationLabels(iConfig, "isolationValues", isolationValueLabels_, isolationValueTokens_);
  
   saveRegressionData_ = iConfig.getParameter<bool>("saveRegressionData");
 }

◆ ~PATPhotonProducer()

PATPhotonProducer::~PATPhotonProducer ( )

override

Definition at line 144 of file PATPhotonProducer.cc.

144 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 480 of file PATPhotonProducer.cc.

                                                                                    {
   edm::ParameterSetDescription iDesc;
   iDesc.setComment("PAT photon producer module");
  
   // input source
   iDesc.add<edm::InputTag>("photonSource", edm::InputTag("no default"))->setComment("input collection");
   iDesc.add<edm::InputTag>("electronSource", edm::InputTag("no default"))->setComment("input collection");
   iDesc.add<edm::InputTag>("conversionSource", edm::InputTag("allConversions"))->setComment("input collection");
  
   iDesc.add<edm::InputTag>("reducedBarrelRecHitCollection", edm::InputTag("reducedEcalRecHitsEB"));
   iDesc.add<edm::InputTag>("reducedEndcapRecHitCollection", edm::InputTag("reducedEcalRecHitsEE"));
  
   iDesc.ifValue(
       edm::ParameterDescription<bool>("addPFClusterIso", false, true),
       true >> (edm::ParameterDescription<edm::InputTag>(
                    "ecalPFClusterIsoMap", edm::InputTag("photonEcalPFClusterIsolationProducer"), true) and
                edm::ParameterDescription<edm::InputTag>(
                    "hcalPFClusterIsoMap", edm::InputTag("photonHcalPFClusterIsolationProducer"), true)) or
           false >> (edm::ParameterDescription<edm::InputTag>("ecalPFClusterIsoMap", edm::InputTag(""), true) and
                     edm::ParameterDescription<edm::InputTag>("hcalPFClusterIsoMap", edm::InputTag(""), true)));
  
   iDesc.ifValue(
       edm::ParameterDescription<bool>("addPuppiIsolation", false, true),
       true >> (edm::ParameterDescription<edm::InputTag>(
                    "puppiIsolationChargedHadrons", edm::InputTag("egmPhotonPUPPIIsolation", "h+-DR030-"), true) and
                edm::ParameterDescription<edm::InputTag>(
                    "puppiIsolationNeutralHadrons", edm::InputTag("egmPhotonPUPPIIsolation", "h0-DR030-"), true) and
                edm::ParameterDescription<edm::InputTag>(
                    "puppiIsolationPhotons", edm::InputTag("egmPhotonPUPPIIsolation", "gamma-DR030-"), true)) or
           false >> edm::EmptyGroupDescription());
  
   iDesc.add<bool>("embedSuperCluster", true)->setComment("embed external super cluster");
   iDesc.add<bool>("embedSeedCluster", true)->setComment("embed external seed cluster");
   iDesc.add<bool>("embedBasicClusters", true)->setComment("embed external basic clusters");
   iDesc.add<bool>("embedPreshowerClusters", true)->setComment("embed external preshower clusters");
   iDesc.add<bool>("embedRecHits", true)->setComment("embed external RecHits");
  
   // MC matching configurables
   iDesc.add<bool>("addGenMatch", true)->setComment("add MC matching");
   iDesc.add<bool>("embedGenMatch", false)->setComment("embed MC matched MC information");
   std::vector<edm::InputTag> emptySourceVector;
   iDesc
       .addNode(edm::ParameterDescription<edm::InputTag>("genParticleMatch", edm::InputTag(), true) xor
                edm::ParameterDescription<std::vector<edm::InputTag>>("genParticleMatch", emptySourceVector, true))
       ->setComment("input with MC match information");
  
   pat::helper::KinResolutionsLoader::fillDescription(iDesc);
  
   // photon ID configurables
   iDesc.add<bool>("addPhotonID", true)->setComment("add photon ID variables");
   edm::ParameterSetDescription photonIDSourcesPSet;
   photonIDSourcesPSet.setAllowAnything();
   iDesc
       .addNode(edm::ParameterDescription<edm::InputTag>("photonIDSource", edm::InputTag(), true) xor
                edm::ParameterDescription<edm::ParameterSetDescription>("photonIDSources", photonIDSourcesPSet, true))
       ->setComment("input with photon ID variables");
  
   // IsoDeposit configurables
   edm::ParameterSetDescription isoDepositsPSet;
   isoDepositsPSet.addOptional<edm::InputTag>("tracker");
   isoDepositsPSet.addOptional<edm::InputTag>("ecal");
   isoDepositsPSet.addOptional<edm::InputTag>("hcal");
   isoDepositsPSet.addOptional<edm::InputTag>("pfAllParticles");
   isoDepositsPSet.addOptional<edm::InputTag>("pfChargedHadrons");
   isoDepositsPSet.addOptional<edm::InputTag>("pfChargedAll");
   isoDepositsPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
   isoDepositsPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
   isoDepositsPSet.addOptional<edm::InputTag>("pfPhotons");
   isoDepositsPSet.addOptional<std::vector<edm::InputTag>>("user");
   iDesc.addOptional("isoDeposits", isoDepositsPSet);
  
   // isolation values configurables
   edm::ParameterSetDescription isolationValuesPSet;
   isolationValuesPSet.addOptional<edm::InputTag>("tracker");
   isolationValuesPSet.addOptional<edm::InputTag>("ecal");
   isolationValuesPSet.addOptional<edm::InputTag>("hcal");
   isolationValuesPSet.addOptional<edm::InputTag>("pfAllParticles");
   isolationValuesPSet.addOptional<edm::InputTag>("pfChargedHadrons");
   isolationValuesPSet.addOptional<edm::InputTag>("pfChargedAll");
   isolationValuesPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
   isolationValuesPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
   isolationValuesPSet.addOptional<edm::InputTag>("pfPhotons");
   isolationValuesPSet.addOptional<std::vector<edm::InputTag>>("user");
   iDesc.addOptional("isolationValues", isolationValuesPSet);
  
   // Efficiency configurables
   edm::ParameterSetDescription efficienciesPSet;
   efficienciesPSet.setAllowAnything();  // TODO: the pat helper needs to implement a description.
   iDesc.add("efficiencies", efficienciesPSet);
   iDesc.add<bool>("addEfficiencies", false);
  
   // Check to see if the user wants to add user data
   edm::ParameterSetDescription userDataPSet;
   PATUserDataHelper<Photon>::fillDescription(userDataPSet);
   iDesc.addOptional("userData", userDataPSet);
  
   edm::ParameterSetDescription isolationPSet;
   isolationPSet.setAllowAnything();  // TODO: the pat helper needs to implement a description.
   iDesc.add("userIsolation", isolationPSet);
  
   iDesc.addNode(edm::ParameterDescription<edm::InputTag>("beamLineSrc", edm::InputTag(), true))
       ->setComment("input with high level selection");
  
   iDesc.add<bool>("saveRegressionData", true)->setComment("save regression input variables");
  
   descriptions.add("PATPhotonProducer", iDesc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addOptional(), pat::helper::KinResolutionsLoader::fillDescription(), pat::PATUserDataHelper< ObjectType >::fillDescription(), edm::ParameterSetDescription::ifValue(), HLT_FULL_cff::InputTag, or, edm::ParameterSetDescription::setAllowAnything(), edm::ParameterSetDescription::setComment(), and edm::ParameterDescriptionNode::setComment().

◆ produce()

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

override

Definition at line 146 of file PATPhotonProducer.cc.

                                                                              {
   // switch off embedding (in unschedules mode)
   if (iEvent.isRealData()) {
     addGenMatch_ = false;
     embedGenMatch_ = false;
   }
  
   edm::ESHandle<CaloTopology> theCaloTopology;
   iSetup.get<CaloTopologyRecord>().get(theCaloTopology);
   ecalTopology_ = &(*theCaloTopology);
  
   edm::ESHandle<CaloGeometry> theCaloGeometry;
   iSetup.get<CaloGeometryRecord>().get(theCaloGeometry);
   ecalGeometry_ = &(*theCaloGeometry);
  
   // Get the vector of Photon's from the event
   edm::Handle<edm::View<reco::Photon>> photons;
   iEvent.getByToken(photonToken_, photons);
  
   // for conversion veto selection
   edm::Handle<reco::ConversionCollection> hConversions;
   iEvent.getByToken(hConversionsToken_, hConversions);
  
   // Get the collection of electrons from the event
   edm::Handle<reco::GsfElectronCollection> hElectrons;
   iEvent.getByToken(electronToken_, hElectrons);
  
   // Get the beamspot
   edm::Handle<reco::BeamSpot> beamSpotHandle;
   iEvent.getByToken(beamLineToken_, beamSpotHandle);
  
   EcalClusterLazyTools lazyTools(iEvent,
                                  ecalClusterToolsESGetTokens_.get(iSetup),
                                  reducedBarrelRecHitCollectionToken_,
                                  reducedEndcapRecHitCollectionToken_);
  
   // prepare the MC matching
   std::vector<edm::Handle<edm::Association<reco::GenParticleCollection>>> genMatches(genMatchTokens_.size());
   if (addGenMatch_) {
     for (size_t j = 0, nd = genMatchTokens_.size(); j < nd; ++j) {
       iEvent.getByToken(genMatchTokens_[j], genMatches[j]);
     }
   }
  
   if (isolator_.enabled())
     isolator_.beginEvent(iEvent, iSetup);
  
   if (efficiencyLoader_.enabled())
     efficiencyLoader_.newEvent(iEvent);
   if (resolutionLoader_.enabled())
     resolutionLoader_.newEvent(iEvent, iSetup);
  
   IsoDepositMaps deposits(isoDepositTokens_.size());
   for (size_t j = 0, nd = isoDepositTokens_.size(); j < nd; ++j) {
     iEvent.getByToken(isoDepositTokens_[j], deposits[j]);
   }
  
   IsolationValueMaps isolationValues(isolationValueTokens_.size());
   for (size_t j = 0; j < isolationValueTokens_.size(); ++j) {
     iEvent.getByToken(isolationValueTokens_[j], isolationValues[j]);
   }
  
   // prepare ID extraction
   std::vector<edm::Handle<edm::ValueMap<Bool_t>>> idhandles;
   std::vector<pat::Photon::IdPair> ids;
   if (addPhotonID_) {
     idhandles.resize(photIDSrcs_.size());
     ids.resize(photIDSrcs_.size());
     for (size_t i = 0; i < photIDSrcs_.size(); ++i) {
       iEvent.getByToken(photIDTokens_[i], idhandles[i]);
       ids[i].first = photIDSrcs_[i].first;
     }
   }
  
   //value maps for puppi isolation
   edm::Handle<edm::ValueMap<float>> PUPPIIsolation_charged_hadrons;
   edm::Handle<edm::ValueMap<float>> PUPPIIsolation_neutral_hadrons;
   edm::Handle<edm::ValueMap<float>> PUPPIIsolation_photons;
   if (addPuppiIsolation_) {
     iEvent.getByToken(PUPPIIsolation_charged_hadrons_, PUPPIIsolation_charged_hadrons);
     iEvent.getByToken(PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_neutral_hadrons);
     iEvent.getByToken(PUPPIIsolation_photons_, PUPPIIsolation_photons);
   }
  
   // loop over photons
   std::vector<Photon> *PATPhotons = new std::vector<Photon>();
   for (edm::View<reco::Photon>::const_iterator itPhoton = photons->begin(); itPhoton != photons->end(); itPhoton++) {
     // construct the Photon from the ref -> save ref to original object
     unsigned int idx = itPhoton - photons->begin();
     edm::RefToBase<reco::Photon> photonRef = photons->refAt(idx);
     edm::Ptr<reco::Photon> photonPtr = photons->ptrAt(idx);
     Photon aPhoton(photonRef);
     auto phoPtr = photons->ptrAt(idx);
     if (embedSuperCluster_)
       aPhoton.embedSuperCluster();
     if (embedSeedCluster_)
       aPhoton.embedSeedCluster();
     if (embedBasicClusters_)
       aPhoton.embedBasicClusters();
     if (embedPreshowerClusters_)
       aPhoton.embedPreshowerClusters();
  
     std::vector<DetId> selectedCells;
     bool barrel = itPhoton->isEB();
     //loop over sub clusters
     if (embedBasicClusters_) {
       for (reco::CaloCluster_iterator clusIt = itPhoton->superCluster()->clustersBegin();
            clusIt != itPhoton->superCluster()->clustersEnd();
            ++clusIt) {
         //get seed (max energy xtal)
         DetId seed = lazyTools.getMaximum(**clusIt).first;
         //get all xtals in 5x5 window around the seed
         std::vector<DetId> dets5x5 =
             (barrel) ? ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalBarrel)->getWindow(seed, 5, 5)
                      : ecalTopology_->getSubdetectorTopology(DetId::Ecal, EcalEndcap)->getWindow(seed, 5, 5);
         selectedCells.insert(selectedCells.end(), dets5x5.begin(), dets5x5.end());
  
         //get all xtals belonging to cluster
         for (const std::pair<DetId, float> &hit : (*clusIt)->hitsAndFractions()) {
           selectedCells.push_back(hit.first);
         }
       }
     }
  
     //remove duplicates
     std::sort(selectedCells.begin(), selectedCells.end());
     std::unique(selectedCells.begin(), selectedCells.end());
  
     // Retrieve the corresponding RecHits
  
     edm::Handle<EcalRecHitCollection> recHitsEBHandle;
     iEvent.getByToken(reducedBarrelRecHitCollectionToken_, recHitsEBHandle);
     edm::Handle<EcalRecHitCollection> recHitsEEHandle;
     iEvent.getByToken(reducedEndcapRecHitCollectionToken_, recHitsEEHandle);
  
     //orginal code would throw an exception via the handle not being valid but now it'll just have a null pointer error
     //should have little effect, if its not barrel or endcap, something very bad has happened elsewhere anyways
     const EcalRecHitCollection *recHits = nullptr;
     if (photonRef->superCluster()->seed()->hitsAndFractions().at(0).first.subdetId() == EcalBarrel)
       recHits = recHitsEBHandle.product();
     else if (photonRef->superCluster()->seed()->hitsAndFractions().at(0).first.subdetId() == EcalEndcap)
       recHits = recHitsEEHandle.product();
  
     EcalRecHitCollection selectedRecHits;
  
     unsigned nSelectedCells = selectedCells.size();
     for (unsigned icell = 0; icell < nSelectedCells; ++icell) {
       EcalRecHitCollection::const_iterator it = recHits->find(selectedCells[icell]);
       if (it != recHits->end()) {
         selectedRecHits.push_back(*it);
       }
     }
     selectedRecHits.sort();
     if (embedRecHits_)
       aPhoton.embedRecHits(&selectedRecHits);
  
     // store the match to the generated final state muons
     if (addGenMatch_) {
       for (size_t i = 0, n = genMatches.size(); i < n; ++i) {
         reco::GenParticleRef genPhoton = (*genMatches[i])[photonRef];
         aPhoton.addGenParticleRef(genPhoton);
       }
       if (embedGenMatch_)
         aPhoton.embedGenParticle();
     }
  
     if (efficiencyLoader_.enabled()) {
       efficiencyLoader_.setEfficiencies(aPhoton, photonRef);
     }
  
     if (resolutionLoader_.enabled()) {
       resolutionLoader_.setResolutions(aPhoton);
     }
  
     // here comes the extra functionality
     if (isolator_.enabled()) {
       isolator_.fill(*photons, idx, isolatorTmpStorage_);
       typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
       // better to loop backwards, so the vector is resized less times
       for (IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(),
                                                        ed = isolatorTmpStorage_.rend();
            it != ed;
            ++it) {
         aPhoton.setIsolation(it->first, it->second);
       }
     }
  
     for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
       aPhoton.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[photonRef]);
     }
  
     for (size_t j = 0; j < isolationValues.size(); ++j) {
       aPhoton.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[photonRef]);
     }
  
     // add photon ID info
     if (addPhotonID_) {
       for (size_t i = 0; i < photIDSrcs_.size(); ++i) {
         ids[i].second = (*idhandles[i])[photonRef];
       }
       aPhoton.setPhotonIDs(ids);
     }
  
     if (useUserData_) {
       userDataHelper_.add(aPhoton, iEvent, iSetup);
     }
  
     // set conversion veto selection
     bool passelectronveto = false;
     if (hConversions.isValid()) {
       // this is recommended method
       passelectronveto = !ConversionTools::hasMatchedPromptElectron(
           photonRef->superCluster(), *hElectrons, *hConversions, beamSpotHandle->position());
     }
     aPhoton.setPassElectronVeto(passelectronveto);
  
     // set electron veto using pixel seed (not recommended but many analysis groups are still using since it is powerful method to remove electrons)
     aPhoton.setHasPixelSeed(photonRef->hasPixelSeed());
  
     // set seed energy
     aPhoton.setSeedEnergy(photonRef->superCluster()->seed()->energy());
  
     // set input variables for regression energy correction
     if (saveRegressionData_) {
       EcalRegressionData ecalRegData;
       ecalRegData.fill(*(photonRef->superCluster()),
                        recHitsEBHandle.product(),
                        recHitsEEHandle.product(),
                        ecalGeometry_,
                        ecalTopology_,
                        -1);
  
       aPhoton.setEMax(ecalRegData.eMax());
       aPhoton.setE2nd(ecalRegData.e2nd());
       aPhoton.setE3x3(ecalRegData.e3x3());
       aPhoton.setETop(ecalRegData.eTop());
       aPhoton.setEBottom(ecalRegData.eBottom());
       aPhoton.setELeft(ecalRegData.eLeft());
       aPhoton.setERight(ecalRegData.eRight());
       aPhoton.setSee(ecalRegData.sigmaIEtaIEta());
       aPhoton.setSep(
           ecalRegData.sigmaIEtaIPhi() * ecalRegData.sigmaIEtaIEta() *
           ecalRegData
               .sigmaIPhiIPhi());  //there is a conflict on what sigmaIEtaIPhi actually is, regression and ID have it differently, this may change in later releases
       aPhoton.setSpp(ecalRegData.sigmaIPhiIPhi());
  
       aPhoton.setMaxDR(ecalRegData.maxSubClusDR());
       aPhoton.setMaxDRDPhi(ecalRegData.maxSubClusDRDPhi());
       aPhoton.setMaxDRDEta(ecalRegData.maxSubClusDRDEta());
       aPhoton.setMaxDRRawEnergy(ecalRegData.maxSubClusDRRawEnergy());
       aPhoton.setSubClusRawE1(ecalRegData.subClusRawEnergy(EcalRegressionData::SubClusNr::C1));
       aPhoton.setSubClusRawE2(ecalRegData.subClusRawEnergy(EcalRegressionData::SubClusNr::C2));
       aPhoton.setSubClusRawE3(ecalRegData.subClusRawEnergy(EcalRegressionData::SubClusNr::C3));
       aPhoton.setSubClusDPhi1(ecalRegData.subClusDPhi(EcalRegressionData::SubClusNr::C1));
       aPhoton.setSubClusDPhi2(ecalRegData.subClusDPhi(EcalRegressionData::SubClusNr::C2));
       aPhoton.setSubClusDPhi3(ecalRegData.subClusDPhi(EcalRegressionData::SubClusNr::C3));
       aPhoton.setSubClusDEta1(ecalRegData.subClusDEta(EcalRegressionData::SubClusNr::C1));
       aPhoton.setSubClusDEta2(ecalRegData.subClusDEta(EcalRegressionData::SubClusNr::C2));
       aPhoton.setSubClusDEta3(ecalRegData.subClusDEta(EcalRegressionData::SubClusNr::C3));
  
       aPhoton.setCryPhi(ecalRegData.seedCrysPhiOrY());
       aPhoton.setCryEta(ecalRegData.seedCrysEtaOrX());
       aPhoton.setIEta(ecalRegData.seedCrysIEtaOrIX());
       aPhoton.setIPhi(ecalRegData.seedCrysIPhiOrIY());
     } else {
       aPhoton.setEMax(0);
       aPhoton.setE2nd(0);
       aPhoton.setE3x3(0);
       aPhoton.setETop(0);
       aPhoton.setEBottom(0);
       aPhoton.setELeft(0);
       aPhoton.setERight(0);
       aPhoton.setSee(0);
       aPhoton.setSep(0);
       aPhoton.setSpp(0);
  
       aPhoton.setMaxDR(0);
       aPhoton.setMaxDRDPhi(0);
       aPhoton.setMaxDRDEta(0);
       aPhoton.setMaxDRRawEnergy(0);
       aPhoton.setSubClusRawE1(0);
       aPhoton.setSubClusRawE2(0);
       aPhoton.setSubClusRawE3(0);
       aPhoton.setSubClusDPhi1(0);
       aPhoton.setSubClusDPhi2(0);
       aPhoton.setSubClusDPhi3(0);
       aPhoton.setSubClusDEta1(0);
       aPhoton.setSubClusDEta2(0);
       aPhoton.setSubClusDEta3(0);
  
       aPhoton.setCryPhi(0);
       aPhoton.setCryEta(0);
       aPhoton.setIEta(0);
       aPhoton.setIPhi(0);
     }
  
     if (addPuppiIsolation_)
       aPhoton.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[phoPtr],
                                 (*PUPPIIsolation_neutral_hadrons)[phoPtr],
                                 (*PUPPIIsolation_photons)[phoPtr]);
     else
       aPhoton.setIsolationPUPPI(-999., -999., -999.);
  
     // Get PFCluster Isolation
     if (addPFClusterIso_) {
       reco::Photon::PflowIsolationVariables newPFIsol = aPhoton.getPflowIsolationVariables();
       edm::Handle<edm::ValueMap<float>> ecalPFClusterIsoMapH;
       iEvent.getByToken(ecalPFClusterIsoT_, ecalPFClusterIsoMapH);
       newPFIsol.sumEcalClusterEt = (*ecalPFClusterIsoMapH)[photonRef];
       edm::Handle<edm::ValueMap<float>> hcalPFClusterIsoMapH;
       if (not hcalPFClusterIsoT_.isUninitialized()) {
         iEvent.getByToken(hcalPFClusterIsoT_, hcalPFClusterIsoMapH);
         newPFIsol.sumHcalClusterEt = (*hcalPFClusterIsoMapH)[photonRef];
       } else {
         newPFIsol.sumHcalClusterEt = -999.;
       }
       aPhoton.setPflowIsolationVariables(newPFIsol);
     }
  
     // add the Photon to the vector of Photons
     PATPhotons->push_back(aPhoton);
   }
  
   // sort Photons in ET
   std::sort(PATPhotons->begin(), PATPhotons->end(), eTComparator_);
  
   // put genEvt object in Event
   std::unique_ptr<std::vector<Photon>> myPhotons(PATPhotons);
   iEvent.put(std::move(myPhotons));
   if (isolator_.enabled())
     isolator_.endEvent();
 }

◆ readIsolationLabels()

template<typename T >

void pat::PATPhotonProducer::readIsolationLabels	(	const edm::ParameterSet &	iConfig,
		const char *	psetName,
		IsolationLabels &	labels,
		std::vector< edm::EDGetTokenT< edm::ValueMap< T > > > &	tokens
	)

private

fill the labels vector from the contents of the parameter set, for the isodeposit or isolation values embedding

Definition at line 141 of file PATPhotonProducer.h.

                                                                                                       {
   labels.clear();
  
   if (iConfig.exists(psetName)) {
     edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>(psetName);
  
     if (depconf.exists("tracker"))
       labels.push_back(std::make_pair(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker")));
     if (depconf.exists("ecal"))
       labels.push_back(std::make_pair(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal")));
     if (depconf.exists("hcal"))
       labels.push_back(std::make_pair(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal")));
     if (depconf.exists("pfAllParticles")) {
       labels.push_back(std::make_pair(pat::PfAllParticleIso, depconf.getParameter<edm::InputTag>("pfAllParticles")));
     }
     if (depconf.exists("pfChargedHadrons")) {
       labels.push_back(
           std::make_pair(pat::PfChargedHadronIso, depconf.getParameter<edm::InputTag>("pfChargedHadrons")));
     }
     if (depconf.exists("pfChargedAll")) {
       labels.push_back(std::make_pair(pat::PfChargedAllIso, depconf.getParameter<edm::InputTag>("pfChargedAll")));
     }
     if (depconf.exists("pfPUChargedHadrons")) {
       labels.push_back(
           std::make_pair(pat::PfPUChargedHadronIso, depconf.getParameter<edm::InputTag>("pfPUChargedHadrons")));
     }
     if (depconf.exists("pfNeutralHadrons")) {
       labels.push_back(
           std::make_pair(pat::PfNeutralHadronIso, depconf.getParameter<edm::InputTag>("pfNeutralHadrons")));
     }
     if (depconf.exists("pfPhotons")) {
       labels.push_back(std::make_pair(pat::PfGammaIso, depconf.getParameter<edm::InputTag>("pfPhotons")));
     }
     if (depconf.exists("user")) {
       std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag> >("user");
       std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
       int key = pat::IsolationKeys::UserBaseIso;
       for (; it != ed; ++it, ++key) {
         labels.push_back(std::make_pair(pat::IsolationKeys(key), *it));
       }
     }
  
     tokens = edm::vector_transform(
         labels, [this](IsolationLabel const& label) { return consumes<edm::ValueMap<T> >(label.second); });
   }
   tokens = edm::vector_transform(
       labels, [this](IsolationLabel const& label) { return consumes<edm::ValueMap<T> >(label.second); });
 }

References pat::EcalIso, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), pat::HcalIso, crabWrapper::key, label, SummaryClient_cfi::labels, pat::PfAllParticleIso, pat::PfChargedAllIso, pat::PfChargedHadronIso, pat::PfGammaIso, pat::PfNeutralHadronIso, pat::PfPUChargedHadronIso, pat::TrackIso, pat::UserBaseIso, and edm::vector_transform().

Member Data Documentation

◆ addEfficiencies_

bool pat::PATPhotonProducer::addEfficiencies_

private

Definition at line 114 of file PATPhotonProducer.h.

◆ addGenMatch_

bool pat::PATPhotonProducer::addGenMatch_

private

Definition at line 86 of file PATPhotonProducer.h.

Referenced by produce().

◆ addPFClusterIso_

bool pat::PATPhotonProducer::addPFClusterIso_

private

Definition at line 81 of file PATPhotonProducer.h.

Referenced by produce().

◆ addPhotonID_

bool pat::PATPhotonProducer::addPhotonID_

private

Definition at line 120 of file PATPhotonProducer.h.

Referenced by produce().

◆ addPuppiIsolation_

bool pat::PATPhotonProducer::addPuppiIsolation_

private

Definition at line 82 of file PATPhotonProducer.h.

Referenced by produce().

◆ addResolutions_

bool pat::PATPhotonProducer::addResolutions_

private

Definition at line 117 of file PATPhotonProducer.h.

◆ beamLineToken_

edm::EDGetTokenT<reco::BeamSpot> pat::PATPhotonProducer::beamLineToken_

private

Definition at line 66 of file PATPhotonProducer.h.

Referenced by produce().

◆ ecalClusterToolsESGetTokens_

const EcalClusterLazyTools::ESGetTokens pat::PATPhotonProducer::ecalClusterToolsESGetTokens_

private

Definition at line 79 of file PATPhotonProducer.h.

Referenced by produce().

◆ ecalGeometry_

const CaloGeometry* pat::PATPhotonProducer::ecalGeometry_

private

Definition at line 133 of file PATPhotonProducer.h.

Referenced by produce().

◆ ecalPFClusterIsoT_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATPhotonProducer::ecalPFClusterIsoT_

private

Definition at line 83 of file PATPhotonProducer.h.

Referenced by produce().

◆ ecalTopology_

const CaloTopology* pat::PATPhotonProducer::ecalTopology_

private

Definition at line 132 of file PATPhotonProducer.h.

Referenced by produce().

◆ efficiencyLoader_

pat::helper::EfficiencyLoader pat::PATPhotonProducer::efficiencyLoader_

private

Definition at line 115 of file PATPhotonProducer.h.

Referenced by produce().

◆ electronToken_

edm::EDGetTokenT<reco::GsfElectronCollection> pat::PATPhotonProducer::electronToken_

private

Definition at line 64 of file PATPhotonProducer.h.

Referenced by produce().

◆ embedBasicClusters_

bool pat::PATPhotonProducer::embedBasicClusters_

private

Definition at line 70 of file PATPhotonProducer.h.

Referenced by produce().

◆ embedGenMatch_

bool pat::PATPhotonProducer::embedGenMatch_

private

Definition at line 87 of file PATPhotonProducer.h.

Referenced by produce().

◆ embedPreshowerClusters_

bool pat::PATPhotonProducer::embedPreshowerClusters_

private

Definition at line 71 of file PATPhotonProducer.h.

Referenced by produce().

◆ embedRecHits_

bool pat::PATPhotonProducer::embedRecHits_

private

Definition at line 72 of file PATPhotonProducer.h.

Referenced by produce().

◆ embedSeedCluster_

bool pat::PATPhotonProducer::embedSeedCluster_

private

Definition at line 69 of file PATPhotonProducer.h.

Referenced by produce().

◆ embedSuperCluster_

bool pat::PATPhotonProducer::embedSuperCluster_

private

Definition at line 68 of file PATPhotonProducer.h.

Referenced by produce().

◆ eTComparator_

GreaterByEt<Photon> pat::PATPhotonProducer::eTComparator_

private

Definition at line 91 of file PATPhotonProducer.h.

Referenced by produce().

◆ genMatchTokens_

std::vector<edm::EDGetTokenT<edm::Association<reco::GenParticleCollection> > > pat::PATPhotonProducer::genMatchTokens_

private

Definition at line 88 of file PATPhotonProducer.h.

Referenced by produce().

◆ hcalPFClusterIsoT_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATPhotonProducer::hcalPFClusterIsoT_

private

Definition at line 84 of file PATPhotonProducer.h.

Referenced by produce().

◆ hConversionsToken_

edm::EDGetTokenT<reco::ConversionCollection> pat::PATPhotonProducer::hConversionsToken_

private

Definition at line 65 of file PATPhotonProducer.h.

Referenced by produce().

◆ isoDepositLabels_

IsolationLabels pat::PATPhotonProducer::isoDepositLabels_

private

Definition at line 103 of file PATPhotonProducer.h.

Referenced by produce().

◆ isoDepositTokens_

std::vector<edm::EDGetTokenT<edm::ValueMap<IsoDeposit> > > pat::PATPhotonProducer::isoDepositTokens_

private

Definition at line 100 of file PATPhotonProducer.h.

Referenced by produce().

◆ isolationValueLabels_

IsolationLabels pat::PATPhotonProducer::isolationValueLabels_

private

Definition at line 104 of file PATPhotonProducer.h.

Referenced by produce().

◆ isolationValueTokens_

std::vector<edm::EDGetTokenT<edm::ValueMap<double> > > pat::PATPhotonProducer::isolationValueTokens_

private

Definition at line 101 of file PATPhotonProducer.h.

Referenced by produce().

◆ isolator_

pat::helper::MultiIsolator pat::PATPhotonProducer::isolator_

private

Definition at line 98 of file PATPhotonProducer.h.

Referenced by produce().

◆ isolatorTmpStorage_

pat::helper::MultiIsolator::IsolationValuePairs pat::PATPhotonProducer::isolatorTmpStorage_

private

Definition at line 99 of file PATPhotonProducer.h.

Referenced by produce().

◆ photIDSrcs_

std::vector<NameTag> pat::PATPhotonProducer::photIDSrcs_

private

Definition at line 122 of file PATPhotonProducer.h.

Referenced by produce().

◆ photIDTokens_

std::vector<edm::EDGetTokenT<edm::ValueMap<Bool_t> > > pat::PATPhotonProducer::photIDTokens_

private

Definition at line 123 of file PATPhotonProducer.h.

Referenced by produce().

◆ photonToken_

edm::EDGetTokenT<edm::View<reco::Photon> > pat::PATPhotonProducer::photonToken_

private

Definition at line 63 of file PATPhotonProducer.h.

Referenced by produce().

◆ PUPPIIsolation_charged_hadrons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATPhotonProducer::PUPPIIsolation_charged_hadrons_

private

Definition at line 127 of file PATPhotonProducer.h.

Referenced by produce().

◆ PUPPIIsolation_neutral_hadrons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATPhotonProducer::PUPPIIsolation_neutral_hadrons_

private

Definition at line 128 of file PATPhotonProducer.h.

Referenced by produce().

◆ PUPPIIsolation_photons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATPhotonProducer::PUPPIIsolation_photons_

private

Definition at line 129 of file PATPhotonProducer.h.

Referenced by produce().

◆ reducedBarrelRecHitCollection_

edm::InputTag pat::PATPhotonProducer::reducedBarrelRecHitCollection_

private

Definition at line 74 of file PATPhotonProducer.h.

◆ reducedBarrelRecHitCollectionToken_

edm::EDGetTokenT<EcalRecHitCollection> pat::PATPhotonProducer::reducedBarrelRecHitCollectionToken_

private

Definition at line 75 of file PATPhotonProducer.h.

Referenced by produce().

◆ reducedEndcapRecHitCollection_

edm::InputTag pat::PATPhotonProducer::reducedEndcapRecHitCollection_

private

Definition at line 76 of file PATPhotonProducer.h.

◆ reducedEndcapRecHitCollectionToken_

edm::EDGetTokenT<EcalRecHitCollection> pat::PATPhotonProducer::reducedEndcapRecHitCollectionToken_

private

Definition at line 77 of file PATPhotonProducer.h.

Referenced by produce().

◆ resolutionLoader_

pat::helper::KinResolutionsLoader pat::PATPhotonProducer::resolutionLoader_

private

Definition at line 118 of file PATPhotonProducer.h.

Referenced by produce().

◆ saveRegressionData_

bool pat::PATPhotonProducer::saveRegressionData_

private

Definition at line 135 of file PATPhotonProducer.h.

Referenced by produce().

◆ userDataHelper_

pat::PATUserDataHelper<pat::Photon> pat::PATPhotonProducer::userDataHelper_

private

Definition at line 130 of file PATPhotonProducer.h.

Referenced by produce().

◆ useUserData_

bool pat::PATPhotonProducer::useUserData_

private

Definition at line 125 of file PATPhotonProducer.h.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ IsoDepositMaps

◆ IsolationLabel

◆ IsolationLabels

◆ IsolationValueMaps

◆ NameTag

Constructor & Destructor Documentation

◆ PATPhotonProducer()

◆ ~PATPhotonProducer()

Member Function Documentation

◆ fillDescriptions()

◆ produce()

◆ readIsolationLabels()

Member Data Documentation

◆ addEfficiencies_

◆ addGenMatch_

◆ addPFClusterIso_

◆ addPhotonID_

◆ addPuppiIsolation_

◆ addResolutions_

◆ beamLineToken_

◆ ecalClusterToolsESGetTokens_

◆ ecalGeometry_

◆ ecalPFClusterIsoT_

◆ ecalTopology_

◆ efficiencyLoader_

◆ electronToken_

◆ embedBasicClusters_

◆ embedGenMatch_

◆ embedPreshowerClusters_

◆ embedRecHits_

◆ embedSeedCluster_

◆ embedSuperCluster_

◆ eTComparator_

◆ genMatchTokens_

◆ hcalPFClusterIsoT_

◆ hConversionsToken_

◆ isoDepositLabels_

◆ isoDepositTokens_

◆ isolationValueLabels_

◆ isolationValueTokens_

◆ isolator_

◆ isolatorTmpStorage_

◆ photIDSrcs_

◆ photIDTokens_

◆ photonToken_

◆ PUPPIIsolation_charged_hadrons_

◆ PUPPIIsolation_neutral_hadrons_

◆ PUPPIIsolation_photons_

◆ reducedBarrelRecHitCollection_

◆ reducedBarrelRecHitCollectionToken_

◆ reducedEndcapRecHitCollection_

◆ reducedEndcapRecHitCollectionToken_

◆ resolutionLoader_

◆ saveRegressionData_

◆ userDataHelper_

◆ useUserData_