Inheritance diagram for PFRecoTauDiscriminationByIsolationMVA2:

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

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

	PFRecoTauDiscriminationByIsolationMVA2 (const edm::ParameterSet &cfg)

	~PFRecoTauDiscriminationByIsolationMVA2 () override

Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
virtual TauDiscriminatorDataType	discriminate (const TauRef &tau) const =0

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 Types
enum	{ kOldDMwoLT, kOldDMwLT, kNewDMwoLT, kNewDMwLT }

typedef edm::AssociationVector< reco::PFTauRefProd, std::vector< reco::PFTauTransverseImpactParameterRef > >	PFTauTIPAssociationByRef

Private Attributes
edm::Handle< reco::TauDiscriminatorContainer >	basicTauDiscriminators_

edm::EDGetTokenT< reco::TauDiscriminatorContainer >	basicTauDiscriminators_token_

int	chargedIsoPtSum_index_

edm::FileInPath	inputFileName_

std::vector< TFile * >	inputFilesToDelete_

bool	loadMVAfromDB_

std::string	moduleLabel_

float *	mvaInput_

std::string	mvaName_

int	mvaOpt_

const GBRForest *	mvaReader_

int	neutralIsoPtSum_index_

int	pucorrPtSum_index_

edm::Handle< PFTauTIPAssociationByRef >	tauLifetimeInfos_

edm::Handle< TauCollection >	taus_

edm::EDGetTokenT< PFTauTIPAssociationByRef >	tauTransverseImpactParameters_token_

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 69 of file PFRecoTauDiscriminationByMVAIsolation2.cc.

Member Typedef Documentation

◆ PFTauTIPAssociationByRef

typedef edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::PFTauTransverseImpactParameterRef> > PFRecoTauDiscriminationByIsolationMVA2::PFTauTIPAssociationByRef

private

Definition at line 140 of file PFRecoTauDiscriminationByMVAIsolation2.cc.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
kOldDMwoLT
kOldDMwLT
kNewDMwoLT
kNewDMwLT

Definition at line 135 of file PFRecoTauDiscriminationByMVAIsolation2.cc.

135 { kOldDMwoLT, kOldDMwLT, kNewDMwoLT, kNewDMwLT };

Constructor & Destructor Documentation

◆ PFRecoTauDiscriminationByIsolationMVA2()

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

inlineexplicit

Definition at line 71 of file PFRecoTauDiscriminationByMVAIsolation2.cc.

       : PFTauDiscriminationContainerProducerBase(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
       throw cms::Exception("PFRecoTauDiscriminationByIsolationMVA2")
           << " 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
       assert(0);
  
     tauTransverseImpactParameters_token_ =
         consumes<PFTauTIPAssociationByRef>(cfg.getParameter<edm::InputTag>("srcTauTransverseImpactParameters"));
  
     basicTauDiscriminators_token_ =
         consumes<reco::TauDiscriminatorContainer>(cfg.getParameter<edm::InputTag>("srcBasicTauDiscriminators"));
     chargedIsoPtSum_index_ = cfg.getParameter<int>("srcChargedIsoPtSumIndex");
     neutralIsoPtSum_index_ = cfg.getParameter<int>("srcNeutralIsoPtSumIndex");
     pucorrPtSum_index_ = cfg.getParameter<int>("srcPUcorrPtSumIndex");
  
     verbosity_ = cfg.getParameter<int>("verbosity");
   }

References cms::cuda::assert(), looper::cfg, Exception, reco::tau::kNewDMwLT, reco::tau::kNewDMwoLT, reco::tau::kOldDMwLT, reco::tau::kOldDMwoLT, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~PFRecoTauDiscriminationByIsolationMVA2()

PFRecoTauDiscriminationByIsolationMVA2::~PFRecoTauDiscriminationByIsolationMVA2 ( )

inlineoverride

Definition at line 117 of file PFRecoTauDiscriminationByMVAIsolation2.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 PFRecoTauDiscriminationByIsolationMVA2::beginEvent	(	const edm::Event &	evt,
		const edm::EventSetup &	es
	)

overridevirtual

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

Definition at line 157 of file PFRecoTauDiscriminationByMVAIsolation2.cc.

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

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

◆ discriminate()

reco::SingleTauDiscriminatorContainer PFRecoTauDiscriminationByIsolationMVA2::discriminate ( const PFTauRef & tau ) const

override

Definition at line 173 of file PFRecoTauDiscriminationByMVAIsolation2.cc.

                                                                                                                   {
   reco::SingleTauDiscriminatorContainer result;
   // CV: define dummy category index in order to use RecoTauDiscriminantCutMultiplexer module to apply WP cuts
   result.rawValues = {-1., 0.};
  
   // 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) &&
        (tauDecayMode == 0 || tauDecayMode == 1 || tauDecayMode == 2 || tauDecayMode == 10)) ||
       ((mvaOpt_ == kNewDMwoLT || mvaOpt_ == kNewDMwLT) &&
        (tauDecayMode == 0 || tauDecayMode == 1 || tauDecayMode == 2 || tauDecayMode == 5 || tauDecayMode == 6 ||
         tauDecayMode == 10))) {
     double chargedIsoPtSum = (*basicTauDiscriminators_)[tau].rawValues.at(chargedIsoPtSum_index_);
     double neutralIsoPtSum = (*basicTauDiscriminators_)[tau].rawValues.at(neutralIsoPtSum_index_);
     double puCorrPtSum = (*basicTauDiscriminators_)[tau].rawValues.at(pucorrPtSum_index_);
  
     const reco::PFTauTransverseImpactParameter& tauLifetimeInfo = *(*tauLifetimeInfos_)[tau];
  
     double decayDistX = tauLifetimeInfo.flightLength().x();
     double decayDistY = tauLifetimeInfo.flightLength().y();
     double decayDistZ = tauLifetimeInfo.flightLength().z();
     double decayDistMag = TMath::Sqrt(decayDistX * decayDistX + decayDistY * decayDistY + decayDistZ * decayDistZ);
  
     if (mvaOpt_ == kOldDMwoLT || mvaOpt_ == kNewDMwoLT) {
       mvaInput_[0] = TMath::Log(TMath::Max(1., Double_t(tau->pt())));
       mvaInput_[1] = TMath::Abs(tau->eta());
       mvaInput_[2] = TMath::Log(TMath::Max(1.e-2, chargedIsoPtSum));
       mvaInput_[3] = TMath::Log(TMath::Max(1.e-2, neutralIsoPtSum - 0.125 * puCorrPtSum));
       mvaInput_[4] = TMath::Log(TMath::Max(1.e-2, puCorrPtSum));
       mvaInput_[5] = tauDecayMode;
     } else if (mvaOpt_ == kOldDMwLT || mvaOpt_ == kNewDMwLT) {
       mvaInput_[0] = TMath::Log(TMath::Max(1., Double_t(tau->pt())));
       mvaInput_[1] = TMath::Abs(tau->eta());
       mvaInput_[2] = TMath::Log(TMath::Max(1.e-2, chargedIsoPtSum));
       mvaInput_[3] = TMath::Log(TMath::Max(1.e-2, neutralIsoPtSum - 0.125 * puCorrPtSum));
       mvaInput_[4] = TMath::Log(TMath::Max(1.e-2, puCorrPtSum));
       mvaInput_[5] = tauDecayMode;
       mvaInput_[6] = TMath::Sign(+1., tauLifetimeInfo.dxy());
       mvaInput_[7] = TMath::Sqrt(TMath::Abs(TMath::Min(1., tauLifetimeInfo.dxy())));
       mvaInput_[8] = TMath::Min(10., TMath::Abs(tauLifetimeInfo.dxy_Sig()));
       mvaInput_[9] = (tauLifetimeInfo.hasSecondaryVertex()) ? 1. : 0.;
       mvaInput_[10] = TMath::Sqrt(decayDistMag);
       mvaInput_[11] = TMath::Min(10., tauLifetimeInfo.flightLengthSig());
     }
  
     double mvaValue = mvaReader_->GetClassifier(mvaInput_);
     if (verbosity_) {
       edm::LogPrint("PFTauDiscByMVAIsol2") << "<PFRecoTauDiscriminationByIsolationMVA2::discriminate>:";
       edm::LogPrint("PFTauDiscByMVAIsol2") << " tau: Pt = " << tau->pt() << ", eta = " << tau->eta();
       edm::LogPrint("PFTauDiscByMVAIsol2") << " isolation: charged = " << chargedIsoPtSum
                                            << ", neutral = " << neutralIsoPtSum << ", PUcorr = " << puCorrPtSum;
       edm::LogPrint("PFTauDiscByMVAIsol2") << " decay mode = " << tauDecayMode;
       edm::LogPrint("PFTauDiscByMVAIsol2") << " impact parameter: distance = " << tauLifetimeInfo.dxy()
                                            << ", significance = " << tauLifetimeInfo.dxy_Sig();
       edm::LogPrint("PFTauDiscByMVAIsol2")
           << " has decay vertex = " << tauLifetimeInfo.hasSecondaryVertex() << ":"
           << " distance = " << decayDistMag << ", significance = " << tauLifetimeInfo.flightLengthSig();
       edm::LogPrint("PFTauDiscByMVAIsol2") << "--> mvaValue = " << mvaValue;
     }
     result.rawValues.at(0) = mvaValue;
   }
   return result;
 }

References Abs(), reco::PFTauTransverseImpactParameter::dxy(), reco::PFTauTransverseImpactParameter::dxy_Sig(), MillePedeFileConverter_cfg::e, reco::PFTauTransverseImpactParameter::flightLength(), reco::PFTauTransverseImpactParameter::flightLengthSig(), reco::PFTauTransverseImpactParameter::hasSecondaryVertex(), reco::tau::kNewDMwLT, reco::tau::kNewDMwoLT, reco::tau::kOldDMwLT, reco::tau::kOldDMwoLT, Max(), Min(), mps_fire::result, Sign(), and metsig::tau.

◆ fillDescriptions()

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

static

Definition at line 241 of file PFRecoTauDiscriminationByMVAIsolation2.cc.

                                                                                                         {
   // pfRecoTauDiscriminationByIsolationMVA2
   edm::ParameterSetDescription desc;
  
   desc.add<std::string>("mvaName");
   desc.add<bool>("loadMVAfromDB");
   desc.addOptional<edm::FileInPath>("inputFileName");
   desc.add<std::string>("mvaOpt");
  
   desc.add<edm::InputTag>("srcTauTransverseImpactParameters");
   desc.add<edm::InputTag>("srcBasicTauDiscriminators");
   desc.add<int>("srcChargedIsoPtSumIndex");
   desc.add<int>("srcNeutralIsoPtSumIndex");
   desc.add<int>("srcPUcorrPtSumIndex");
   desc.add<int>("verbosity", 0);
  
   fillProducerDescriptions(desc);  // inherited from the base
  
   descriptions.add("pfRecoTauDiscriminationByIsolationMVA2", desc);
 }