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

Inheritance diagram for pat::PATPhotonProducer:

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

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

	~PATPhotonProducer ()

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
	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 (const std::string &iProcessName, std::vector< const char * > &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 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	addResolutions_

edm::EDGetTokenT< reco::BeamSpot >	beamLineToken_

const CaloGeometry *	ecalGeometry_

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

const CaloTopology *	ecalTopology_

EcalClusterLocal	ecl_

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::InputTag	reducedBarrelRecHitCollection_

edm::EDGetTokenT < EcalRecHitCollection >	reducedBarrelRecHitCollectionToken_

edm::InputTag	reducedEndcapRecHitCollection_

edm::EDGetTokenT < EcalRecHitCollection >	reducedEndcapRecHitCollectionToken_

pat::helper::KinResolutionsLoader	resolutionLoader_

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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

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

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

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 53 of file PATPhotonProducer.h.

Member Typedef Documentation

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

private

Definition at line 94 of file PATPhotonProducer.h.

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

private

Definition at line 96 of file PATPhotonProducer.h.

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

private

Definition at line 97 of file PATPhotonProducer.h.

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

private

Definition at line 95 of file PATPhotonProducer.h.

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

private

Definition at line 121 of file PATPhotonProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 31 of file PATPhotonProducer.cc.

References addGenMatch_, beamLineToken_, edm::EDConsumerBase::consumes(), electronToken_, embedBasicClusters_, embedGenMatch_, embedPreshowerClusters_, embedRecHits_, embedSeedCluster_, embedSuperCluster_, edm::ParameterSet::existsAs(), genMatchTokens_, edm::ParameterSet::getParameter(), hConversionsToken_, photonToken_, reducedBarrelRecHitCollection_, reducedBarrelRecHitCollectionToken_, reducedEndcapRecHitCollection_, reducedEndcapRecHitCollectionToken_, GlobalPosition_Frontier_DevDB_cff::tag, and edm::vector_transform().

                                                                     :
   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
   addPFClusterIso_   = iConfig.getParameter<bool>("addPFClusterIso");
   ecalPFClusterIsoT_ = consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("ecalPFClusterIsoMap"));
   hcalPFClusterIsoT_ = consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("hcalPFClusterIsoMap"));
   // 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_);
 
 }

PATPhotonProducer::~PATPhotonProducer ( )

Definition at line 117 of file PATPhotonProducer.cc.

117 {

118 }

Member Function Documentation

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

static

Definition at line 383 of file PATPhotonProducer.cc.

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_25ns14e33_v1_cff::InputTag, or, edm::ParameterSetDescription::setAllowAnything(), edm::ParameterSetDescription::setComment(), and edm::ParameterDescriptionNode::setComment().

 {
   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.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");
 
   descriptions.add("PATPhotonProducer", iDesc);
 
 }

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

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 120 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, 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;
     }
   }
 
   // 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);
     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() );
 
     EcalRegressionData ecalRegData;
     ecalRegData.fill(*(photonRef->superCluster()),
              recHitsEBHandle.product(),recHitsEEHandle.product(),
              ecalGeometry_,ecalTopology_,-1);
     
 
     // set input variables for regression energy correction
     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() );
 
     // Get PFCluster Isolation
     if (addPFClusterIso_) {
       edm::Handle<edm::ValueMap<float> > ecalPFClusterIsoMapH;
       iEvent.getByToken(ecalPFClusterIsoT_, ecalPFClusterIsoMapH);
       edm::Handle<edm::ValueMap<float> > hcalPFClusterIsoMapH;
       iEvent.getByToken(hcalPFClusterIsoT_, hcalPFClusterIsoMapH);
       aPhoton.setEcalPFClusterIso((*ecalPFClusterIsoMapH)[photonRef]);
       aPhoton.setHcalPFClusterIso((*hcalPFClusterIsoMapH)[photonRef]);
     } else {
       aPhoton.setEcalPFClusterIso(-999.);
       aPhoton.setHcalPFClusterIso(-999.);
     }
 
     // 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::auto_ptr<std::vector<Photon> > myPhotons(PATPhotons);
   iEvent.put(myPhotons);
   if (isolator_.enabled()) isolator_.endEvent();
 
 }

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 136 of file PATPhotonProducer.h.

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

                                                                                                      {
     
     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 = UserBaseIso;
         for ( ; it != ed; ++it, ++key) {
           labels.push_back(std::make_pair(IsolationKeys(key), *it));
         }
       }
     }
     
     tokens = edm::vector_transform(labels, [this](IsolationLabel const & label){return consumes<edm::ValueMap<T> >(label.second);});
     
   }

Member Data Documentation

bool pat::PATPhotonProducer::addEfficiencies_

private

Definition at line 114 of file PATPhotonProducer.h.

bool pat::PATPhotonProducer::addGenMatch_

private

Definition at line 87 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::addPFClusterIso_

private

Definition at line 83 of file PATPhotonProducer.h.

Referenced by produce().

bool pat::PATPhotonProducer::addPhotonID_

private

Definition at line 120 of file PATPhotonProducer.h.

Referenced by produce().

bool pat::PATPhotonProducer::addResolutions_

private

Definition at line 117 of file PATPhotonProducer.h.

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

private

Definition at line 70 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

const CaloGeometry* pat::PATPhotonProducer::ecalGeometry_

private

Definition at line 129 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 84 of file PATPhotonProducer.h.

Referenced by produce().

const CaloTopology* pat::PATPhotonProducer::ecalTopology_

private

Definition at line 128 of file PATPhotonProducer.h.

Referenced by produce().

EcalClusterLocal pat::PATPhotonProducer::ecl_

private

Definition at line 130 of file PATPhotonProducer.h.

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

private

Definition at line 115 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 68 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedBasicClusters_

private

Definition at line 74 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedGenMatch_

private

Definition at line 88 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedPreshowerClusters_

private

Definition at line 75 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedRecHits_

private

Definition at line 76 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedSeedCluster_

private

Definition at line 73 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedSuperCluster_

private

Definition at line 72 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

GreaterByEt<Photon> pat::PATPhotonProducer::eTComparator_

private

Definition at line 92 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 89 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

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

private

Definition at line 85 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 69 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

IsolationLabels pat::PATPhotonProducer::isoDepositLabels_

private

Definition at line 104 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 101 of file PATPhotonProducer.h.

Referenced by produce().

IsolationLabels pat::PATPhotonProducer::isolationValueLabels_

private

Definition at line 105 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 102 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 99 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 100 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 122 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 123 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 67 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

edm::InputTag pat::PATPhotonProducer::reducedBarrelRecHitCollection_

private

Definition at line 78 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer().

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

private

Definition at line 79 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

edm::InputTag pat::PATPhotonProducer::reducedEndcapRecHitCollection_

private

Definition at line 80 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer().

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

private

Definition at line 81 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

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

private

Definition at line 118 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 126 of file PATPhotonProducer.h.

Referenced by produce().

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

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation