Inheritance diagram for PATTauDiscriminationByMVAIsolationRun2:

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

double	discriminate (const TauRef &) const

void	endEvent (edm::Event &)

	PATTauDiscriminationByMVAIsolationRun2 (const edm::ParameterSet &cfg)

	~PATTauDiscriminationByMVAIsolationRun2 ()

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

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

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

virtual	~EDConsumerBase () noexcept(false)

Private Types
enum	{ kOldDMwoLT, kOldDMwLT, kNewDMwoLT, kNewDMwLT, kDBoldDMwLT, kDBnewDMwLT, kPWoldDMwLT, kPWnewDMwLT, kDBoldDMwLTwGJ, kDBnewDMwLTwGJ }

Private Attributes
std::unique_ptr< pat::PATTauDiscriminator >	category_output_

std::string	chargedIsoPtSums_

TauIdMVAAuxiliaries	clusterVariables_

std::string	footprintCorrection_

edm::FileInPath	inputFileName_

std::vector< TFile * >	inputFilesToDelete_

bool	loadMVAfromDB_

std::string	moduleLabel_

float *	mvaInput_

std::string	mvaName_

int	mvaOpt_

const GBRForest *	mvaReader_

std::string	neutralIsoPtSums_

std::string	photonPtSumOutsideSignalCone_

std::string	puCorrPtSums_

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 72 of file PATTauDiscriminationByMVAIsolationRun2.cc.

Member Enumeration Documentation

anonymous enum

private

Enumerator
kOldDMwoLT
kOldDMwLT
kNewDMwoLT
kNewDMwLT
kDBoldDMwLT
kDBnewDMwLT
kPWoldDMwLT
kPWnewDMwLT
kDBoldDMwLTwGJ
kDBnewDMwLTwGJ

Definition at line 146 of file PATTauDiscriminationByMVAIsolationRun2.cc.

146 { kOldDMwoLT, kOldDMwLT, kNewDMwoLT, kNewDMwLT, kDBoldDMwLT, kDBnewDMwLT, kPWoldDMwLT, kPWnewDMwLT, kDBoldDMwLTwGJ, kDBnewDMwLTwGJ };

PATTauDiscriminationByMVAIsolationRun2::kNewDMwLT

Definition: PATTauDiscriminationByMVAIsolationRun2.cc:146

PATTauDiscriminationByMVAIsolationRun2::kOldDMwoLT

Definition: PATTauDiscriminationByMVAIsolationRun2.cc:146

PATTauDiscriminationByMVAIsolationRun2::kDBnewDMwLTwGJ

Definition: PATTauDiscriminationByMVAIsolationRun2.cc:146

PATTauDiscriminationByMVAIsolationRun2::kDBoldDMwLTwGJ

Definition: PATTauDiscriminationByMVAIsolationRun2.cc:146

PATTauDiscriminationByMVAIsolationRun2::kNewDMwoLT

Definition: PATTauDiscriminationByMVAIsolationRun2.cc:146

PATTauDiscriminationByMVAIsolationRun2::kOldDMwLT

Definition: PATTauDiscriminationByMVAIsolationRun2.cc:146

PATTauDiscriminationByMVAIsolationRun2::kPWnewDMwLT

Definition: PATTauDiscriminationByMVAIsolationRun2.cc:146

PATTauDiscriminationByMVAIsolationRun2::kDBoldDMwLT

Definition: PATTauDiscriminationByMVAIsolationRun2.cc:146

PATTauDiscriminationByMVAIsolationRun2::kPWoldDMwLT

Definition: PATTauDiscriminationByMVAIsolationRun2.cc:146

PATTauDiscriminationByMVAIsolationRun2::kDBnewDMwLT

Definition: PATTauDiscriminationByMVAIsolationRun2.cc:146

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 75 of file PATTauDiscriminationByMVAIsolationRun2.cc.

References Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

       : PATTauDiscriminationProducerBase(cfg),
         moduleLabel_(cfg.getParameter<std::string>("@module_label")),
     mvaReader_(0),
     mvaInput_(0),
     category_output_()
     {
        mvaName_ = cfg.getParameter<std::string>("mvaName");
        loadMVAfromDB_ = cfg.exists("loadMVAfromDB") ? cfg.getParameter<bool>("loadMVAfromDB") : false;
        if ( !loadMVAfromDB_ ) {
          if(cfg.exists("inputFileName")){
        inputFileName_ = cfg.getParameter<edm::FileInPath>("inputFileName");
      }else throw cms::Exception("MVA input not defined") << "Requested to load tau MVA input from ROOT file but no file provided in cfg file";
        }    
        std::string mvaOpt_string = cfg.getParameter<std::string>("mvaOpt");
        if      ( mvaOpt_string == "oldDMwoLT" ) mvaOpt_ = kOldDMwoLT;
        else if ( mvaOpt_string == "oldDMwLT"  ) mvaOpt_ = kOldDMwLT;
        else if ( mvaOpt_string == "newDMwoLT" ) mvaOpt_ = kNewDMwoLT;
        else if ( mvaOpt_string == "newDMwLT"  ) mvaOpt_ = kNewDMwLT;
        else if ( mvaOpt_string == "DBoldDMwLT"  ) mvaOpt_ = kDBoldDMwLT;
        else if ( mvaOpt_string == "DBnewDMwLT"  ) mvaOpt_ = kDBnewDMwLT;
        else if ( mvaOpt_string == "PWoldDMwLT"  ) mvaOpt_ = kPWoldDMwLT;
        else if ( mvaOpt_string == "PWnewDMwLT"  ) mvaOpt_ = kPWnewDMwLT;
        else if ( mvaOpt_string == "DBoldDMwLTwGJ" ) mvaOpt_ = kDBoldDMwLTwGJ;
        else if ( mvaOpt_string == "DBnewDMwLTwGJ" ) mvaOpt_ = kDBnewDMwLTwGJ;
        else throw cms::Exception("PATTauDiscriminationByMVAIsolationRun2")
          << " Invalid Configuration Parameter 'mvaOpt' = " << mvaOpt_string << " !!\n";
             
        if      ( mvaOpt_ == kOldDMwoLT || mvaOpt_ == kNewDMwoLT ) mvaInput_ = new float[6];
        else if ( mvaOpt_ == kOldDMwLT  || mvaOpt_ == kNewDMwLT  ) mvaInput_ = new float[12];
        else if ( mvaOpt_ == kDBoldDMwLT || mvaOpt_ == kDBnewDMwLT ||
                  mvaOpt_ == kPWoldDMwLT || mvaOpt_ == kPWnewDMwLT ||
                  mvaOpt_ == kDBoldDMwLTwGJ || mvaOpt_ == kDBnewDMwLTwGJ) mvaInput_ = new float[23];
        else assert(0);
 
        chargedIsoPtSums_ = cfg.getParameter<std::string>("srcChargedIsoPtSum");
        neutralIsoPtSums_ = cfg.getParameter<std::string>("srcNeutralIsoPtSum");
        puCorrPtSums_ = cfg.getParameter<std::string>("srcPUcorrPtSum");
        photonPtSumOutsideSignalCone_ = cfg.getParameter<std::string>("srcPhotonPtSumOutsideSignalCone");
        footprintCorrection_ = cfg.getParameter<std::string>("srcFootprintCorrection");
           
        verbosity_ = ( cfg.exists("verbosity") ) ?
          cfg.getParameter<int>("verbosity") : 0;
 
        produces<pat::PATTauDiscriminator>("category");
     }  

PATTauDiscriminationByMVAIsolationRun2::~PATTauDiscriminationByMVAIsolationRun2 ( )

inline

Definition at line 128 of file PATTauDiscriminationByMVAIsolationRun2.cc.

     {
       if(!loadMVAfromDB_) delete mvaReader_;
       delete[] mvaInput_;
       for ( std::vector<TFile*>::iterator it = inputFilesToDelete_.begin();
         it != inputFilesToDelete_.end(); ++it ) {
         delete (*it);
       }
     }

Member Function Documentation

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

virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 164 of file PATTauDiscriminationByMVAIsolationRun2.cc.

References edm::Event::getByToken(), and mitigatedMETSequence_cff::loadMVAfromDB.

 {
   if( !mvaReader_ ) {
     if ( loadMVAfromDB_ ) {
       mvaReader_ = loadMVAfromDB(es, mvaName_);
     } else {
       mvaReader_ = loadMVAfromFile(inputFileName_, mvaName_, inputFilesToDelete_);
     }
   }
     
   evt.getByToken(Tau_token, taus_);
   category_output_.reset(new pat::PATTauDiscriminator(TauRefProd(taus_)));
 }

double PATTauDiscriminationByMVAIsolationRun2::discriminate ( const TauRef & tau ) const

virtual

Implements TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 178 of file PATTauDiscriminationByMVAIsolationRun2.cc.

References funct::abs(), python.rootplot.argparse::category, tauProducer_cfi::chargedIsoPtSum, MillePedeFileConverter_cfg::e, f, objects.autophobj::float, tauProducer_cfi::footprintCorrection, edm::Ref< C, T, F >::isNull(), cmsBatch::log, hpstanc_transforms::max, min(), tauProducer_cfi::neutralIsoPtSum, tauProducer_cfi::photonPtSumOutsideSignalCone, funct::pow(), tauProducer_cfi::puCorrPtSum, and mathSSE::sqrt().

 {
   // CV: define dummy category index in order to use RecoTauDiscriminantCutMultiplexer module to appy WP cuts
   double category = 0.; 
   category_output_->setValue(tauIndex_, category);
     
   // CV: computation of MVA value requires presence of leading charged hadron
   if ( tau->leadChargedHadrCand().isNull() ) return 0.;
     
   int tauDecayMode = tau->decayMode();
     
   if ( ((mvaOpt_ == kOldDMwoLT || mvaOpt_ == kOldDMwLT || mvaOpt_ == kDBoldDMwLT || mvaOpt_ == kPWoldDMwLT || mvaOpt_ == kDBoldDMwLTwGJ)
         && (tauDecayMode == 0 || tauDecayMode == 1 || tauDecayMode == 2 || tauDecayMode == 10))
        ||
        ((mvaOpt_ == kNewDMwoLT || mvaOpt_ == kNewDMwLT || mvaOpt_ == kDBnewDMwLT || mvaOpt_ == kPWnewDMwLT || mvaOpt_ == kDBnewDMwLTwGJ)
         && (tauDecayMode == 0 || tauDecayMode == 1 || tauDecayMode == 2 || tauDecayMode == 5 || tauDecayMode == 6 || tauDecayMode == 10 || tauDecayMode == 11))
   ) {
     
     float chargedIsoPtSum = tau->tauID(chargedIsoPtSums_);
     float neutralIsoPtSum = tau->tauID(neutralIsoPtSums_);
     float puCorrPtSum     = tau->tauID(puCorrPtSums_);
     float photonPtSumOutsideSignalCone = tau->tauID(photonPtSumOutsideSignalCone_);
     float footprintCorrection = tau->tauID(footprintCorrection_);
         
     float decayDistX = tau->flightLength().x();
     float decayDistY = tau->flightLength().y();
     float decayDistZ = tau->flightLength().z();
     float decayDistMag = std::sqrt(decayDistX*decayDistX + decayDistY*decayDistY + decayDistZ*decayDistZ);
         
     // --- The following 5 variables differ slightly between AOD & MiniAOD
     //     because they are recomputed using packedCandidates saved in the tau
     float nPhoton = (float)clusterVariables_.tau_n_photons_total(*tau);
     float ptWeightedDetaStrip = clusterVariables_.tau_pt_weighted_deta_strip(*tau, tauDecayMode);
     float ptWeightedDphiStrip = clusterVariables_.tau_pt_weighted_dphi_strip(*tau, tauDecayMode);
     float ptWeightedDrSignal = clusterVariables_.tau_pt_weighted_dr_signal(*tau, tauDecayMode);
     float ptWeightedDrIsolation = clusterVariables_.tau_pt_weighted_dr_iso(*tau, tauDecayMode);
     // ---
     float leadingTrackChi2 = tau->leadingTrackNormChi2();
     float eRatio = clusterVariables_.tau_Eratio(*tau);
 
     // Difference between measured and maximally allowed Gottfried-Jackson angle
     float gjAngleDiff = -999;
     if ( tauDecayMode == 10 ) {
         double mTau = 1.77682;
         double mAOne = tau->p4().M();
         double pAOneMag = tau->p();
         double argumentThetaGJmax = (std::pow(mTau,2) - std::pow(mAOne,2) ) / ( 2 * mTau * pAOneMag );
         double argumentThetaGJmeasured = ( tau->p4().px() * decayDistX + tau->p4().py() * decayDistY + tau->p4().pz() * decayDistZ ) / ( pAOneMag * decayDistMag );
         if ( std::abs(argumentThetaGJmax) <= 1. && std::abs(argumentThetaGJmeasured) <= 1. ) {
             double thetaGJmax = std::asin( argumentThetaGJmax );
             double thetaGJmeasured = std::acos( argumentThetaGJmeasured );
             gjAngleDiff = thetaGJmeasured - thetaGJmax;
         }
     }
         
     if ( mvaOpt_ == kOldDMwoLT || mvaOpt_ == kNewDMwoLT ) {
       mvaInput_[0]  = std::log(std::max(1.f, (float)tau->pt()));
       mvaInput_[1]  = std::abs((float)tau->eta());
       mvaInput_[2]  = std::log(std::max(1.e-2f, chargedIsoPtSum));
       mvaInput_[3]  = std::log(std::max(1.e-2f, neutralIsoPtSum - 0.125f*puCorrPtSum));
       mvaInput_[4]  = std::log(std::max(1.e-2f, puCorrPtSum));
       mvaInput_[5]  = tauDecayMode;
     } else if ( mvaOpt_ == kOldDMwLT || mvaOpt_ == kNewDMwLT  ) {
       mvaInput_[0]  = std::log(std::max(1.f, (float)tau->pt()));
       mvaInput_[1]  = std::abs((float)tau->eta());
       mvaInput_[2]  = std::log(std::max(1.e-2f, chargedIsoPtSum));
       mvaInput_[3]  = std::log(std::max(1.e-2f, neutralIsoPtSum - 0.125f*puCorrPtSum));
       mvaInput_[4]  = std::log(std::max(1.e-2f, puCorrPtSum));
       mvaInput_[5]  = tauDecayMode;
       mvaInput_[6]  = std::copysign(+1.f, tau->dxy());
       mvaInput_[7]  = std::sqrt(std::min(1.f, std::abs(tau->dxy())));
       mvaInput_[8]  = std::min(10.f, std::abs(tau->dxy_Sig()));
       mvaInput_[9]  = ( tau->hasSecondaryVertex() ) ? 1. : 0.;
       mvaInput_[10] = std::sqrt(decayDistMag);
       mvaInput_[11] = std::min(10.f, tau->flightLengthSig());
     } else if ( mvaOpt_ == kDBoldDMwLT || mvaOpt_ == kDBnewDMwLT ) {
       mvaInput_[0]  = std::log(std::max(1.f, (float)tau->pt()));
       mvaInput_[1]  = std::abs((float)tau->eta());
       mvaInput_[2]  = std::log(std::max(1.e-2f, chargedIsoPtSum));
       mvaInput_[3]  = std::log(std::max(1.e-2f, neutralIsoPtSum));
       mvaInput_[4]  = std::log(std::max(1.e-2f, puCorrPtSum));
       mvaInput_[5]  = std::log(std::max(1.e-2f, photonPtSumOutsideSignalCone));
       mvaInput_[6]  = tauDecayMode;
       mvaInput_[7]  = std::min(30.f, nPhoton);
       mvaInput_[8]  = std::min(0.5f, ptWeightedDetaStrip);
       mvaInput_[9]  = std::min(0.5f, ptWeightedDphiStrip);
       mvaInput_[10] = std::min(0.5f, ptWeightedDrSignal);
       mvaInput_[11] = std::min(0.5f, ptWeightedDrIsolation);
       mvaInput_[12] = std::min(100.f, leadingTrackChi2);
       mvaInput_[13] = std::min(1.f, eRatio);
       mvaInput_[14]  = std::copysign(+1.f, tau->dxy());
       mvaInput_[15]  = std::sqrt(std::min(1.f, std::abs(tau->dxy())));
       mvaInput_[16]  = std::min(10.f, std::abs(tau->dxy_Sig()));
       mvaInput_[17]  = std::copysign(+1.f, tau->ip3d());
       mvaInput_[18]  = std::sqrt(std::min(1.f, std::abs(tau->ip3d())));
       mvaInput_[19]  = std::min(10.f, std::abs(tau->ip3d_Sig()));
       mvaInput_[20]  = ( tau->hasSecondaryVertex() ) ? 1. : 0.;
       mvaInput_[21] = std::sqrt(decayDistMag);
       mvaInput_[22] = std::min(10.f, tau->flightLengthSig());
     } else if ( mvaOpt_ == kPWoldDMwLT || mvaOpt_ == kPWnewDMwLT ) {
       mvaInput_[0]  = std::log(std::max(1.f, (float)tau->pt()));
       mvaInput_[1]  = std::abs((float)tau->eta());
       mvaInput_[2]  = std::log(std::max(1.e-2f, chargedIsoPtSum));
       mvaInput_[3]  = std::log(std::max(1.e-2f, neutralIsoPtSum));
       mvaInput_[4]  = std::log(std::max(1.e-2f, footprintCorrection));
       mvaInput_[5]  = std::log(std::max(1.e-2f, photonPtSumOutsideSignalCone));
       mvaInput_[6]  = tauDecayMode;
       mvaInput_[7]  = std::min(30.f, nPhoton);
       mvaInput_[8]  = std::min(0.5f, ptWeightedDetaStrip);
       mvaInput_[9]  = std::min(0.5f, ptWeightedDphiStrip);
       mvaInput_[10] = std::min(0.5f, ptWeightedDrSignal);
       mvaInput_[11] = std::min(0.5f, ptWeightedDrIsolation);
       mvaInput_[12] = std::min(100.f, leadingTrackChi2);
       mvaInput_[13] = std::min(1.f, eRatio);
       mvaInput_[14]  = std::copysign(+1.f, tau->dxy());
       mvaInput_[15]  = std::sqrt(std::min(1.f, std::abs(tau->dxy())));
       mvaInput_[16]  = std::min(10.f, std::abs(tau->dxy_Sig()));
       mvaInput_[17]  = std::copysign(+1.f, tau->ip3d());
       mvaInput_[18]  = std::sqrt(std::min(1.f, std::abs(tau->ip3d())));
       mvaInput_[19]  = std::min(10.f, std::abs(tau->ip3d_Sig()));
       mvaInput_[20]  = ( tau->hasSecondaryVertex() ) ? 1. : 0.;
       mvaInput_[21] = std::sqrt(decayDistMag);
       mvaInput_[22] = std::min(10.f, tau->flightLengthSig());
     } else if ( mvaOpt_ == kDBoldDMwLTwGJ || mvaOpt_ == kDBnewDMwLTwGJ ) {
       mvaInput_[0]  = std::log(std::max(1.f, (float)tau->pt()));
       mvaInput_[1]  = std::abs((float)tau->eta());
       mvaInput_[2]  = std::log(std::max(1.e-2f, chargedIsoPtSum));
       mvaInput_[3]  = std::log(std::max(1.e-2f, neutralIsoPtSum));
       mvaInput_[4]  = std::log(std::max(1.e-2f, puCorrPtSum));
       mvaInput_[5]  = std::log(std::max(1.e-2f, photonPtSumOutsideSignalCone));
       mvaInput_[6]  = tauDecayMode;
       mvaInput_[7]  = std::min(30.f, nPhoton);
       mvaInput_[8]  = std::min(0.5f, ptWeightedDetaStrip);
       mvaInput_[9]  = std::min(0.5f, ptWeightedDphiStrip);
       mvaInput_[10] = std::min(0.5f, ptWeightedDrSignal);
       mvaInput_[11] = std::min(0.5f, ptWeightedDrIsolation);
       mvaInput_[12] = std::min(1.f, eRatio);
       mvaInput_[13]  = std::copysign(+1.f, tau->dxy());
       mvaInput_[14]  = std::sqrt(std::min(1.f, std::abs(tau->dxy())));
       mvaInput_[15]  = std::min(10.f, std::abs(tau->dxy_Sig()));
       mvaInput_[16]  = std::copysign(+1.f, tau->ip3d());
       mvaInput_[17]  = std::sqrt(std::min(1.f, std::abs(tau->ip3d())));
       mvaInput_[18]  = std::min(10.f, std::abs(tau->ip3d_Sig()));
       mvaInput_[19]  = ( tau->hasSecondaryVertex() ) ? 1. : 0.;
       mvaInput_[20] = std::sqrt(decayDistMag);
       mvaInput_[21] = std::min(10.f, tau->flightLengthSig());
       mvaInput_[22] = std::max(-1.f, gjAngleDiff);
     }
         
     double mvaValue = mvaReader_->GetClassifier(mvaInput_);
     if ( verbosity_ ) {
       edm::LogPrint("PATTauDiscByMVAIsolRun2") << "<PATTauDiscriminationByMVAIsolationRun2::discriminate>:";
       edm::LogPrint("PATTauDiscByMVAIsolRun2") << " tau: Pt = " << tau->pt() << ", eta = " << tau->eta();
       edm::LogPrint("PATTauDiscByMVAIsolRun2") << " isolation: charged = " << chargedIsoPtSum << ", neutral = " << neutralIsoPtSum << ", PUcorr = " << puCorrPtSum;
       edm::LogPrint("PATTauDiscByMVAIsolRun2") << " decay mode = " << tauDecayMode;
       edm::LogPrint("PATTauDiscByMVAIsolRun2") << " impact parameter: distance = " << tau->dxy() << ", significance = " << tau->dxy_Sig();
       edm::LogPrint("PATTauDiscByMVAIsolRun2") << " has decay vertex = " << tau->hasSecondaryVertex() << ":"
                                                << " distance = " << decayDistMag << ", significance = " << tau->flightLengthSig();
       edm::LogPrint("PATTauDiscByMVAIsolRun2") << "--> mvaValue = " << mvaValue;
     }
     return mvaValue;
   } else {
     return -1.;
   }
 }

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

virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 344 of file PATTauDiscriminationByMVAIsolationRun2.cc.

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

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

Member Data Documentation

std::unique_ptr<pat::PATTauDiscriminator> PATTauDiscriminationByMVAIsolationRun2::category_output_

private

Definition at line 157 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::chargedIsoPtSums_

private

Definition at line 150 of file PATTauDiscriminationByMVAIsolationRun2.cc.

TauIdMVAAuxiliaries PATTauDiscriminationByMVAIsolationRun2::clusterVariables_

private

Definition at line 159 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::footprintCorrection_

private

Definition at line 154 of file PATTauDiscriminationByMVAIsolationRun2.cc.

edm::FileInPath PATTauDiscriminationByMVAIsolationRun2::inputFileName_

private

Definition at line 144 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::vector<TFile*> PATTauDiscriminationByMVAIsolationRun2::inputFilesToDelete_

private

Definition at line 158 of file PATTauDiscriminationByMVAIsolationRun2.cc.

bool PATTauDiscriminationByMVAIsolationRun2::loadMVAfromDB_

private

Definition at line 143 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::moduleLabel_

private

Definition at line 140 of file PATTauDiscriminationByMVAIsolationRun2.cc.

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

float* PATTauDiscriminationByMVAIsolationRun2::mvaInput_

private

Definition at line 148 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::mvaName_

private

Definition at line 142 of file PATTauDiscriminationByMVAIsolationRun2.cc.

int PATTauDiscriminationByMVAIsolationRun2::mvaOpt_

private

Definition at line 147 of file PATTauDiscriminationByMVAIsolationRun2.cc.

const GBRForest* PATTauDiscriminationByMVAIsolationRun2::mvaReader_

private

Definition at line 145 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::neutralIsoPtSums_

private

Definition at line 151 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::photonPtSumOutsideSignalCone_

private

Definition at line 153 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::puCorrPtSums_

private

Definition at line 152 of file PATTauDiscriminationByMVAIsolationRun2.cc.

edm::Handle<TauCollection> PATTauDiscriminationByMVAIsolationRun2::taus_

private

Definition at line 156 of file PATTauDiscriminationByMVAIsolationRun2.cc.

int PATTauDiscriminationByMVAIsolationRun2::verbosity_

private

Definition at line 161 of file PATTauDiscriminationByMVAIsolationRun2.cc.

Public Member Functions

Private Types

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation