Inheritance diagram for reco::tau::PATTauDiscriminationByMVAIsolationRun2:

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

reco::SingleTauDiscriminatorContainer	discriminate (const TauRef &) const override

	PATTauDiscriminationByMVAIsolationRun2 (const edm::ParameterSet &cfg)

	~PATTauDiscriminationByMVAIsolationRun2 () override

Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
virtual void	endEvent (edm::Event &)

void	produce (edm::Event &, const edm::EventSetup &) override

	TauDiscriminationProducerBase ()

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	~TauDiscriminationProducerBase () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
static void	fillProducerDescriptions (edm::ParameterSetDescription &desc)

static std::string	getTauTypeString ()
	helper method to retrieve tau type name, e.g. to build correct cfi getter More...

Private Attributes
std::string	chargedIsoPtSums_

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, TauDiscriminatorDataType, ConsumeType >
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, TauDiscriminatorDataType, ConsumeType >
std::string	moduleLabel_

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

size_t	tauIndex_

edm::InputTag	TauProducer_

Detailed Description

Definition at line 79 of file PATTauDiscriminationByMVAIsolationRun2.cc.

Constructor & Destructor Documentation

◆ PATTauDiscriminationByMVAIsolationRun2()

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

inlineexplicit

Definition at line 81 of file PATTauDiscriminationByMVAIsolationRun2.cc.

           : PATTauDiscriminationContainerProducerBase(cfg),
             moduleLabel_(cfg.getParameter<std::string>("@module_label")),
             mvaReader_(nullptr),
             mvaInput_(nullptr) {
         mvaName_ = cfg.getParameter<std::string>("mvaName");
         loadMVAfromDB_ = cfg.getParameter<bool>("loadMVAfromDB");
         if (!loadMVAfromDB_) {
           inputFileName_ = cfg.getParameter<edm::FileInPath>("inputFileName");
         }
         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.getParameter<int>("verbosity");
       }

References cms::cuda::assert(), looper::cfg, Exception, reco::tau::kDBnewDMwLT, reco::tau::kDBnewDMwLTwGJ, reco::tau::kDBoldDMwLT, reco::tau::kDBoldDMwLTwGJ, reco::tau::kNewDMwLT, reco::tau::kNewDMwoLT, reco::tau::kOldDMwLT, reco::tau::kOldDMwoLT, reco::tau::kPWnewDMwLT, reco::tau::kPWoldDMwLT, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~PATTauDiscriminationByMVAIsolationRun2()

reco::tau::PATTauDiscriminationByMVAIsolationRun2::~PATTauDiscriminationByMVAIsolationRun2 ( )

inlineoverride

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

◆ beginEvent()

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

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >.

Definition at line 172 of file PATTauDiscriminationByMVAIsolationRun2.cc.

                                                                                                         {
       if (!mvaReader_) {
         if (loadMVAfromDB_) {
           mvaReader_ = loadMVAfromDB(es, mvaName_);
         } else {
           mvaReader_ = loadMVAfromFile(inputFileName_, mvaName_, inputFilesToDelete_);
         }
       }
  
       evt.getByToken(Tau_token, taus_);
     }

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

◆ discriminate()

reco::SingleTauDiscriminatorContainer reco::tau::PATTauDiscriminationByMVAIsolationRun2::discriminate ( const TauRef & tau ) const

overridevirtual

Implements TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >.

Definition at line 184 of file PATTauDiscriminationByMVAIsolationRun2.cc.

                                                                                                                     {
       // CV: define dummy category index in order to use RecoTauDiscriminantCutMultiplexer module to appy WP cuts
       reco::SingleTauDiscriminatorContainer result;
       result.rawValues = {-1.};
  
       // CV: computation of MVA value requires presence of leading charged hadron
       if (tau->leadChargedHadrCand().isNull()) {
         result.rawValues.at(0) = 0.;
         return result;
       }
  
       if (reco::tau::fillIsoMVARun2Inputs(mvaInput_,
                                           *tau,
                                           mvaOpt_,
                                           chargedIsoPtSums_,
                                           neutralIsoPtSums_,
                                           puCorrPtSums_,
                                           photonPtSumOutsideSignalCone_,
                                           footprintCorrection_)) {
         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 = " << tau->tauID(chargedIsoPtSums_)
               << ", neutral = " << tau->tauID(neutralIsoPtSums_) << ", PUcorr = " << tau->tauID(puCorrPtSums_);
           edm::LogPrint("PATTauDiscByMVAIsolRun2") << " decay mode = " << tau->decayMode();
           edm::LogPrint("PATTauDiscByMVAIsolRun2")
               << " impact parameter: distance = " << tau->dxy() << ", significance = " << tau->dxy_Sig();
           edm::LogPrint("PATTauDiscByMVAIsolRun2") << " has decay vertex = " << tau->hasSecondaryVertex() << ":"
                                                    << ", significance = " << tau->flightLengthSig();
           edm::LogPrint("PATTauDiscByMVAIsolRun2") << "--> mvaValue = " << mvaValue;
         }
         result.rawValues.at(0) = mvaValue;
       }
       return result;
     }

References reco::tau::fillIsoMVARun2Inputs(), mps_fire::result, and metsig::tau.

◆ fillDescriptions()

void reco::tau::PATTauDiscriminationByMVAIsolationRun2::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 222 of file PATTauDiscriminationByMVAIsolationRun2.cc.

                                                                                                             {
       // patTauDiscriminationByMVAIsolationRun2
       edm::ParameterSetDescription desc;
  
       desc.add<std::string>("mvaName");
       desc.add<bool>("loadMVAfromDB");
       desc.addOptional<edm::FileInPath>("inputFileName");
       desc.add<std::string>("mvaOpt");
  
       desc.add<std::string>("srcChargedIsoPtSum");
       desc.add<std::string>("srcNeutralIsoPtSum");
       desc.add<std::string>("srcPUcorrPtSum");
       desc.add<std::string>("srcPhotonPtSumOutsideSignalCone");
       desc.add<std::string>("srcFootprintCorrection");
       desc.add<int>("verbosity", 0);
  
       fillProducerDescriptions(desc);  // inherited from the base
  
       descriptions.add("patTauDiscriminationByMVAIsolationRun2", desc);
     }