Inheritance diagram for reco::tau::PATTauDiscriminationByMVAIsolationRun2:

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

double	discriminate (const TauRef &) const override

void	endEvent (edm::Event &) override

	PATTauDiscriminationByMVAIsolationRun2 (const edm::ParameterSet &cfg)

	~PATTauDiscriminationByMVAIsolationRun2 () 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

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

Static Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
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::unique_ptr< pat::PATTauDiscriminator >	category_output_

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

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 80 of file PATTauDiscriminationByMVAIsolationRun2.cc.

References Exception, edm::ParameterSet::getParameter(), 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.

       : PATTauDiscriminationProducerBase(cfg),
         moduleLabel_(cfg.getParameter<std::string>("@module_label")),
     mvaReader_(nullptr),
     mvaInput_(nullptr),
     category_output_()
     {
        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");
 
        produces<pat::PATTauDiscriminator>("category");
     }  

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

inlineoverride

Definition at line 130 of file PATTauDiscriminationByMVAIsolationRun2.cc.

References fillDescriptions().

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

Member Function Documentation

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

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 166 of file PATTauDiscriminationByMVAIsolationRun2.cc.

References edm::Event::getByToken(), and taus_updatedMVAIds_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 reco::tau::PATTauDiscriminationByMVAIsolationRun2::discriminate ( const TauRef & tau ) const

overridevirtual

Implements TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 180 of file PATTauDiscriminationByMVAIsolationRun2.cc.

References taus_updatedMVAIds_cff::category, reco::tau::fillIsoMVARun2Inputs(), and edm::Ref< C, T, F >::isNull().

 {
   // 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.;
 
   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;
     }
     return mvaValue;
   } 
   return -1.;
 }

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

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 206 of file PATTauDiscriminationByMVAIsolationRun2.cc.

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

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

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

static

Definition at line 213 of file PATTauDiscriminationByMVAIsolationRun2.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), DEFINE_FWK_MODULE, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                    {
   // 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);
 }