Inheritance diagram for PATTauDiscriminationAgainstElectronMVA6:

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

double	discriminate (const TauRef &) const override

void	endEvent (edm::Event &) override

	PATTauDiscriminationAgainstElectronMVA6 (const edm::ParameterSet &cfg)

	~PATTauDiscriminationAgainstElectronMVA6 () override

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

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	TauDiscriminationProducerBase ()

	~TauDiscriminationProducerBase () override

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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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_

bool	vetoEcalCracks_

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

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);
     vetoEcalCracks_ = cfg.getParameter<bool>("vetoEcalCracks");
     verbosity_ = ( cfg.exists("verbosity") ) ?
       cfg.getParameter<int>("verbosity") : 0;
 
     // add category index
     produces<PATTauDiscriminator>("category");
   }

PATTauDiscriminationAgainstElectronMVA6::~PATTauDiscriminationAgainstElectronMVA6 ( )

inlineoverride

Definition at line 50 of file PATTauDiscriminationAgainstElectronMVA6.cc.

50 {}

Member Function Documentation

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

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 70 of file PATTauDiscriminationAgainstElectronMVA6.cc.

References JetPlusTrackCorrections_cfi::Electrons, and 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

overridevirtual

Implements TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 80 of file PATTauDiscriminationAgainstElectronMVA6.cc.

References funct::abs(), taus_updatedMVAIds_cff::category, deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, JetPlusTrackCorrections_cfi::Electrons, CustomPhysics_cfi::gamma, edm::Ref< C, T, F >::get(), SiStripPI::max, min(), and pat::PackedCandidate::pdgId().

 {
   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 ( const auto & gamma : signalGammaCands ) {
       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 ( const auto & theElectron : *Electrons ) {
       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 = false;
           pat::PackedCandidate const* packedLeadTauCand = dynamic_cast<pat::PackedCandidate const*>(theTauRef->leadChargedHadrCand().get());
           if( abs(packedLeadTauCand->pdgId()) == 11 ) 
         hasGsfTrack = true;
       if ( !hasGsfTrack )
             hasGsfTrack = theElectron.gsfTrack().isNonnull();
 
       // veto taus that go to Ecal crack
       if ( vetoEcalCracks_ && (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 = false;
       pat::PackedCandidate const* packedLeadTauCand = dynamic_cast<pat::PackedCandidate const*>(theTauRef->leadChargedHadrCand().get());
       if( abs(packedLeadTauCand->pdgId()) == 11 ) hasGsfTrack = true;
           
       // veto taus that go to Ecal crack
       if (  vetoEcalCracks_ && (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 )

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 188 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 195 of file PATTauDiscriminationAgainstElectronMVA6.cc.

References DEFINE_FWK_MODULE.

 {
   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 63 of file PATTauDiscriminationAgainstElectronMVA6.cc.

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

private

Definition at line 60 of file PATTauDiscriminationAgainstElectronMVA6.cc.

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

private

Definition at line 59 of file PATTauDiscriminationAgainstElectronMVA6.cc.

std::string PATTauDiscriminationAgainstElectronMVA6::moduleLabel_

private

Definition at line 55 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 56 of file PATTauDiscriminationAgainstElectronMVA6.cc.

edm::InputTag PATTauDiscriminationAgainstElectronMVA6::srcElectrons

private

Definition at line 58 of file PATTauDiscriminationAgainstElectronMVA6.cc.

edm::Handle<TauCollection> PATTauDiscriminationAgainstElectronMVA6::taus_

private

Definition at line 61 of file PATTauDiscriminationAgainstElectronMVA6.cc.

int PATTauDiscriminationAgainstElectronMVA6::verbosity_

private

Definition at line 67 of file PATTauDiscriminationAgainstElectronMVA6.cc.

bool PATTauDiscriminationAgainstElectronMVA6::vetoEcalCracks_

private

Definition at line 65 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