#include <RecoEgamma/ElectronIdentification/plugins/ElectronMVANtuplizer.cc>

Inheritance diagram for ElectronMVANtuplizer:

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

	~ElectronMVANtuplizer () 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

template<class T , class V >
int	matchToTruth (const T &el, const V &genParticles, int &genIdx)

Private Attributes
const double	deltaR_

int	ele3Q_

bool	eleIsEB_

bool	eleIsEBEEGap_

bool	eleIsEBEtaGap_

bool	eleIsEBPhiGap_

bool	eleIsEE_

bool	eleIsEEDeeGap_

bool	eleIsEERingGap_

const std::vector< std::string >	eleMapBranchNames_

const std::vector< std::string >	eleMapTags_

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

float	eleQ_

int	genNpu_

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

const bool	isMC_

int	matchedGenIdx_

int	matchedToGenEle_

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::GsfElectron >	mvaVarMngr_

const size_t	nCats_

const size_t	nEleMaps_

int	nEvent_

int	nLumi_

int	nRun_

const size_t	nValMaps_

int	nVars_

MultiTokenT< std::vector< PileupSummaryInfo > >	pileup_

const double	ptThreshold_

MultiTokenT< edm::View< reco::GsfElectron > >	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 for training and testing electron MVA IDs.

Implementation: [Notes on implementation]

Definition at line 56 of file ElectronMVANtuplizer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 157 of file ElectronMVANtuplizer.cc.

References edm::EDConsumerBase::consumes(), edm::EDConsumerBase::consumesCollector(), ele3Q_, eleIsEB_, eleIsEBEEGap_, eleIsEBEtaGap_, eleIsEBPhiGap_, eleIsEE_, eleIsEEDeeGap_, eleIsEERingGap_, eleMapBranchNames_, eleMapTags_, eleMapTokens_, eleQ_, genNpu_, MVAVariableManager< ParticleType >::getName(), MVAVariableManager< ParticleType >::getNVars(), mps_fire::i, isMC_, gen::k, TFileService::kSharedResource, TFileService::make(), matchedToGenEle_, mvaCatBranchNames_, mvaCats_, mvaCatTags_, mvaCatTokens_, mvaPasses_, mvaValues_, mvaVarMngr_, nCats_, nEleMaps_, nEvent_, nLumi_, nRun_, nValMaps_, nVars_, MVAVariableManager< ParticleType >::setConsumes(), tree_, valMapBranchNames_, valMapTags_, valMapTokens_, vars_, and vtxN_.

   : mvaVarMngr_            (iConfig.getParameter<std::string>("variableDefinition"))
   , isMC_                  (iConfig.getParameter<bool>("isMC"))
   , deltaR_                (iConfig.getParameter<double>("deltaR"))
   , ptThreshold_           (iConfig.getParameter<double>("ptThreshold"))
   , eleMapTags_            (iConfig.getUntrackedParameter<std::vector<std::string>>("eleMVAs"))
   , eleMapBranchNames_     (iConfig.getUntrackedParameter<std::vector<std::string>>("eleMVALabels"))
   , nEleMaps_              (eleMapBranchNames_.size())
   , valMapTags_            (iConfig.getUntrackedParameter<std::vector<std::string>>("eleMVAValMaps"))
   , valMapBranchNames_     (iConfig.getUntrackedParameter<std::vector<std::string>>("eleMVAValMapLabels"))
   , nValMaps_              (valMapBranchNames_.size())
   , mvaCatTags_            (iConfig.getUntrackedParameter<std::vector<std::string>>("eleMVACats"))
   , mvaCatBranchNames_     (iConfig.getUntrackedParameter<std::vector<std::string>>("eleMVACatLabels"))
   , nCats_                 (mvaCatBranchNames_.size())
   , src_                   (consumesCollector(), iConfig, "src"         , "srcMiniAOD")
   , vertices_        (src_, consumesCollector(), iConfig, "vertices"    , "verticesMiniAOD")
   , pileup_          (src_, consumesCollector(), iConfig, "pileup"      , "pileupMiniAOD")
   , genParticles_    (src_, consumesCollector(), iConfig, "genParticles", "genParticlesMiniAOD")
 {
     // eleMaps
     for (size_t k = 0; k < nEleMaps_; ++k) {
 
         eleMapTokens_.push_back(consumes<edm::ValueMap<bool> >(edm::InputTag(eleMapTags_[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");
 
    nVars_ = mvaVarMngr_.getNVars();
 
    tree_->Branch("nEvent",  &nEvent_);
    tree_->Branch("nRun",    &nRun_);
    tree_->Branch("nLumi",   &nLumi_);
    if (isMC_) tree_->Branch("genNpu", &genNpu_);
    tree_->Branch("vtxN",   &vtxN_);
 
    tree_->Branch("ele_q",&eleQ_);
    tree_->Branch("ele_3q",&ele3Q_);
 
    if (isMC_) {
        tree_->Branch("matchedToGenEle",   &matchedToGenEle_);
    }
 
    // Has to be in two different loops
    for (int i = 0; i < nVars_; ++i) {
        vars_.push_back(0.0);
    }
    for (int i = 0; i < nVars_; ++i) {
        tree_->Branch(mvaVarMngr_.getName(i).c_str(), &vars_[i]);
    }
 
    tree_->Branch("ele_isEB",&eleIsEB_);
    tree_->Branch("ele_isEE",&eleIsEE_);
    tree_->Branch("ele_isEBEtaGap",&eleIsEBEtaGap_);
    tree_->Branch("ele_isEBPhiGap",&eleIsEBPhiGap_);
    tree_->Branch("ele_isEBEEGap", &eleIsEBEEGap_);
    tree_->Branch("ele_isEEDeeGap",&eleIsEEDeeGap_);
    tree_->Branch("ele_isEERingGap",&eleIsEERingGap_);
 
    // IDs
    for (size_t k = 0; k < nValMaps_; ++k) {
        tree_->Branch(valMapBranchNames_[k].c_str() ,  &mvaValues_[k]);
    }
 
    for (size_t k = 0; k < nEleMaps_; ++k) {
        tree_->Branch(eleMapBranchNames_[k].c_str() ,  &mvaPasses_[k]);
    }
 
    for (size_t k = 0; k < nCats_; ++k) {
        tree_->Branch(mvaCatBranchNames_[k].c_str() ,  &mvaCats_[k]);
    }
 
    // All tokens for event content needed by this MVA
    // Tags from the variable helper
    mvaVarMngr_.setConsumes(consumesCollector());
 }

ElectronMVANtuplizer::~ElectronMVANtuplizer ( )

override

Definition at line 256 of file ElectronMVANtuplizer.cc.

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

Member Function Documentation

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

overrideprivate

Definition at line 271 of file ElectronMVANtuplizer.cc.

References ele3Q_, eleIsEB_, eleIsEBEEGap_, eleIsEBEtaGap_, eleIsEBPhiGap_, eleIsEE_, eleIsEEDeeGap_, eleIsEERingGap_, eleMapTokens_, eleQ_, edm::EventID::event(), genNpu_, GenHFHadronMatcher_cfi::genParticles, genParticles_, edm::Event::getByToken(), MultiTokenT< T >::getHandle(), MultiTokenT< T >::getValidHandle(), MVAVariableManager< ParticleType >::getValue(), edm::EventBase::id(), createfilelist::int, isMC_, gen::k, edm::EventBase::luminosityBlock(), matchedGenIdx_, matchedToGenEle_, matchToTruth(), mvaCats_, mvaCatTokens_, mvaPasses_, mvaValues_, mvaVarMngr_, nCats_, nEleMaps_, nEvent_, nLumi_, nRun_, nValMaps_, nVars_, ElectronMVANtuplizer_cfg::pileup, pileup_, ptThreshold_, muons2muons_cfi::pu, edm::EventID::run(), TrackRefitter_38T_cff::src, src_, tree_, valMapTokens_, MuonErrorMatrixValues_cff::values, 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);
 
     // Get MC only Handles, which are allowed to be non-valid
     auto genParticles = genParticles_.getHandle(iEvent);
     auto pileup       = pileup_.getHandle(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[nEleMaps_];
     for (size_t k = 0; k < nEleMaps_; ++k) {
         iEvent.getByToken(eleMapTokens_[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(size_t iEle = 0; iEle < src->size(); ++iEle) {
 
         const auto ele =  src->ptrAt(iEle);
 
         eleQ_ = ele->charge();
         ele3Q_ = ele->chargeInfo().isGsfCtfScPixConsistent;
 
         if (ele->pt() < ptThreshold_) {
             continue;
         }
 
         for (int iVar = 0; iVar < nVars_; ++iVar) {
             vars_[iVar] = mvaVarMngr_.getValue(iVar, ele, iEvent);
         }
 
         if (isMC_) {
             matchedToGenEle_ = matchToTruth( ele, genParticles, matchedGenIdx_);
         }
 
         // gap variables
         eleIsEB_ = ele->isEB();
         eleIsEE_ = ele->isEE();
         eleIsEBEEGap_ = ele->isEBEEGap();
         eleIsEBEtaGap_ = ele->isEBEtaGap();
         eleIsEBPhiGap_ = ele->isEBPhiGap();
         eleIsEEDeeGap_ = ele->isEEDeeGap();
         eleIsEERingGap_ = ele->isEERingGap();
 
         //
         // Look up and save the ID decisions
         //
         for (size_t k = 0; k < nEleMaps_; ++k) {
           mvaPasses_[k] = (int)(*decisions[k])[ele];
         }
 
         for (size_t k = 0; k < nValMaps_; ++k) {
           mvaValues_[k] = (*values[k])[ele];
         }
 
         for (size_t k = 0; k < nCats_; ++k) {
           mvaCats_[k] = (*mvaCats[k])[ele];
         }
 
 
         tree_->Fill();
     }
 
 }

void ElectronMVANtuplizer::beginJob ( void )

inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 68 of file ElectronMVANtuplizer.cc.

68 {};

void ElectronMVANtuplizer::endJob ( void )

inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 70 of file ElectronMVANtuplizer.cc.

References GenHFHadronMatcher_cfi::genParticles, and matchToTruth().

70 {};

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

static

Definition at line 410 of file ElectronMVANtuplizer.cc.

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

                                                                                  {
 
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("src");
     desc.add<edm::InputTag>("vertices");
     desc.add<edm::InputTag>("pileup");
     desc.add<edm::InputTag>("genParticles");
     desc.add<edm::InputTag>("srcMiniAOD");
     desc.add<edm::InputTag>("verticesMiniAOD");
     desc.add<edm::InputTag>("pileupMiniAOD");
     desc.add<edm::InputTag>("genParticlesMiniAOD");
     desc.add<std::string>("variableDefinition");
     desc.add<bool>("isMC");
     desc.add<double>("deltaR", 0.1);
     desc.add<double>("ptThreshold", 5.0);
     desc.addUntracked<std::vector<std::string>>("eleMVAs");
     desc.addUntracked<std::vector<std::string>>("eleMVALabels");
     desc.addUntracked<std::vector<std::string>>("eleMVAValMaps");
     desc.addUntracked<std::vector<std::string>>("eleMVAValMapLabels");
     desc.addUntracked<std::vector<std::string>>("eleMVACats");
     desc.addUntracked<std::vector<std::string>>("eleMVACatLabels");
     descriptions.addDefault(desc);
 
 }

template<class T , class V >

int ElectronMVANtuplizer::matchToTruth	(	const T &	el,
		const V &	genParticles,
		int &	genIdx
	)

private

Definition at line 369 of file ElectronMVANtuplizer.cc.

References funct::abs(), HiRegitMuonDetachedTripletStep_cff::DeltaR, deltaR_, PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, mps_fire::i, TRUE_ELECTRON_FROM_TAU, TRUE_NON_PROMPT_ELECTRON, TRUE_PROMPT_ELECTRON, and UNMATCHED.

Referenced by analyze(), and endJob().

                                                                                      {
 
   genIdx = -1;
 
   //
   // Explicit loop and geometric matching method (advised by Josh Bendavid)
   //
 
   // Find the closest status 1 gen electron to the reco electron
   double dR = 999;
   for(size_t i=0; i<genParticles->size();i++){
     const auto particle = genParticles->ptrAt(i);
     // Drop everything that is not electron or not status 1
     if( abs(particle->pdgId()) != 11 || particle->status() != 1 )
       continue;
     //
     double dRtmp = ROOT::Math::VectorUtil::DeltaR( el->p4(), particle->p4() );
     if( dRtmp < dR ){
       dR = dRtmp;
       genIdx = i;
     }
   }
   // See if the closest electron is close enough. If not, no match found.
   if( genIdx == -1 || dR >= deltaR_ ) {
     return UNMATCHED;
   }
 
   const auto closestElectron = genParticles->ptrAt(genIdx);
 
   if( closestElectron->fromHardProcessFinalState() )
     return TRUE_PROMPT_ELECTRON;
 
   if( closestElectron->isDirectHardProcessTauDecayProductFinalState() )
     return TRUE_ELECTRON_FROM_TAU;
 
   // What remains is true non-prompt electrons
   return TRUE_NON_PROMPT_ELECTRON;
 }