#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

void	findFirstNonElectronMother2 (const reco::Candidate *particle, int &ancestorPID, int &ancestorStatus)

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_

const edm::EDGetToken	genParticles_

const edm::EDGetToken	genParticlesMiniAOD_

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_

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 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 162 of file ElectronMVANtuplizer.cc.

References edm::EDConsumerBase::consumes(), ele3Q_, eleIsEB_, eleIsEBEEGap_, eleIsEBEtaGap_, eleIsEBPhiGap_, eleIsEE_, eleIsEEDeeGap_, eleIsEERingGap_, eleMapBranchNames_, eleMapTags_, eleMapTokens_, eleQ_, genNpu_, MVAVariableManager< ParticleType >::getGlobalInputTags(), MVAVariableManager< ParticleType >::getHelperInputTags(), 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_, GlobalPosition_Frontier_DevDB_cff::tag, tree_, valMapBranchNames_, valMapTags_, valMapTokens_, vars_, and vtxN_.

  :
   src_                   (consumes<edm::View<reco::GsfElectron> >(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"))),
   genParticles_          (consumes<edm::View<reco::GenParticle> >(iConfig.getParameter<edm::InputTag>("genParticles"))),
   srcMiniAOD_            (consumes<edm::View<reco::GsfElectron> >(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"))),
   genParticlesMiniAOD_   (consumes<edm::View<reco::GenParticle> >(iConfig.getParameter<edm::InputTag>("genParticlesMiniAOD"))),
   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())
 {
     // 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
    for (auto &tag : mvaVarMngr_.getHelperInputTags()) {
        consumes<edm::ValueMap<float>>(tag);
    }
    for (auto &tag : mvaVarMngr_.getGlobalInputTags()) {
        consumes<double>(tag);
    }
 }

ElectronMVANtuplizer::~ElectronMVANtuplizer ( )

override

Definition at line 271 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 286 of file ElectronMVANtuplizer.cc.

References ele3Q_, eleIsEB_, eleIsEBEEGap_, eleIsEBEtaGap_, eleIsEBPhiGap_, eleIsEE_, eleIsEEDeeGap_, eleIsEERingGap_, eleMapTokens_, eleQ_, edm::EventID::event(), genNpu_, GenHFHadronMatcher_cfi::genParticles, genParticles_, genParticlesMiniAOD_, edm::Event::getByToken(), MVAVariableManager< ParticleType >::getValue(), edm::EventBase::id(), createfilelist::int, isMC_, edm::HandleBase::isValid(), gen::k, edm::EventBase::luminosityBlock(), matchedGenIdx_, matchedToGenEle_, matchToTruth(), mvaCats_, mvaCatTokens_, mvaPasses_, mvaValues_, mvaVarMngr_, nCats_, nEleMaps_, nEvent_, nLumi_, nRun_, nValMaps_, nVars_, ElectronMVANtuplizer_cfg::pileup, pileup_, pileupMiniAOD_, ptThreshold_, muons2muons_cfi::pu, edm::EventID::run(), TrackRefitter_38T_cff::src, src_, srcMiniAOD_, tree_, valMapTokens_, MuonErrorMatrixValues_cff::values, vars_, 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
     if(isMC_) {
         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
        for(const auto& pu : *pileup)
        {
            int bx = pu.getBunchCrossing();
            if(bx == 0)
            {
                genNpu_ = pu.getPU_NumInteractions();
                break;
            }
        }
     }
 
     // Retrieve genParticles
     edm::Handle<edm::View<reco::GenParticle> >  genParticles;
     if(isMC_) {
         iEvent.getByToken(genParticles_, genParticles);
         if( !genParticles.isValid() ){
           iEvent.getByToken(genParticlesMiniAOD_, genParticles);
           if( !genParticles.isValid() )
             throw cms::Exception(" Collection not found: ")
               << " failed to find a standard AOD or miniAOD genParticle collection " << std::endl;
         }
     }
 
 
     edm::Handle<edm::View<reco::GsfElectron> > 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[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]);
     }
 
     int nEle = src->size();
 
     for(int iEle = 0; iEle < nEle; ++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 )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 497 of file ElectronMVANtuplizer.cc.

498 {

499 }

void ElectronMVANtuplizer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 503 of file ElectronMVANtuplizer.cc.

504 {

505 }

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

static

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

void ElectronMVANtuplizer::findFirstNonElectronMother2	(	const reco::Candidate *	particle,
		int &	ancestorPID,
		int &	ancestorStatus
	)

private

Definition at line 424 of file ElectronMVANtuplizer.cc.

References funct::abs(), reco::Candidate::mother(), reco::Candidate::pdgId(), and reco::Candidate::status().

Referenced by matchToTruth().

                                                                {
 
   if( particle == nullptr ){
     edm::LogError  ("ElectronNtuplizer") << "ElectronNtuplizer: ERROR! null candidate pointer, this should never happen";
     return;
   }
 
   // Is this the first non-electron parent? If yes, return, otherwise
   // go deeper into recursion
   if( abs(particle->pdgId()) == 11 ){
     findFirstNonElectronMother2(particle->mother(0), ancestorPID, ancestorStatus);
   }else{
     ancestorPID = particle->pdgId();
     ancestorStatus = particle->status();
   }
 
   return;
 }

template<class T , class V >

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

private

Definition at line 445 of file ElectronMVANtuplizer.cc.

References funct::abs(), HiRegitMuonDetachedTripletStep_cff::DeltaR, deltaR_, PATTauDiscriminationAgainstElectronDeadECAL_cfi::dR, findFirstNonElectronMother2(), mps_fire::i, reco::Candidate::p4(), reco::Candidate::pdgId(), reco::Candidate::status(), TRUE_ELECTRON_FROM_TAU, TRUE_NON_PROMPT_ELECTRON, TRUE_PROMPT_ELECTRON, and UNMATCHED.

Referenced by analyze().

                                                                                            {
 
   //
   // Explicit loop and geometric matching method (advised by Josh Bendavid)
   //
 
   // Find the closest status 1 gen electron to the reco electron
   double dR = 999;
   const reco::Candidate *closestElectron = nullptr;
   for(size_t i=0; i<prunedGenParticles->size();i++){
     const reco::Candidate *particle = &(*prunedGenParticles)[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;
       closestElectron = particle;
       genIdx = i;
     }
   }
   // See if the closest electron (if it exists) is close enough.
   // If not, no match found.
   if( !(closestElectron != nullptr && dR < deltaR_) ) {
     return UNMATCHED;
   }
 
   //
   int ancestorPID = -999;
   int ancestorStatus = -999;
   findFirstNonElectronMother2(closestElectron, ancestorPID, ancestorStatus);
 
   if( ancestorPID == -999 && ancestorStatus == -999 ){
     // No non-electron parent??? This should never happen.
     // Complain.
     edm::LogError  ("ElectronNtuplizer") << "ElectronNtuplizer: ERROR! null candidate pointer, this should never happen";
     return UNMATCHED;
   }
 
   if( abs(ancestorPID) > 50 && ancestorStatus == 2 )
     return TRUE_NON_PROMPT_ELECTRON;
 
   if( abs(ancestorPID) == 15 && ancestorStatus == 2 )
     return TRUE_ELECTRON_FROM_TAU;
 
   // What remains is true prompt electrons
   return TRUE_PROMPT_ELECTRON;
 }