Inheritance diagram for PATTauDiscriminationAgainstElectronMVA6:

Public Member Functions
void	beginEvent (const edm::Event &, const edm::EventSetup &)

double	discriminate (const TauRef &) const

void	endEvent (edm::Event &)

	PATTauDiscriminationAgainstElectronMVA6 (const edm::ParameterSet &cfg)

	~PATTauDiscriminationAgainstElectronMVA6 ()

Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
void	produce (edm::Event &, const edm::EventSetup &)

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	TauDiscriminationProducerBase ()

virtual	~TauDiscriminationProducerBase ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

std::vector < edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

	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 &	itemsToGetFromEvent () 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

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

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
bool	isInEcalCrack (double) const

Private Attributes
std::unique_ptr < PATTauDiscriminator >	category_output_

edm::Handle < pat::ElectronCollection >	Electrons

edm::EDGetTokenT < pat::ElectronCollection >	electronToken

std::string	moduleLabel_

std::unique_ptr < AntiElectronIDMVA6 >	mva_

edm::InputTag	srcElectrons

edm::Handle< TauCollection >	taus_

int	verbosity_

Additional Inherited Members
Public Types inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
typedef std::vector< TauType >	TauCollection

typedef edm::Ref< TauCollection >	TauRef

typedef edm::RefProd < TauCollection >	TauRefProd

Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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)

Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
std::string	moduleLabel_

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

size_t	tauIndex_

edm::InputTag	TauProducer_

Detailed Description

Definition at line 24 of file PATTauDiscriminationAgainstElectronMVA6.cc.

Constructor & Destructor Documentation

PATTauDiscriminationAgainstElectronMVA6::PATTauDiscriminationAgainstElectronMVA6 ( const edm::ParameterSet & cfg )

inlineexplicit

Definition at line 27 of file PATTauDiscriminationAgainstElectronMVA6.cc.

References looper::cfg, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), and PATTauDiscriminationAgainstElectronMVA6_cfi::srcElectrons.

     : PATTauDiscriminationProducerBase(cfg),
       mva_(),
       category_output_()
   {
     mva_ = std::make_unique<AntiElectronIDMVA6>(cfg);
 
     srcElectrons = cfg.getParameter<edm::InputTag>("srcElectrons");
     electronToken = consumes<pat::ElectronCollection>(srcElectrons);
     verbosity_ = ( cfg.exists("verbosity") ) ?
       cfg.getParameter<int>("verbosity") : 0;
 
     // add category index
     produces<PATTauDiscriminator>("category");
   }

PATTauDiscriminationAgainstElectronMVA6::~PATTauDiscriminationAgainstElectronMVA6 ( )

inline

Definition at line 49 of file PATTauDiscriminationAgainstElectronMVA6.cc.

49 {}

Member Function Documentation

void PATTauDiscriminationAgainstElectronMVA6::beginEvent	(	const edm::Event &	evt,
		const edm::EventSetup &	es
	)

virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 67 of file PATTauDiscriminationAgainstElectronMVA6.cc.

References edm::Event::getByToken().

 {
   mva_->beginEvent(evt, es);
 
   evt.getByToken(Tau_token, taus_);
   category_output_.reset(new PATTauDiscriminator(TauRefProd(taus_)));
 
   evt.getByToken(electronToken, Electrons);
 }

double PATTauDiscriminationAgainstElectronMVA6::discriminate ( const TauRef & theTauRef ) const

virtual

Implements TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 77 of file PATTauDiscriminationAgainstElectronMVA6.cc.

References funct::abs(), edm::PtrVector< T >::begin(), python.rootplot.argparse::category, compareJSON::const, deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, edm::PtrVector< T >::end(), edm::Ref< C, T, F >::get(), pat::Electron::gsfTrack(), edm::Ref< C, T, F >::isNonnull(), bookConverter::max, min(), reco::GsfElectron::p4(), pat::PackedCandidate::pdgId(), and reco::LeafCandidate::pt().

 {
   double mvaValue = 1.;
   double category = -1.;
   bool isGsfElectronMatched = false;
   float deltaRDummy = 9.9;
   const float ECALBarrelEndcapEtaBorder = 1.479;
   float tauEtaAtEcalEntrance = theTauRef->etaAtEcalEntrance();  
   float leadChargedPFCandEtaAtEcalEntrance = theTauRef->etaAtEcalEntranceLeadChargedCand();
       
   if( (*theTauRef).leadChargedHadrCand().isNonnull()) {
     int numSignalPFGammaCandsInSigCone = 0;
     const reco::CandidatePtrVector signalGammaCands = theTauRef->signalGammaCands();
     for( reco::CandidatePtrVector::const_iterator gamma = signalGammaCands.begin(); gamma != signalGammaCands.end(); ++gamma ){
       double dR = deltaR((*gamma)->p4(), theTauRef->leadChargedHadrCand()->p4());
       double signalrad = std::max(0.05, std::min(0.10, 3.0/std::max(1.0, theTauRef->pt())));      
       // gammas inside the tau signal cone
       if (dR < signalrad) {
         numSignalPFGammaCandsInSigCone += 1;
       }
     }
     // loop over the electrons
     for( unsigned int ie = 0; ie < Electrons->size(); ++ie ){
       const pat::Electron& theElectron = Electrons->at(ie);
       if ( theElectron.pt() > 10. ) { // CV: only take electrons above some minimal energy/Pt into account...   
     double deltaREleTau = deltaR(theElectron.p4(), theTauRef->p4());
     deltaRDummy = deltaREleTau;
     if( deltaREleTau < 0.3 ){   
       double mva_match = mva_->MVAValue(*theTauRef, theElectron);     
       bool hasGsfTrack = 0;
           pat::PackedCandidate const* packedLeadTauCand = dynamic_cast<pat::PackedCandidate const*>(theTauRef->leadChargedHadrCand().get());
           if( abs(packedLeadTauCand->pdgId()) == 11 ) 
         hasGsfTrack = 1;
       if ( !hasGsfTrack )
             hasGsfTrack = theElectron.gsfTrack().isNonnull();
 
       // veto taus that go to Ecal crack
       if ( isInEcalCrack(tauEtaAtEcalEntrance) || isInEcalCrack(leadChargedPFCandEtaAtEcalEntrance) ) {
         // add category index
         category_output_->setValue(tauIndex_, category);
         // return MVA output value
         return -99;
       }
       // Veto taus that go to Ecal crack
       if( std::abs(tauEtaAtEcalEntrance) < ECALBarrelEndcapEtaBorder ){ // Barrel
         if( numSignalPFGammaCandsInSigCone == 0 && hasGsfTrack ){
           category = 5.;
         }
         else if ( numSignalPFGammaCandsInSigCone >= 1 && hasGsfTrack ) {
           category = 7.;
         }
       } else { // Endcap
         if ( numSignalPFGammaCandsInSigCone == 0 && hasGsfTrack ) {
           category = 13.;
         }
         else if ( numSignalPFGammaCandsInSigCone >= 1 && hasGsfTrack ) {
           category = 15.;
         }
       }
       mvaValue = std::min(mvaValue, mva_match);
       isGsfElectronMatched = true;  
      } // deltaR < 0.3
        } // electron pt > 10
      } // end of loop over electrons
 
     if ( !isGsfElectronMatched ) {
       mvaValue = mva_->MVAValue(*theTauRef);
       bool hasGsfTrack = 0;
       pat::PackedCandidate const* packedLeadTauCand = dynamic_cast<pat::PackedCandidate const*>(theTauRef->leadChargedHadrCand().get());
       if( abs(packedLeadTauCand->pdgId()) == 11 ) hasGsfTrack = 1;
           
       // veto taus that go to Ecal crack
       if ( isInEcalCrack(tauEtaAtEcalEntrance) || isInEcalCrack(leadChargedPFCandEtaAtEcalEntrance) ) {
     // add category index
     category_output_->setValue(tauIndex_, category);
     // return MVA output value
     return -99;
       }
       // veto taus that go to Ecal crack     
       if( std::abs(tauEtaAtEcalEntrance) < ECALBarrelEndcapEtaBorder ){ // Barrel
     if( numSignalPFGammaCandsInSigCone == 0 && !hasGsfTrack ){
       category = 0.;
     }
     else if ( numSignalPFGammaCandsInSigCone >= 1 && !hasGsfTrack ) {
       category = 2.;
     }
       } else { // Endcap
     if ( numSignalPFGammaCandsInSigCone == 0 && !hasGsfTrack ) {
       category = 8.;
     }
     else if ( numSignalPFGammaCandsInSigCone >= 1 && !hasGsfTrack ) {
       category = 10.;
     }
       }
     }
   }
   if ( verbosity_ ) {
     edm::LogPrint("PATTauAgainstEleMVA6") << "<PATTauDiscriminationAgainstElectronMVA6::discriminate>:" ;
     edm::LogPrint("PATTauAgainstEleMVA6") << " tau: Pt = " << theTauRef->pt() << ", eta = " << theTauRef->eta() << ", phi = " << theTauRef->phi();
     edm::LogPrint("PATTauAgainstEleMVA6") << " deltaREleTau = " << deltaRDummy << ", isGsfElectronMatched = " << isGsfElectronMatched;
     edm::LogPrint("PATTauAgainstEleMVA6") << " #Prongs = " << theTauRef->signalChargedHadrCands().size();
     edm::LogPrint("PATTauAgainstEleMVA6") << " MVA = " << mvaValue << ", category = " << category;
   }
   // add category index
   category_output_->setValue(tauIndex_, category);
   // return MVA output value
   return mvaValue;
 }

void PATTauDiscriminationAgainstElectronMVA6::endEvent ( edm::Event & evt )

virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 186 of file PATTauDiscriminationAgainstElectronMVA6.cc.

References eostools::move(), and edm::Event::put().

 {
   // add all category indices to event
   evt.put(std::move(category_output_), "category");
 }

bool PATTauDiscriminationAgainstElectronMVA6::isInEcalCrack ( double eta ) const

private

Definition at line 193 of file PATTauDiscriminationAgainstElectronMVA6.cc.

 {
   double absEta = fabs(eta);
   return (absEta > 1.460 && absEta < 1.558);
 }

Member Data Documentation

std::unique_ptr<PATTauDiscriminator> PATTauDiscriminationAgainstElectronMVA6::category_output_

private

Definition at line 62 of file PATTauDiscriminationAgainstElectronMVA6.cc.

edm::Handle<pat::ElectronCollection> PATTauDiscriminationAgainstElectronMVA6::Electrons

private

Definition at line 59 of file PATTauDiscriminationAgainstElectronMVA6.cc.

edm::EDGetTokenT<pat::ElectronCollection> PATTauDiscriminationAgainstElectronMVA6::electronToken

private

Definition at line 58 of file PATTauDiscriminationAgainstElectronMVA6.cc.

std::string PATTauDiscriminationAgainstElectronMVA6::moduleLabel_

private

Definition at line 54 of file PATTauDiscriminationAgainstElectronMVA6.cc.

Referenced by Mixins._TypedParameterizable::insertInto(), Modules.ESSource::nameInProcessDesc_(), and Modules.ESProducer::nameInProcessDesc_().

std::unique_ptr<AntiElectronIDMVA6> PATTauDiscriminationAgainstElectronMVA6::mva_

private

Definition at line 55 of file PATTauDiscriminationAgainstElectronMVA6.cc.

edm::InputTag PATTauDiscriminationAgainstElectronMVA6::srcElectrons

private

Definition at line 57 of file PATTauDiscriminationAgainstElectronMVA6.cc.

edm::Handle<TauCollection> PATTauDiscriminationAgainstElectronMVA6::taus_

private

Definition at line 60 of file PATTauDiscriminationAgainstElectronMVA6.cc.

int PATTauDiscriminationAgainstElectronMVA6::verbosity_

private

Definition at line 64 of file PATTauDiscriminationAgainstElectronMVA6.cc.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation