PATTauDiscriminationByMVAIsolationRun2 Class Reference

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
	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 &	itemsToGetFromEvent () 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 }

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

Member Enumeration Documentation

anonymous enum

private

Enumerator
kOldDMwoLT
kOldDMwLT
kNewDMwoLT
kNewDMwLT
kDBoldDMwLT
kDBnewDMwLT
kPWoldDMwLT
kPWnewDMwLT

Definition at line 145 of file PATTauDiscriminationByMVAIsolationRun2.cc.

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

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 77 of file PATTauDiscriminationByMVAIsolationRun2.cc.

References assert(), 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 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) 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 127 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 163 of file PATTauDiscriminationByMVAIsolationRun2.cc.

References edm::Event::getByToken(), and mvaPFMET_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 177 of file PATTauDiscriminationByMVAIsolationRun2.cc.

References python.rootplot.argparse::category, PFRecoTauDiscriminationByMVAIsolation2_cff::chargedIsoPtSum, alignCSCRings::e, PFRecoTauDiscriminationByMVAIsolationRun2_cff::footprintCorrection, edm::Ref< C, T, F >::isNull(), dqm-mbProfile::log, bookConverter::max, min(), PFRecoTauDiscriminationByMVAIsolation2_cff::neutralIsoPtSum, PFRecoTauDiscriminationByMVAIsolationRun2_cff::photonPtSumOutsideSignalCone, PFRecoTauDiscriminationByMVAIsolation2_cff::puCorrPtSum, Sign(), 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) && (tauDecayMode == 0 || tauDecayMode == 1 || tauDecayMode == 2 || tauDecayMode == 10)) ||
     ((mvaOpt_ == kNewDMwoLT || mvaOpt_ == kNewDMwLT || mvaOpt_ == kDBnewDMwLT || mvaOpt_ == kPWnewDMwLT) && (tauDecayMode == 0 || tauDecayMode == 1 || tauDecayMode == 2 || tauDecayMode == 5 || tauDecayMode == 6 || tauDecayMode == 10)) ) {
    
    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);
        
    if ( mvaOpt_ == kOldDMwoLT || mvaOpt_ == kNewDMwoLT ) {
      mvaInput_[0]  = std::log(std::max((float)1., (float)tau->pt()));
      mvaInput_[1]  = std::fabs((float)tau->eta());
      mvaInput_[2]  = std::log(std::max((float)1.e-2, chargedIsoPtSum));
      mvaInput_[3]  = std::log(std::max((float)1.e-2, neutralIsoPtSum - (float)0.125*puCorrPtSum));
      mvaInput_[4]  = std::log(std::max((float)1.e-2, puCorrPtSum));
      mvaInput_[5]  = tauDecayMode;
    } else if ( mvaOpt_ == kOldDMwLT || mvaOpt_ == kNewDMwLT  ) {
      mvaInput_[0]  = std::log(std::max((float)1., (float)tau->pt()));
      mvaInput_[1]  = std::fabs((float)tau->eta());
      mvaInput_[2]  = std::log(std::max((float)1.e-2, chargedIsoPtSum));
      mvaInput_[3]  = std::log(std::max((float)1.e-2, neutralIsoPtSum - (float)0.125*puCorrPtSum));
      mvaInput_[4]  = std::log(std::max((float)1.e-2, puCorrPtSum));
      mvaInput_[5]  = tauDecayMode;
      mvaInput_[6]  = TMath::Sign((float)+1., tau->dxy());
      mvaInput_[7]  = std::sqrt(std::min((float)1., std::fabs(tau->dxy())));
      mvaInput_[8]  = std::min((float)10., std::fabs(tau->dxy_Sig()));
      mvaInput_[9]  = ( tau->hasSecondaryVertex() ) ? 1. : 0.;
      mvaInput_[10] = std::sqrt(decayDistMag);
      mvaInput_[11] = std::min((float)10., tau->flightLengthSig());
    } else if ( mvaOpt_ == kDBoldDMwLT || mvaOpt_ == kDBnewDMwLT ) {
      mvaInput_[0]  = std::log(std::max((float)1., (float)tau->pt()));
      mvaInput_[1]  = std::fabs(tau->eta());
      mvaInput_[2]  = std::log(std::max((float)1.e-2, chargedIsoPtSum));
      mvaInput_[3]  = std::log(std::max((float)1.e-2, neutralIsoPtSum));
      mvaInput_[4]  = std::log(std::max((float)1.e-2, puCorrPtSum));
      mvaInput_[5]  = std::log(std::max((float)1.e-2, photonPtSumOutsideSignalCone));
      mvaInput_[6]  = tauDecayMode;
      mvaInput_[7]  = std::min((float)30., nPhoton);
      mvaInput_[8]  = std::min((float)0.5, ptWeightedDetaStrip);
      mvaInput_[9]  = std::min((float)0.5, ptWeightedDphiStrip);
      mvaInput_[10] = std::min((float)0.5, ptWeightedDrSignal);
      mvaInput_[11] = std::min((float)0.5, ptWeightedDrIsolation);
      mvaInput_[12] = std::min((float)100., leadingTrackChi2);
      mvaInput_[13] = std::min((float)1., eRatio);
      mvaInput_[14]  = TMath::Sign((float)+1., tau->dxy());
      mvaInput_[15]  = std::sqrt(std::min((float)1., std::fabs(tau->dxy())));
      mvaInput_[16]  = std::min((float)10., std::fabs(tau->dxy_Sig()));
      mvaInput_[17]  = TMath::Sign((float)+1., tau->ip3d());
      mvaInput_[18]  = std::sqrt(std::min((float)1., std::fabs(tau->ip3d())));
      mvaInput_[19]  = std::min((float)10., std::fabs(tau->ip3d_Sig()));
      mvaInput_[20]  = ( tau->hasSecondaryVertex() ) ? 1. : 0.;
      mvaInput_[21] = std::sqrt(decayDistMag);
      mvaInput_[22] = std::min((float)10., tau->flightLengthSig());
    } else if ( mvaOpt_ == kPWoldDMwLT || mvaOpt_ == kPWnewDMwLT ) {
      mvaInput_[0]  = std::log(std::max((float)1., (float)tau->pt()));
      mvaInput_[1]  = std::fabs(tau->eta());
      mvaInput_[2]  = std::log(std::max((float)1.e-2, chargedIsoPtSum));
      mvaInput_[3]  = std::log(std::max((float)1.e-2, neutralIsoPtSum));
      mvaInput_[4]  = std::log(std::max((float)1.e-2, footprintCorrection));
      mvaInput_[5]  = std::log(std::max((float)1.e-2, photonPtSumOutsideSignalCone));
      mvaInput_[6]  = tauDecayMode;
      mvaInput_[7]  = std::min((float)30., nPhoton);
      mvaInput_[8]  = std::min((float)0.5, ptWeightedDetaStrip);
      mvaInput_[9]  = std::min((float)0.5, ptWeightedDphiStrip);
      mvaInput_[10] = std::min((float)0.5, ptWeightedDrSignal);
      mvaInput_[11] = std::min((float)0.5, ptWeightedDrIsolation);
      mvaInput_[12] = std::min((float)100., leadingTrackChi2);
      mvaInput_[13] = std::min((float)1., eRatio);
      mvaInput_[14]  = TMath::Sign((float)+1., tau->dxy());
      mvaInput_[15]  = std::sqrt(std::fabs(std::min((float)1., std::fabs(tau->dxy()))));
      mvaInput_[16]  = std::min((float)10., std::fabs(tau->dxy_Sig()));
      mvaInput_[17]  = TMath::Sign((float)+1., tau->ip3d());
      mvaInput_[18]  = std::sqrt(std::fabs(std::min((float)1., std::fabs(tau->ip3d()))));
      mvaInput_[19]  = std::min((float)10., std::fabs(tau->ip3d_Sig()));
      mvaInput_[20]  = ( tau->hasSecondaryVertex() ) ? 1. : 0.;
      mvaInput_[21] = std::sqrt(decayDistMag);
      mvaInput_[22] = std::min((float)10., tau->flightLengthSig());
    }
        
    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 300 of file PATTauDiscriminationByMVAIsolationRun2.cc.

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

std::string PATTauDiscriminationByMVAIsolationRun2::chargedIsoPtSums_

private

Definition at line 149 of file PATTauDiscriminationByMVAIsolationRun2.cc.

TauIdMVAAuxiliaries PATTauDiscriminationByMVAIsolationRun2::clusterVariables_

private

Definition at line 158 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::footprintCorrection_

private

Definition at line 153 of file PATTauDiscriminationByMVAIsolationRun2.cc.

edm::FileInPath PATTauDiscriminationByMVAIsolationRun2::inputFileName_

private

Definition at line 143 of file PATTauDiscriminationByMVAIsolationRun2.cc.

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

private

Definition at line 157 of file PATTauDiscriminationByMVAIsolationRun2.cc.

bool PATTauDiscriminationByMVAIsolationRun2::loadMVAfromDB_

private

Definition at line 142 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::moduleLabel_

private

Definition at line 139 of file PATTauDiscriminationByMVAIsolationRun2.cc.

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

float* PATTauDiscriminationByMVAIsolationRun2::mvaInput_

private

Definition at line 147 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::mvaName_

private

Definition at line 141 of file PATTauDiscriminationByMVAIsolationRun2.cc.

int PATTauDiscriminationByMVAIsolationRun2::mvaOpt_

private

Definition at line 146 of file PATTauDiscriminationByMVAIsolationRun2.cc.

const GBRForest* PATTauDiscriminationByMVAIsolationRun2::mvaReader_

private

Definition at line 144 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::neutralIsoPtSums_

private

Definition at line 150 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::photonPtSumOutsideSignalCone_

private

Definition at line 152 of file PATTauDiscriminationByMVAIsolationRun2.cc.

std::string PATTauDiscriminationByMVAIsolationRun2::puCorrPtSums_

private

Definition at line 151 of file PATTauDiscriminationByMVAIsolationRun2.cc.

edm::Handle<TauCollection> PATTauDiscriminationByMVAIsolationRun2::taus_

private

Definition at line 155 of file PATTauDiscriminationByMVAIsolationRun2.cc.

int PATTauDiscriminationByMVAIsolationRun2::verbosity_

private

Definition at line 160 of file PATTauDiscriminationByMVAIsolationRun2.cc.