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

Inheritance diagram for PhotonMVANtuplizer:

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

	~PhotonMVANtuplizer () override

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

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

virtual	~EDConsumerBase () noexcept(false)

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

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

void	beginJob () override

void	endJob () override

Private Attributes
int	genNpu_

const bool	isMC_

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_

const size_t	nCats_

int	nEvent_

int	nLumi_

const size_t	nPhoMaps_

int	nRun_

const size_t	nValMaps_

int	nVars_

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

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

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

const edm::EDGetToken	pileup_

const edm::EDGetToken	pileupMiniAOD_

const double	ptThreshold_

const edm::EDGetToken	src_

const edm::EDGetToken	srcMiniAOD_

TTree *	tree_

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

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

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

std::vector< float >	vars_

const edm::EDGetToken	vertices_

const edm::EDGetToken	verticesMiniAOD_

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 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 55 of file PhotonMVANtuplizer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 130 of file PhotonMVANtuplizer.cc.

References edm::EDConsumerBase::consumes(), genNpu_, mps_fire::i, isMC_, gen::k, TFileService::kSharedResource, TFileService::make(), mvaCatBranchNames_, mvaCats_, mvaCatTags_, mvaCatTokens_, mvaPasses_, mvaValues_, nCats_, nEvent_, nLumi_, nPhoMaps_, nRun_, nValMaps_, nVars_, phoMapBranchNames_, phoMapTags_, phoMapTokens_, tree_, valMapBranchNames_, valMapTags_, valMapTokens_, vars_, and vtxN_.

  :
   src_                   (consumes<edm::View<reco::Photon> >(iConfig.getParameter<edm::InputTag>("src"))),
   vertices_              (consumes<std::vector<reco::Vertex> >(iConfig.getParameter<edm::InputTag>("vertices"))),
   pileup_                (consumes<std::vector< PileupSummaryInfo > >(iConfig.getParameter<edm::InputTag>("pileup"))),
   srcMiniAOD_            (consumes<edm::View<reco::Photon> >(iConfig.getParameter<edm::InputTag>("srcMiniAOD"))),
   verticesMiniAOD_       (consumes<std::vector<reco::Vertex> >(iConfig.getParameter<edm::InputTag>("verticesMiniAOD"))),
   pileupMiniAOD_         (consumes<std::vector< PileupSummaryInfo > >(iConfig.getParameter<edm::InputTag>("pileupMiniAOD"))),
   phoMapTags_            (iConfig.getUntrackedParameter<std::vector<std::string>>("phoMVAs")),
   phoMapBranchNames_     (iConfig.getUntrackedParameter<std::vector<std::string>>("phoMVALabels")),
   nPhoMaps_              (phoMapBranchNames_.size()),
   valMapTags_            (iConfig.getUntrackedParameter<std::vector<std::string>>("phoMVAValMaps")),
   valMapBranchNames_     (iConfig.getUntrackedParameter<std::vector<std::string>>("phoMVAValMapLabels")),
   nValMaps_              (valMapBranchNames_.size()),
   mvaCatTags_            (iConfig.getUntrackedParameter<std::vector<std::string>>("phoMVACats")),
   mvaCatBranchNames_     (iConfig.getUntrackedParameter<std::vector<std::string>>("phoMVACatLabels")),
   nCats_                 (mvaCatBranchNames_.size()),
   isMC_                  (iConfig.getParameter<bool>("isMC")),
   ptThreshold_           (iConfig.getParameter<double>("ptThreshold"))
 {
     // phoMaps
     for (size_t k = 0; k < nPhoMaps_; ++k) {
 
         phoMapTokens_.push_back(consumes<edm::ValueMap<bool> >(edm::InputTag(phoMapTags_[k])));
 
         // Initialize vectors for holding ID decisions
         mvaPasses_.push_back(0);
     }
 
     // valMaps
     for (size_t k = 0; k < nValMaps_; ++k) {
         valMapTokens_.push_back(consumes<edm::ValueMap<float> >(edm::InputTag(valMapTags_[k])));
 
         // Initialize vectors for holding MVA values
         mvaValues_.push_back(0.0);
     }
 
     // categories
     for (size_t k = 0; k < nCats_; ++k) {
         mvaCatTokens_.push_back(consumes<edm::ValueMap<int> >(edm::InputTag(mvaCatTags_[k])));
 
         // Initialize vectors for holding MVA values
         mvaCats_.push_back(0);
     }
 
    // 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("vtxN",   &vtxN_);
 
    // Has to be in two different loops
    for (int i = 0; i < nVars_; ++i) {
        vars_.push_back(0.0);
    }
 
    // 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]);
    }
 }

PhotonMVANtuplizer::~PhotonMVANtuplizer ( )

override

Definition at line 206 of file PhotonMVANtuplizer.cc.

 {
 
    // do anything here that needs to be done at desctruction time
    // (e.g. close files, deallocate resources etc.)
 
 }

Member Function Documentation

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

overrideprivate

Definition at line 221 of file PhotonMVANtuplizer.cc.

References edm::EventID::event(), genNpu_, edm::Event::getByToken(), edm::EventBase::id(), createfilelist::int, isMC_, edm::HandleBase::isValid(), gen::k, edm::EventBase::luminosityBlock(), mvaCats_, mvaCatTokens_, mvaPasses_, mvaValues_, nCats_, nEvent_, nLumi_, nPhoMaps_, nRun_, nValMaps_, phoMapTokens_, ElectronMVANtuplizer_cfg::pileup, pileup_, pileupMiniAOD_, ptThreshold_, muons2muons_cfi::pu, edm::EventID::run(), TrackRefitter_38T_cff::src, src_, srcMiniAOD_, tree_, valMapTokens_, MuonErrorMatrixValues_cff::values, electrons_cff::vertices, vertices_, verticesMiniAOD_, and vtxN_.

 {
     // Fill global event info
     nEvent_ = iEvent.id().event();
     nRun_   = iEvent.id().run();
     nLumi_  = iEvent.luminosityBlock();
 
 
     // Retrieve Vertecies
     edm::Handle<reco::VertexCollection> vertices;
     iEvent.getByToken(vertices_, vertices);
     if( !vertices.isValid() ){
       iEvent.getByToken(verticesMiniAOD_,vertices);
       if( !vertices.isValid() )
         throw cms::Exception(" Collection not found: ")
           << " failed to find a standard AOD or miniAOD vertex collection " << std::endl;
     }
 
     vtxN_ = vertices->size();
 
     // Retrieve Pileup Info
     edm::Handle<std::vector< PileupSummaryInfo > >  pileup;
     iEvent.getByToken(pileup_, pileup);
     if( !pileup.isValid() ){
       iEvent.getByToken(pileupMiniAOD_,pileup);
       if( !pileup.isValid() )
         throw cms::Exception(" Collection not found: ")
           << " failed to find a standard AOD or miniAOD pileup collection " << std::endl;
     }
 
     // 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;
            }
        }
     }
 
     edm::Handle<edm::View<reco::Photon> > src;
 
     // Retrieve the collection of particles from the event.
     // If we fail to retrieve the collection with the standard AOD
     // name, we next look for the one with the stndard miniAOD name.
     iEvent.getByToken(src_, src);
     if( !src.isValid() ){
       iEvent.getByToken(srcMiniAOD_,src);
       if( !src.isValid() )
         throw cms::Exception(" Collection not found: ")
           << " failed to find a standard AOD or miniAOD particle collection " << std::endl;
     }
 
     // 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]);
     }
 
     int nPho = src->size();
 
     for(int iPho = 0; iPho < nPho; ++iPho) {
 
         const auto pho =  src->ptrAt(iPho);
 
         if (pho->pt() < ptThreshold_) {
             continue;
         }
 
         //
         // Look up and save the ID decisions
         //
         for (size_t k = 0; k < nPhoMaps_; ++k) {
           mvaPasses_[k] = (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::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 328 of file PhotonMVANtuplizer.cc.

329 {

330 }

void PhotonMVANtuplizer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 334 of file PhotonMVANtuplizer.cc.

335 {

336 }

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

static

Definition at line 340 of file PhotonMVANtuplizer.cc.

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

                                                                                {
 
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("src");
     desc.add<edm::InputTag>("vertices");
     desc.add<edm::InputTag>("pileup");
     desc.add<edm::InputTag>("srcMiniAOD");
     desc.add<edm::InputTag>("verticesMiniAOD");
     desc.add<edm::InputTag>("pileupMiniAOD");
     desc.addUntracked<std::vector<std::string>>("phoMVAs");
     desc.addUntracked<std::vector<std::string>>("phoMVALabels");
     desc.addUntracked<std::vector<std::string>>("phoMVAValMaps");
     desc.addUntracked<std::vector<std::string>>("phoMVAValMapLabels");
     desc.addUntracked<std::vector<std::string>>("phoMVACats");
     desc.addUntracked<std::vector<std::string>>("phoMVACatLabels");
     desc.add<bool>("isMC");
     desc.add<double>("ptThreshold", 5.0);
     descriptions.addDefault(desc);
 
 }