#include <RecoEgamma/PhotonIdentification/plugins/PhotonMVANtuplizer.cc>

Inheritance diagram for PhotonMVANtuplizer:

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

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources >
	EDAnalyzer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

Private Attributes
const double	deltaR_

const bool	doEnergyMatrix_

const MultiTokenT< EcalRecHitCollection >	ebRecHits_

const MultiTokenT< EcalRecHitCollection >	eeRecHits_

std::vector< float >	energyMatrix_

const int	energyMatrixSize_

double	eta_

int	genNpu_

const MultiTokenT< edm::View< reco::GenParticle > >	genParticles_

const bool	isMC_

int	matchedGenIdx_

int	matchedToGenPh_

const std::vector< std::string >	mvaCatBranchNames_

std::vector< int >	mvaCats_

const std::vector< std::string >	mvaCatTags_

std::vector< edm::EDGetTokenT< edm::ValueMap< int > > >	mvaCatTokens_

std::vector< int >	mvaPasses_

std::vector< float >	mvaValues_

MVAVariableManager< reco::Photon >	mvaVarMngr_

const size_t	nCats_

int	nEvent_

int	nLumi_

const size_t	nPhoMaps_

int	nRun_

const size_t	nValMaps_

const int	nVars_

const std::vector< std::string >	phoMapBranchNames_

const std::vector< std::string >	phoMapTags_

std::vector< edm::EDGetTokenT< edm::ValueMap< bool > > >	phoMapTokens_

const MultiTokenT< std::vector< PileupSummaryInfo > >	pileup_

double	pT_

const double	ptThreshold_

const MultiTokenT< edm::View< reco::Photon > >	src_

TTree *	tree_

const std::vector< std::string >	valMapBranchNames_

const std::vector< std::string >	valMapTags_

std::vector< edm::EDGetTokenT< edm::ValueMap< float > > >	valMapTokens_

const MVAVariableHelper< reco::Photon >	variableHelper_

std::vector< float >	vars_

const MultiTokenT< std::vector< reco::Vertex > >	vertices_

int	vtxN_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

Description: Ntuplizer to use for testing photon MVA IDs.

Implementation: [Notes on implementation]

Definition at line 45 of file PhotonMVANtuplizer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 159 of file PhotonMVANtuplizer.cc.

References edm::EDConsumerBase::consumes(), doEnergyMatrix_, energyMatrix_, eta_, genNpu_, MVAVariableManager< ParticleType >::getName(), mps_fire::i, isMC_, gen::k, TFileService::kSharedResource, TFileService::make(), matchedToGenPh_, mvaCatBranchNames_, mvaCats_, mvaCatTags_, mvaCatTokens_, mvaPasses_, mvaValues_, mvaVarMngr_, nCats_, nEvent_, nLumi_, nPhoMaps_, nRun_, nValMaps_, nVars_, phoMapBranchNames_, phoMapTags_, phoMapTokens_, pT_, GlobalPosition_Frontier_DevDB_cff::tag, tree_, valMapBranchNames_, valMapTags_, valMapTokens_, vars_, and vtxN_.

  : phoMapTags_            (iConfig.getParameter<std::vector<std::string>>("phoMVAs"))
  , phoMapBranchNames_     (iConfig.getParameter<std::vector<std::string>>("phoMVALabels"))
  , nPhoMaps_              (phoMapBranchNames_.size())
  , valMapTags_            (iConfig.getParameter<std::vector<std::string>>("phoMVAValMaps"))
  , valMapBranchNames_     (iConfig.getParameter<std::vector<std::string>>("phoMVAValMapLabels"))
  , nValMaps_              (valMapBranchNames_.size())
  , mvaCatTags_            (iConfig.getParameter<std::vector<std::string>>("phoMVACats"))
  , mvaCatBranchNames_     (iConfig.getParameter<std::vector<std::string>>("phoMVACatLabels"))
  , nCats_                 (mvaCatBranchNames_.size())
  , isMC_                  (iConfig.getParameter<bool>("isMC"))
  , ptThreshold_           (iConfig.getParameter<double>("ptThreshold"))
  , deltaR_                (iConfig.getParameter<double>("deltaR"))
  , src_                   (consumesCollector(), iConfig, "src"     , "srcMiniAOD")
  , vertices_        (src_, consumesCollector(), iConfig, "vertices", "verticesMiniAOD")
  , pileup_          (src_, consumesCollector(), iConfig, "pileup"  , "pileupMiniAOD")
  , genParticles_    (src_, consumesCollector(), iConfig, "genParticles", "genParticlesMiniAOD")
  , ebRecHits_       (src_, consumesCollector(), iConfig, "ebReducedRecHitCollection", "ebReducedRecHitCollectionMiniAOD")
  , eeRecHits_       (src_, consumesCollector(), iConfig, "eeReducedRecHitCollection", "eeReducedRecHitCollectionMiniAOD")
  , mvaPasses_             (nPhoMaps_)
  , mvaValues_             (nValMaps_)
  , mvaCats_               (nCats_)
  , variableHelper_        (consumesCollector())
  , mvaVarMngr_            (iConfig.getParameter<std::string>("variableDefinition"))
  , nVars_                 (mvaVarMngr_.getNVars())
  , vars_                  (nVars_)
  , doEnergyMatrix_        (iConfig.getParameter<bool>("doEnergyMatrix"))
  , energyMatrixSize_      (iConfig.getParameter<int>("energyMatrixSize"))
 {
     // phoMaps
     for (auto const& tag : phoMapTags_) {
         phoMapTokens_.push_back(consumes<edm::ValueMap<bool> >(edm::InputTag(tag)));
     }
     // valMaps
     for (auto const& tag : valMapTags_) {
         valMapTokens_.push_back(consumes<edm::ValueMap<float> >(edm::InputTag(tag)));
     }
     // categories
     for (auto const& tag : mvaCatTags_) {
         mvaCatTokens_.push_back(consumes<edm::ValueMap<int> >(edm::InputTag(tag)));
     }
 
     // Book tree
     usesResource(TFileService::kSharedResource);
     edm::Service<TFileService> fs ;
     tree_  = fs->make<TTree>("tree","tree");
 
     tree_->Branch("nEvent", &nEvent_);
     tree_->Branch("nRun", &nRun_);
     tree_->Branch("nLumi", &nLumi_);
     if (isMC_) {
         tree_->Branch("genNpu", &genNpu_);
         tree_->Branch("matchedToGenPh", &matchedToGenPh_);
     }
     tree_->Branch("vtxN", &vtxN_);
     tree_->Branch("pT", &pT_);
     tree_->Branch("eta", &eta_);
 
     if (doEnergyMatrix_) tree_->Branch("energyMatrix",&energyMatrix_);
 
     for (int i = 0; i < nVars_; ++i) {
         tree_->Branch(mvaVarMngr_.getName(i).c_str(), &vars_[i]);
     }
 
     // IDs
     for (size_t k = 0; k < nValMaps_; ++k) {
         tree_->Branch(valMapBranchNames_[k].c_str() ,  &mvaValues_[k]);
     }
 
     for (size_t k = 0; k < nPhoMaps_; ++k) {
         tree_->Branch(phoMapBranchNames_[k].c_str() ,  &mvaPasses_[k]);
     }
 
     for (size_t k = 0; k < nCats_; ++k) {
         tree_->Branch(mvaCatBranchNames_[k].c_str() ,  &mvaCats_[k]);
     }
 }

Member Function Documentation

void PhotonMVANtuplizer::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 239 of file PhotonMVANtuplizer.cc.

References deltaR_, doEnergyMatrix_, ebRecHits_, eeRecHits_, energyMatrix_, energyMatrixSize_, eta_, edm::EventID::event(), genNpu_, GenHFHadronMatcher_cfi::genParticles, genParticles_, MVAVariableHelper< ParticleType >::getAuxVariables(), edm::Event::getByToken(), MultiTokenT< T >::getValidHandle(), MVAVariableManager< ParticleType >::getValue(), edm::EventBase::id(), iEvent, isMC_, gen::k, edm::EventBase::luminosityBlock(), matchedToGenPh_, mvaCats_, mvaCatTokens_, mvaValues_, mvaVarMngr_, nCats_, nEvent_, nLumi_, nPhoMaps_, nRun_, nValMaps_, nVars_, phoMapTokens_, estimatePileup_makeJSON::pileup, pileup_, pT_, ptThreshold_, muons2muons_cfi::pu, edm::EventID::run(), SurveyInfoScenario_cff::seed, TrackRefitter_38T_cff::src, src_, tree_, valMapTokens_, MuonErrorMatrixValues_cff::values, variableHelper_, vars_, electrons_cff::vertices, vertices_, and vtxN_.

 {
     // Fill global event info
     nEvent_ = iEvent.id().event();
     nRun_   = iEvent.id().run();
     nLumi_  = iEvent.luminosityBlock();
 
     // Get Handles
     auto src            = src_.getValidHandle(iEvent);
     auto vertices       = vertices_.getValidHandle(iEvent);
     auto pileup         = pileup_.getValidHandle(iEvent);
     auto genParticles   = genParticles_.getValidHandle(iEvent);
 
     vtxN_ = vertices->size();
 
     // initialize cluster tools
     std::unique_ptr<noZS::EcalClusterLazyTools> lazyTools;
     if(doEnergyMatrix_) {
         // Configure Lazy Tools, which will compute 5x5 quantities
         lazyTools = std::make_unique<noZS::EcalClusterLazyTools>(
                 iEvent, iSetup, ebRecHits_.get(iEvent), eeRecHits_.get(iEvent));
     }
 
     // Fill with true number of pileup
     if(isMC_) {
        for(const auto& pu : *pileup)
        {
            int bx = pu.getBunchCrossing();
            if(bx == 0)
            {
                genNpu_ = pu.getPU_NumInteractions();
                break;
            }
        }
     }
 
     // Get MVA decisions
     edm::Handle<edm::ValueMap<bool> > decisions[nPhoMaps_];
     for (size_t k = 0; k < nPhoMaps_; ++k) {
         iEvent.getByToken(phoMapTokens_[k],decisions[k]);
     }
 
     // Get MVA values
     edm::Handle<edm::ValueMap<float> > values[nValMaps_];
     for (size_t k = 0; k < nValMaps_; ++k) {
         iEvent.getByToken(valMapTokens_[k],values[k]);
     }
 
     // Get MVA categories
     edm::Handle<edm::ValueMap<int> > mvaCats[nCats_];
     for (size_t k = 0; k < nCats_; ++k) {
         iEvent.getByToken(mvaCatTokens_[k],mvaCats[k]);
     }
 
     for(auto const& pho : src->ptrs())
     {
         if (pho->pt() < ptThreshold_) continue;
 
         pT_ = pho->pt();
         eta_ = pho->eta();
 
         // Fill the energy matrix around the seed
         if(doEnergyMatrix_) {
             const auto& seed = *(pho->superCluster()->seed());
             energyMatrix_ = lazyTools->energyMatrix(seed, energyMatrixSize_);
         }
 
         // variables from the text file
         for (int iVar = 0; iVar < nVars_; ++iVar) {
             std::vector<float> extraVariables = variableHelper_.getAuxVariables(pho, iEvent);
             vars_[iVar] = mvaVarMngr_.getValue(iVar, *pho, extraVariables);
         }
 
         if (isMC_) matchedToGenPh_ = matchToTruth( *pho, *genParticles, deltaR_);
 
         //
         // Look up and save the ID decisions
         //
         for (size_t k = 0; k < nPhoMaps_; ++k) mvaPasses_[k] = static_cast<int>((*decisions[k])[pho]);
         for (size_t k = 0; k < nValMaps_; ++k) mvaValues_[k] = (*values[k])[pho];
         for (size_t k = 0; k < nCats_   ; ++k) mvaCats_[k]   = (*mvaCats[k])[pho];
 
         tree_->Fill();
     }
 
 }

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

static

Definition at line 328 of file PhotonMVANtuplizer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), DEFINE_FWK_MODULE, and AlCaHLTBitMon_QueryRunRegistry::string.

 {
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("src",                 edm::InputTag("gedPhotons"));
     desc.add<edm::InputTag>("vertices",            edm::InputTag("offlinePrimaryVertices"));
     desc.add<edm::InputTag>("pileup",              edm::InputTag("addPileupInfo"));
     desc.add<edm::InputTag>("genParticles",        edm::InputTag("genParticles"));
     desc.add<edm::InputTag>("srcMiniAOD",          edm::InputTag("slimmedPhotons"));
     desc.add<edm::InputTag>("verticesMiniAOD",     edm::InputTag("offlineSlimmedPrimaryVertices"));
     desc.add<edm::InputTag>("pileupMiniAOD",       edm::InputTag("slimmedAddPileupInfo"));
     desc.add<edm::InputTag>("genParticlesMiniAOD", edm::InputTag("prunedGenParticles"));
     desc.add<edm::InputTag>("ebReducedRecHitCollection",        edm::InputTag("reducedEcalRecHitsEB"));
     desc.add<edm::InputTag>("eeReducedRecHitCollection",        edm::InputTag("reducedEcalRecHitsEE"));
     desc.add<edm::InputTag>("ebReducedRecHitCollectionMiniAOD", edm::InputTag("reducedEgamma","reducedEBRecHits"));
     desc.add<edm::InputTag>("eeReducedRecHitCollectionMiniAOD", edm::InputTag("reducedEgamma","reducedEERecHits"));
     desc.add<std::vector<std::string>>("phoMVAs", {});
     desc.add<std::vector<std::string>>("phoMVALabels", {});
     desc.add<std::vector<std::string>>("phoMVAValMaps", {});
     desc.add<std::vector<std::string>>("phoMVAValMapLabels", {});
     desc.add<std::vector<std::string>>("phoMVACats", {});
     desc.add<std::vector<std::string>>("phoMVACatLabels", {});
     desc.add<bool>("doEnergyMatrix", false);
     desc.add<int>("energyMatrixSize", 2)->setComment("extension of crystals in each direction away from the seed");
     desc.add<bool>("isMC", true);
     desc.add<double>("ptThreshold", 15.0);
     desc.add<double>("deltaR", 0.1);
     desc.add<std::string>("variableDefinition");
     descriptions.addDefault(desc);
 }