#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::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

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

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

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

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

Static Public Member Functions inherited from edm::EDProducer
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	addPhotonID_

bool	addResolutions_

edm::EDGetTokenT< reco::BeamSpot >	beamLineToken_

const CaloGeometry *	ecalGeometry_

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 < 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::EDProducer
typedef EDProducer	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 54 of file PATPhotonProducer.h.

Member Typedef Documentation

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

private

Definition at line 92 of file PATPhotonProducer.h.

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

private

Definition at line 94 of file PATPhotonProducer.h.

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

private

Definition at line 95 of file PATPhotonProducer.h.

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

private

Definition at line 93 of file PATPhotonProducer.h.

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

private

Definition at line 119 of file PATPhotonProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 29 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>(edm::InputTag("gedGsfElectrons"));
   hConversionsToken_ = consumes<reco::ConversionCollection>(edm::InputTag("allConversions"));
   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());
   }
   // 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 111 of file PATPhotonProducer.cc.

111 {

112 }

Member Function Documentation

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

static

Definition at line 401 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::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>("reducedBarrelRecHitCollection", edm::InputTag("reducedEcalRecHitsEB"));
   iDesc.add<edm::InputTag>("reducedEndcapRecHitCollection", edm::InputTag("reducedEcalRecHitsEE"));
 
   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");
 
   iDesc.add<edm::InputTag>("electronSource", edm::InputTag("no default"))->setComment("input collection");
 
   // 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::EDProducer.

Definition at line 114 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);
 
   // Get the vector of Photon's from the event
   edm::Handle<edm::View<reco::Photon> > photons;
   iEvent.getByToken(photonToken_, photons);
 
   edm::InputTag  reducedEBRecHitCollection(std::string("reducedEcalRecHitsEB"));
   edm::InputTag  reducedEERecHitCollection(std::string("reducedEcalRecHitsEE"));
   EcalClusterLazyTools lazyTools(iEvent, iSetup, reducedBarrelRecHitCollection_, reducedEndcapRecHitCollection_);
 
   // Get calo geometry
   edm::ESHandle<CaloGeometry> theCaloGeometry;
   iSetup.get<CaloGeometryRecord>().get(theCaloGeometry);
   ecalGeometry_ = & (*theCaloGeometry);
 
   // 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);
 
   // 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 > rechitsH ;
     float cryPhi, cryEta, thetatilt, phitilt;
     int ieta, iphi;
 
     switch( photonRef->superCluster()->seed()->hitsAndFractions().at(0).first.subdetId() ) {
     case EcalBarrel:
       {
         iEvent.getByToken(reducedBarrelRecHitCollectionToken_,rechitsH);
         ecl_.localCoordsEB( *photonRef->superCluster()->seed(), *ecalGeometry_, cryEta, cryPhi, ieta, iphi, thetatilt, phitilt);
       }
       break;
     case EcalEndcap:
       {
         iEvent.getByToken(reducedEndcapRecHitCollectionToken_,rechitsH);
       }
       break;
     default:
      edm::LogError("PFECALSuperClusterProducer::calculateRegressedEnergy") << "Supercluster seed is either EB nor EE!" << std::endl;
     }
 
     EcalRecHitCollection selectedRecHits;
     const EcalRecHitCollection *recHits = rechitsH.product();
 
     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() );
 
     // prepare input variables for regression energy correction
     float maxDR=999., maxDRDPhi=999., maxDRDEta=999., maxDRRawEnergy=0.;
     float subClusRawE[3], subClusDPhi[3], subClusDEta[3];
     memset(subClusRawE,0,3*sizeof(float));
     memset(subClusDPhi,0,3*sizeof(float));
     memset(subClusDEta,0,3*sizeof(float));
     size_t iclus=0;
     for( auto clus = photonRef->superCluster()->clustersBegin()+1; clus != photonRef->superCluster()->clustersEnd(); ++clus ) {
       const float this_deta = (*clus)->eta() - photonRef->superCluster()->seed()->eta();
       const float this_dphi = TVector2::Phi_mpi_pi((*clus)->phi() - photonRef->superCluster()->seed()->phi());
       const float this_dr = std::hypot(this_deta,this_dphi);
       if(this_dr > maxDR || maxDR == 999.0f) {
         maxDR = this_dr;
         maxDRDEta = this_deta;
         maxDRDPhi = this_dphi;
         maxDRRawEnergy = (*clus)->energy();
       }
       if( iclus++ < 3 ) {
         subClusRawE[iclus] = (*clus)->energy();
         subClusDEta[iclus] = this_deta;
         subClusDPhi[iclus] = this_dphi;
       }
     }
 
     const float eMax = EcalClusterTools::eMax( *photonRef->superCluster()->seed(), &*rechitsH );
     const float e2nd = EcalClusterTools::e2nd( *photonRef->superCluster()->seed(), &*rechitsH );
     const float e3x3 = EcalClusterTools::e3x3( *photonRef->superCluster()->seed(), &*rechitsH, ecalTopology_ );
     const float eTop = EcalClusterTools::eTop( *photonRef->superCluster()->seed(), &*rechitsH, ecalTopology_ );
     const float eBottom = EcalClusterTools::eBottom( *photonRef->superCluster()->seed(), &*rechitsH, ecalTopology_ );
     const float eLeft = EcalClusterTools::eLeft( *photonRef->superCluster()->seed(), &*rechitsH, ecalTopology_ );
     const float eRight = EcalClusterTools::eRight( *photonRef->superCluster()->seed(), &*rechitsH, ecalTopology_ );
     std::vector<float> vCov = EcalClusterTools::localCovariances( *photonRef->superCluster()->seed(), &*rechitsH, ecalTopology_ );
     const float see = (isnan(vCov[0]) ? 0. : sqrt(vCov[0]));
     const float spp = (isnan(vCov[2]) ? 0. : sqrt(vCov[2]));
     const float sep = vCov[1];
 
     // set input variables for regression energy correction
     aPhoton.setEMax( eMax );
     aPhoton.setE2nd( e2nd );
     aPhoton.setE3x3( e3x3 );
     aPhoton.setETop( eTop );
     aPhoton.setEBottom( eBottom );
     aPhoton.setELeft( eLeft );
     aPhoton.setERight( eRight );
     aPhoton.setSee( see );
     aPhoton.setSpp( spp );
     aPhoton.setSep( sep );
 
     aPhoton.setMaxDR( maxDR );
     aPhoton.setMaxDRDPhi( maxDRDPhi );
     aPhoton.setMaxDRDEta( maxDRDEta );
     aPhoton.setMaxDRRawEnergy( maxDRRawEnergy );
     aPhoton.setSubClusRawE1( subClusRawE[0] );
     aPhoton.setSubClusRawE2( subClusRawE[1] );
     aPhoton.setSubClusRawE3( subClusRawE[2] );
     aPhoton.setSubClusDPhi1( subClusDPhi[0] );
     aPhoton.setSubClusDPhi2( subClusDPhi[1] );
     aPhoton.setSubClusDPhi3( subClusDPhi[2] );
     aPhoton.setSubClusDEta1( subClusDEta[0] );
     aPhoton.setSubClusDEta2( subClusDEta[1] );
     aPhoton.setSubClusDEta3( subClusDEta[2] );
 
     aPhoton.setCryPhi( cryPhi );
     aPhoton.setCryEta( cryEta );
     aPhoton.setIEta( ieta );
     aPhoton.setIPhi( iphi );
 
     // 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 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 139 of file PATPhotonProducer.h.

References pat::EcalIso, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), pat::HcalIso, combine::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 112 of file PATPhotonProducer.h.

bool pat::PATPhotonProducer::addGenMatch_

private

Definition at line 85 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::addPhotonID_

private

Definition at line 118 of file PATPhotonProducer.h.

Referenced by produce().

bool pat::PATPhotonProducer::addResolutions_

private

Definition at line 115 of file PATPhotonProducer.h.

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

private

Definition at line 72 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

const CaloGeometry* pat::PATPhotonProducer::ecalGeometry_

private

Definition at line 127 of file PATPhotonProducer.h.

Referenced by produce().

const CaloTopology* pat::PATPhotonProducer::ecalTopology_

private

Definition at line 126 of file PATPhotonProducer.h.

Referenced by produce().

EcalClusterLocal pat::PATPhotonProducer::ecl_

private

Definition at line 128 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 113 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 70 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedBasicClusters_

private

Definition at line 76 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedGenMatch_

private

Definition at line 86 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedPreshowerClusters_

private

Definition at line 77 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedRecHits_

private

Definition at line 78 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedSeedCluster_

private

Definition at line 75 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

bool pat::PATPhotonProducer::embedSuperCluster_

private

Definition at line 74 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

GreaterByEt<Photon> pat::PATPhotonProducer::eTComparator_

private

Definition at line 90 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 87 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

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

private

Definition at line 71 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

IsolationLabels pat::PATPhotonProducer::isoDepositLabels_

private

Definition at line 102 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 99 of file PATPhotonProducer.h.

Referenced by produce().

IsolationLabels pat::PATPhotonProducer::isolationValueLabels_

private

Definition at line 103 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 100 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 97 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 98 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 120 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 121 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 69 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

edm::InputTag pat::PATPhotonProducer::reducedBarrelRecHitCollection_

private

Definition at line 80 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

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

private

Definition at line 81 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

edm::InputTag pat::PATPhotonProducer::reducedEndcapRecHitCollection_

private

Definition at line 82 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

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

private

Definition at line 83 of file PATPhotonProducer.h.

Referenced by PATPhotonProducer(), and produce().

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

private

Definition at line 116 of file PATPhotonProducer.h.

Referenced by produce().

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

private

Definition at line 124 of file PATPhotonProducer.h.

Referenced by produce().

bool pat::PATPhotonProducer::useUserData_

private

Definition at line 123 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