#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_

MultiTokenT< std::vector< PileupSummaryInfo > >	pileup_

const double	ptThreshold_

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_

std::vector< float >	vars_

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 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 56 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_.

  : 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"))
  , src_                   (consumesCollector(), iConfig, "src"     , "srcMiniAOD")
  , vertices_        (src_, consumesCollector(), iConfig, "vertices", "verticesMiniAOD")
  , pileup_          (src_, consumesCollector(), iConfig, "pileup"  , "pileupMiniAOD")
 {
     // 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 202 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 217 of file PhotonMVANtuplizer.cc.

References edm::EventID::event(), genNpu_, edm::Event::getByToken(), MultiTokenT< T >::getValidHandle(), edm::EventBase::id(), createfilelist::int, isMC_, gen::k, edm::EventBase::luminosityBlock(), mvaCats_, mvaCatTokens_, mvaPasses_, mvaValues_, nCats_, nEvent_, nLumi_, nPhoMaps_, nRun_, nValMaps_, phoMapTokens_, ElectronMVANtuplizer_cfg::pileup, pileup_, ptThreshold_, muons2muons_cfi::pu, edm::EventID::run(), TrackRefitter_38T_cff::src, src_, tree_, valMapTokens_, MuonErrorMatrixValues_cff::values, 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);
 
     vtxN_ = vertices->size();
 
     // 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]);
     }
 
     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 )

inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 69 of file PhotonMVANtuplizer.cc.

69 {};

void PhotonMVANtuplizer::endJob ( void )

inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 71 of file PhotonMVANtuplizer.cc.

71 {};

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

static

Definition at line 295 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);
 
 }