PATTauDiscriminationByMVAIsolationRun2 Class Reference

Inheritance diagram for 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

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
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.

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

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_(nullptr),
    mvaInput_(nullptr),
    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 ( )

inlineoverride

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  )

overridevirtual

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

overridevirtual

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, SiStripPI::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 )

overridevirtual

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.