PFMETAlgorithmMVA Class Reference

#include <PFMETAlgorithmMVA.h>

Public Member Functions
void	evaluateMVA ()
double	getCovU1 () const
double	getCovU2 () const
double	getDPhi () const
reco::Candidate::LorentzVector	getMEt () const
const reco::METCovMatrix &	getMEtCov () const
double	getU () const
void	initialize (const edm::EventSetup &)
	PFMETAlgorithmMVA (const edm::ParameterSet &cfg)
void	print (std::ostream &) const
void	setHasPhotons (bool hasPhotons)
void	setInput (const std::vector< reco::PUSubMETCandInfo > &, const std::vector< reco::PUSubMETCandInfo > &, const std::vector< reco::PUSubMETCandInfo > &, const std::vector< reco::Vertex::Point > &)
	~PFMETAlgorithmMVA ()

Private Member Functions
void	computeMET ()
std::unique_ptr< float[]>	createFloatVector (std::vector< std::string > variableNames)
const float	evaluateCovU1 ()
const float	evaluateCovU2 ()
const float	evaluateDPhi ()
const float	evaluateU ()
const float	GetResponse (const GBRForest *Reader, std::vector< std::string > &variableNames)
const GBRForest *	loadMVAfromDB (const edm::EventSetup &es, const std::string &mvaName)
const GBRForest *	loadMVAfromFile (const edm::FileInPath &inputFileName, const std::string &mvaName)
const std::string	updateVariableNames (std::string input)

Private Attributes
edm::ParameterSet	cfg_
double	chargedSumLeptonPx_
double	chargedSumLeptonPy_
double	dZcut_
bool	hasPhotons_
bool	loadMVAfromDB_
float *	mvaInputCovU1_
float *	mvaInputCovU2_
float *	mvaInputDPhi_
float *	mvaInputU_
reco::Candidate::LorentzVector	mvaMEt_
reco::METCovMatrix	mvaMEtCov_
std::string	mvaNameCovU1_
std::string	mvaNameCovU2_
std::string	mvaNameDPhi_
std::string	mvaNameU_
float	mvaOutputCovU1_
float	mvaOutputCovU2_
float	mvaOutputDPhi_
float	mvaOutputU_
const GBRForest *	mvaReaderCovU1_
const GBRForest *	mvaReaderCovU2_
const GBRForest *	mvaReaderDPhi_
const GBRForest *	mvaReaderU_
int	mvaType_
double	sumLeptonPx_
double	sumLeptonPy_
MvaMEtUtilities	utils_
std::map< std::string, float >	var_
std::vector< std::string >	varForCovU1_
std::vector< std::string >	varForCovU2_
std::vector< std::string >	varForDPhi_
std::vector< std::string >	varForU_

Detailed Description

MVA based algorithm for computing the particle-flow missing Et

Authors

Phil Harris, CERN Christian Veelken, LLR

Definition at line 31 of file PFMETAlgorithmMVA.h.

Constructor & Destructor Documentation

PFMETAlgorithmMVA()

PFMETAlgorithmMVA::PFMETAlgorithmMVA

(

const edm::ParameterSet &

cfg

)

Definition at line 121 of file PFMETAlgorithmMVA.cc.

    : utils_(cfg),
      mvaReaderU_(nullptr),
      mvaReaderDPhi_(nullptr),
      mvaReaderCovU1_(nullptr),
      mvaReaderCovU2_(nullptr),
      cfg_(cfg) {
  mvaType_ = kBaseline;
 
  loadMVAfromDB_ = cfg.getParameter<bool>("loadMVAfromDB");
}

References looper::cfg, kBaseline, loadMVAfromDB_, and mvaType_.

~PFMETAlgorithmMVA()

PFMETAlgorithmMVA::~PFMETAlgorithmMVA

(

)

Definition at line 133 of file PFMETAlgorithmMVA.cc.

                                      {
  if (!loadMVAfromDB_) {
    delete mvaReaderU_;
    delete mvaReaderDPhi_;
    delete mvaReaderCovU1_;
    delete mvaReaderCovU2_;
  }
}

References loadMVAfromDB_, mvaReaderCovU1_, mvaReaderCovU2_, mvaReaderDPhi_, and mvaReaderU_.

Member Function Documentation

computeMET()

void PFMETAlgorithmMVA::computeMET ( )

private

Definition at line 260 of file PFMETAlgorithmMVA.cc.

                                   {
  double U = var_["RecoilCor_U"];
  double Phi = var_["PhiCor_UPhi"];
  if (U < 0.)
    Phi += Pi;  //RF: No sign flip for U necessary in that case?
  double cosPhi = std::cos(Phi);
  double sinPhi = std::sin(Phi);
  double metPx = U * cosPhi - sumLeptonPx_;
  double metPy = U * sinPhi - sumLeptonPy_;
  double metPt = sqrt(metPx * metPx + metPy * metPy);
  mvaMEt_.SetCoordinates(metPx, metPy, 0., metPt);
  // compute MET uncertainties in dirrections parallel and perpendicular to hadronic recoil
  // (neglecting uncertainties on lepton momenta)
  mvaMEtCov_(0, 0) = mvaOutputCovU1_ * cosPhi * cosPhi + mvaOutputCovU2_ * sinPhi * sinPhi;
  mvaMEtCov_(0, 1) = -mvaOutputCovU1_ * sinPhi * cosPhi + mvaOutputCovU2_ * sinPhi * cosPhi;
  mvaMEtCov_(1, 0) = mvaMEtCov_(0, 1);
  mvaMEtCov_(1, 1) = mvaOutputCovU1_ * sinPhi * sinPhi + mvaOutputCovU2_ * cosPhi * cosPhi;
}

References funct::cos(), mvaMEt_, mvaMEtCov_, mvaOutputCovU1_, mvaOutputCovU2_, VtxSmearedParameters_cfi::Phi, Pi, funct::sin(), mathSSE::sqrt(), sumLeptonPx_, sumLeptonPy_, mitigatedMETSequence_cff::U, and var_.

Referenced by evaluateMVA().

createFloatVector()

std::unique_ptr< float[]> PFMETAlgorithmMVA::createFloatVector ( std::vector< std::string >  variableNames )

private

Definition at line 226 of file PFMETAlgorithmMVA.cc.

                                                                                              {
  std::unique_ptr<float[]> floatVector(new float[variableNames.size()]);
  int i = 0;
  for (const auto& variableName : variableNames) {
    floatVector[i++] = var_[variableName];
  }
  return floatVector;
}

References mps_fire::i, and var_.

Referenced by GetResponse().

evaluateCovU1()

const float PFMETAlgorithmMVA::evaluateCovU1 ( )

private

evaluateCovU2()

const float PFMETAlgorithmMVA::evaluateCovU2 ( )

private

evaluateDPhi()

const float PFMETAlgorithmMVA::evaluateDPhi ( )

private

evaluateMVA()

void PFMETAlgorithmMVA::evaluateMVA

(

)

Definition at line 236 of file PFMETAlgorithmMVA.cc.

                                    {
  // CV: MVAs needs to be evaluated in order { DPhi, U1, CovU1, CovU2 }
  //     as MVA for U1 (CovU1, CovU2) uses output of DPhi (DPhi and U1) MVA
  mvaOutputDPhi_ = GetResponse(mvaReaderDPhi_, varForDPhi_);
  var_["PhiCor_UPhi"] = var_["particleFlow_UPhi"] + mvaOutputDPhi_;
  mvaOutputU_ = GetResponse(mvaReaderU_, varForU_);
  var_["RecoilCor_U"] = var_["particleFlow_U"] * mvaOutputU_;
  var_["RecoilCor_UPhi"] = var_["PhiCor_UPhi"];
  mvaOutputCovU1_ = std::pow(GetResponse(mvaReaderCovU1_, varForCovU1_) * mvaOutputU_ * var_["particleFlow_U"], 2);
  mvaOutputCovU2_ = std::pow(GetResponse(mvaReaderCovU2_, varForCovU2_) * mvaOutputU_ * var_["particleFlow_U"], 2);
 
  // compute MET(Photon check)
  if (hasPhotons_) {
    //Fix events with unphysical properties
    double sumLeptonPt = std::max(sqrt(sumLeptonPx_ * sumLeptonPx_ + sumLeptonPy_ * sumLeptonPy_), 1.);
    if (var_["track_U"] / sumLeptonPt < 0.1 || var_["noPileUp_U"] / sumLeptonPt < 0.1) {
      mvaOutputU_ = 1.;
      mvaOutputDPhi_ = 0.;
    }
  }
  computeMET();
}

References computeMET(), GetResponse(), hasPhotons_, SiStripPI::max, mvaOutputCovU1_, mvaOutputCovU2_, mvaOutputDPhi_, mvaOutputU_, mvaReaderCovU1_, mvaReaderCovU2_, mvaReaderDPhi_, mvaReaderU_, funct::pow(), mathSSE::sqrt(), sumLeptonPx_, sumLeptonPy_, var_, varForCovU1_, varForCovU2_, varForDPhi_, and varForU_.

Referenced by reco::PFMETProducerMVA::produce().

evaluateU()

const float PFMETAlgorithmMVA::evaluateU ( )

private

getCovU1()

double PFMETAlgorithmMVA::getCovU1 ( ) const

inline

Definition at line 52 of file PFMETAlgorithmMVA.h.

{ return mvaOutputCovU1_; }

References mvaOutputCovU1_.

getCovU2()

double PFMETAlgorithmMVA::getCovU2 ( ) const

inline

Definition at line 53 of file PFMETAlgorithmMVA.h.

{ return mvaOutputCovU2_; }

References mvaOutputCovU2_.

getDPhi()

double PFMETAlgorithmMVA::getDPhi ( ) const

inline

Definition at line 51 of file PFMETAlgorithmMVA.h.

{ return mvaOutputDPhi_; }

References mvaOutputDPhi_.

getMEt()

reco::Candidate::LorentzVector PFMETAlgorithmMVA::getMEt ( ) const

inline

Definition at line 47 of file PFMETAlgorithmMVA.h.

{ return mvaMEt_; }

References mvaMEt_.

Referenced by reco::PFMETProducerMVA::produce().

getMEtCov()

const reco::METCovMatrix& PFMETAlgorithmMVA::getMEtCov ( ) const

inline

Definition at line 48 of file PFMETAlgorithmMVA.h.

{ return mvaMEtCov_; }

References mvaMEtCov_.

Referenced by reco::PFMETProducerMVA::produce().

GetResponse()

const float PFMETAlgorithmMVA::GetResponse ( const GBRForest *  Reader, std::vector< std::string > &  variableNames  )

private

Definition at line 280 of file PFMETAlgorithmMVA.cc.

                                                                                                       {
  std::unique_ptr<float[]> mvaInputVector = createFloatVector(variableNames);
  double result = Reader->GetResponse(mvaInputVector.get());
  return result;
}

References createFloatVector(), GBRForest::GetResponse(), and mps_fire::result.

Referenced by evaluateMVA().

getU()

double PFMETAlgorithmMVA::getU ( ) const

inline

Definition at line 50 of file PFMETAlgorithmMVA.h.

{ return mvaOutputU_; }

References mvaOutputU_.

initialize()

void PFMETAlgorithmMVA::initialize

(

const edm::EventSetup &

es

)

Definition at line 143 of file PFMETAlgorithmMVA.cc.

                                                          {
  edm::ParameterSet cfgInputRecords = cfg_.getParameter<edm::ParameterSet>("inputRecords");
  mvaNameU_ = cfgInputRecords.getParameter<std::string>("U");
  mvaNameDPhi_ = cfgInputRecords.getParameter<std::string>("DPhi");
  mvaNameCovU1_ = cfgInputRecords.getParameter<std::string>("CovU1");
  mvaNameCovU2_ = cfgInputRecords.getParameter<std::string>("CovU2");
 
  if (loadMVAfromDB_) {
    mvaReaderU_ = loadMVAfromDB(es, mvaNameU_);
    mvaReaderDPhi_ = loadMVAfromDB(es, mvaNameDPhi_);
    mvaReaderCovU1_ = loadMVAfromDB(es, mvaNameCovU1_);
    mvaReaderCovU2_ = loadMVAfromDB(es, mvaNameCovU2_);
  } else {
    edm::ParameterSet cfgInputFileNames = cfg_.getParameter<edm::ParameterSet>("inputFileNames");
 
    edm::FileInPath inputFileNameU = cfgInputFileNames.getParameter<edm::FileInPath>("U");
    mvaReaderU_ = loadMVAfromFile(inputFileNameU, mvaNameU_);
    edm::FileInPath inputFileNameDPhi = cfgInputFileNames.getParameter<edm::FileInPath>("DPhi");
    mvaReaderDPhi_ = loadMVAfromFile(inputFileNameDPhi, mvaNameDPhi_);
    edm::FileInPath inputFileNameCovU1 = cfgInputFileNames.getParameter<edm::FileInPath>("CovU1");
    mvaReaderCovU1_ = loadMVAfromFile(inputFileNameCovU1, mvaNameCovU1_);
    edm::FileInPath inputFileNameCovU2 = cfgInputFileNames.getParameter<edm::FileInPath>("CovU2");
    mvaReaderCovU2_ = loadMVAfromFile(inputFileNameCovU2, mvaNameCovU2_);
  }
}

References cfg_, edm::ParameterSet::getParameter(), loadMVAfromDB(), loadMVAfromDB_, loadMVAfromFile(), mvaNameCovU1_, mvaNameCovU2_, mvaNameDPhi_, mvaNameU_, mvaReaderCovU1_, mvaReaderCovU2_, mvaReaderDPhi_, mvaReaderU_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by reco::PFMETProducerMVA::produce().

loadMVAfromDB()

const GBRForest * PFMETAlgorithmMVA::loadMVAfromDB ( const edm::EventSetup &  es, const std::string &  mvaName  )

private

Definition at line 115 of file PFMETAlgorithmMVA.cc.

                                                                                                   {
  edm::ESHandle<GBRForest> mva;
  es.get<GBRWrapperRcd>().get(mvaName, mva);
  return mva.product();
}

References edm::EventSetup::get(), get, beam_dqm_sourceclient-live_cfg::mva, and taus_updatedMVAIds_cff::mvaName.

Referenced by initialize().

loadMVAfromFile()

const GBRForest * PFMETAlgorithmMVA::loadMVAfromFile ( const edm::FileInPath &  inputFileName, const std::string &  mvaName  )

private

Definition at line 78 of file PFMETAlgorithmMVA.cc.

                                                                                                                {
  if (inputFileName.location() == edm::FileInPath::Unknown)
    throw cms::Exception("PFMETAlgorithmMVA::loadMVA") << " Failed to find File = " << inputFileName << " !!\n";
  std::unique_ptr<TFile> inputFile(new TFile(inputFileName.fullPath().data()));
 
  std::vector<std::string>* lVec = (std::vector<std::string>*)inputFile->Get("varlist");
 
  if (lVec == nullptr) {
    throw cms::Exception("PFMETAlgorithmMVA::loadMVA")
        << " Failed to load mva file : " << inputFileName.fullPath().data() << " is not a proper file !!\n";
  }
 
  std::vector<std::string> variableNames;
  for (unsigned int i = 0; i < lVec->size(); ++i) {
    variableNames.push_back(updateVariableNames(lVec->at(i)));
  }
 
  if (mvaName.find(mvaNameU_) != std::string::npos)
    varForU_ = variableNames;
  else if (mvaName.find(mvaNameDPhi_) != std::string::npos)
    varForDPhi_ = variableNames;
  else if (mvaName.find(mvaNameCovU1_) != std::string::npos)
    varForCovU1_ = variableNames;
  else if (mvaName.find(mvaNameCovU2_) != std::string::npos)
    varForCovU2_ = variableNames;
  else
    throw cms::Exception("PFMETAlgorithmMVA::loadMVA")
        << "MVA MET weight file tree names do not match specified inputs" << std::endl;
 
  const GBRForest* mva = (GBRForest*)inputFile->Get(mvaName.data());
  if (!mva)
    throw cms::Exception("PFMETAlgorithmMVA::loadMVA")
        << " Failed to load MVA = " << mvaName.data() << " from file = " << inputFileName.fullPath().data() << " !!\n";
 
  return mva;
}

References Exception, mps_fire::i, dtResolutionTest_cfi::inputFile, InefficientDoubleROC::inputFileName, beam_dqm_sourceclient-live_cfg::mva, taus_updatedMVAIds_cff::mvaName, mvaNameCovU1_, mvaNameCovU2_, mvaNameDPhi_, mvaNameU_, edm::FileInPath::Unknown, updateVariableNames(), varForCovU1_, varForCovU2_, varForDPhi_, and varForU_.

Referenced by initialize().

print()

void PFMETAlgorithmMVA::print

(

std::ostream &

stream

)

const

Definition at line 287 of file PFMETAlgorithmMVA.cc.

                                                      {
  stream << "<PFMETAlgorithmMVA::print>:" << std::endl;
  for (const auto& entry : var_)
    stream << entry.first << " = " << entry.second << std::endl;
  stream << " covU1 = " << mvaOutputCovU1_ << ", covU2 = " << mvaOutputCovU2_ << std::endl;
  stream << " sum(leptons): Pt = " << sqrt(sumLeptonPx_ * sumLeptonPx_ + sumLeptonPy_ * sumLeptonPy_) << ","
         << " phi = " << atan2(sumLeptonPy_, sumLeptonPx_) << " "
         << "(Px = " << sumLeptonPx_ << ", Py = " << sumLeptonPy_ << ")";
  stream << " MVA output: U = " << mvaOutputU_ << ", dPhi = " << mvaOutputDPhi_ << ","
         << " covU1 = " << mvaOutputCovU1_ << ", covU2 = " << mvaOutputCovU2_ << std::endl;
  stream << std::endl;
}

References mps_splice::entry, mvaOutputCovU1_, mvaOutputCovU2_, mvaOutputDPhi_, mvaOutputU_, mathSSE::sqrt(), cms::cuda::stream, sumLeptonPx_, sumLeptonPy_, and var_.

setHasPhotons()

void PFMETAlgorithmMVA::setHasPhotons ( bool  hasPhotons )

inline

Definition at line 38 of file PFMETAlgorithmMVA.h.

{ hasPhotons_ = hasPhotons; }

References hasPhotons_.

Referenced by reco::PFMETProducerMVA::produce().

setInput()

void PFMETAlgorithmMVA::setInput	(	const std::vector< reco::PUSubMETCandInfo > &	leptons,
		const std::vector< reco::PUSubMETCandInfo > &	jets,
		const std::vector< reco::PUSubMETCandInfo > &	pfCandidates,
		const std::vector< reco::Vertex::Point > &	vertices
	)

Definition at line 170 of file PFMETAlgorithmMVA.cc.

                                                                             {
  utils_.computeAllSums(jets, leptons, pfCandidates);
 
  sumLeptonPx_ = utils_.getLeptonsSumMEX();
  sumLeptonPy_ = utils_.getLeptonsSumMEY();
 
  chargedSumLeptonPx_ = utils_.getLeptonsChSumMEX();
  chargedSumLeptonPy_ = utils_.getLeptonsChSumMEY();
 
  const std::vector<reco::PUSubMETCandInfo> jets_cleaned = utils_.getCleanedJets();
 
  CommonMETData pfRecoil_data = utils_.computeRecoil(MvaMEtUtilities::kPF);
  CommonMETData chHSRecoil_data = utils_.computeRecoil(MvaMEtUtilities::kChHS);
  CommonMETData hsRecoil_data = utils_.computeRecoil(MvaMEtUtilities::kHS);
  CommonMETData puRecoil_data = utils_.computeRecoil(MvaMEtUtilities::kPU);
  CommonMETData hsMinusNeutralPUMEt_data = utils_.computeRecoil(MvaMEtUtilities::kHSMinusNeutralPU);
 
  reco::Candidate::LorentzVector jet1P4 = utils_.leadJetP4(jets_cleaned);
  reco::Candidate::LorentzVector jet2P4 = utils_.subleadJetP4(jets_cleaned);
 
  var_["particleFlow_U"] = pfRecoil_data.met;
  var_["particleFlow_SumET"] = pfRecoil_data.sumet;
  var_["particleFlow_UPhi"] = pfRecoil_data.phi;
 
  var_["track_SumET"] = chHSRecoil_data.sumet / var_["particleFlow_SumET"];
  var_["track_U"] = chHSRecoil_data.met;
  var_["track_UPhi"] = chHSRecoil_data.phi;
 
  var_["noPileUp_SumET"] = hsRecoil_data.sumet / var_["particleFlow_SumET"];
  var_["noPileUp_U"] = hsRecoil_data.met;
  var_["noPileUp_UPhi"] = hsRecoil_data.phi;
 
  var_["pileUp_SumET"] = puRecoil_data.sumet / var_["particleFlow_SumET"];
  var_["pileUp_MET"] = puRecoil_data.met;
  var_["pileUp_METPhi"] = puRecoil_data.phi;
 
  var_["pileUpCorrected_SumET"] = hsMinusNeutralPUMEt_data.sumet / var_["particleFlow_SumET"];
  var_["pileUpCorrected_U"] = hsMinusNeutralPUMEt_data.met;
  var_["pileUpCorrected_UPhi"] = hsMinusNeutralPUMEt_data.phi;
 
  var_["jet1_pT"] = jet1P4.pt();
  var_["jet1_eta"] = jet1P4.eta();
  var_["jet1_Phi"] = jet1P4.phi();
  var_["jet2_pT"] = jet2P4.pt();
  var_["jet2_eta"] = jet2P4.eta();
  var_["jet2_Phi"] = jet2P4.phi();
 
  var_["numJetsPtGt30"] = utils_.numJetsAboveThreshold(jets_cleaned, 30.);
  var_["nJets"] = jets_cleaned.size();
  var_["nPV"] = vertices.size();
}

References chargedSumLeptonPx_, chargedSumLeptonPy_, MvaMEtUtilities::computeAllSums(), MvaMEtUtilities::computeRecoil(), MvaMEtUtilities::getCleanedJets(), MvaMEtUtilities::getLeptonsChSumMEX(), MvaMEtUtilities::getLeptonsChSumMEY(), MvaMEtUtilities::getLeptonsSumMEX(), MvaMEtUtilities::getLeptonsSumMEY(), singleTopDQM_cfi::jets, MvaMEtUtilities::kChHS, MvaMEtUtilities::kHS, MvaMEtUtilities::kHSMinusNeutralPU, MvaMEtUtilities::kPF, MvaMEtUtilities::kPU, MvaMEtUtilities::leadJetP4(), HLT_FULL_cff::leptons, CommonMETData::met, MvaMEtUtilities::numJetsAboveThreshold(), zmumugammaAnalyzer_cfi::pfCandidates, CommonMETData::phi, MvaMEtUtilities::subleadJetP4(), CommonMETData::sumet, sumLeptonPx_, sumLeptonPy_, utils_, var_, and pwdgSkimBPark_cfi::vertices.

Referenced by reco::PFMETProducerMVA::produce().

updateVariableNames()

const std::string PFMETAlgorithmMVA::updateVariableNames ( std::string  input )

private

Definition at line 20 of file PFMETAlgorithmMVA.cc.

                                                                      {
  if (input == "sumet")
    return "particleFlow_SumET";
  if (input == "npv")
    return "nPV";
  if (input == "pfu")
    return "particleFlow_U";
  if (input == "pfuphi")
    return "particleFlow_UPhi";
  if (input == "tksumet")
    return "track_SumET";
  if (input == "tku")
    return "track_U";
  if (input == "tkuphi")
    return "track_UPhi";
  if (input == "nopusumet")
    return "noPileUp_SumET";
  if (input == "nopuu")
    return "noPileUp_U";
  if (input == "nopuuphi")
    return "noPileUp_UPhi";
  if (input == "pusumet")
    return "pileUp_SumET";
  if (input == "pumet")
    return "pileUp_MET";
  if (input == "pumetphi")
    return "pileUp_METPhi";
  if (input == "pucsumet")
    return "pileUpCorrected_SumET";
  if (input == "pucu")
    return "pileUpCorrected_U";
  if (input == "pucuphi")
    return "pileUpCorrected_UPhi";
  if (input == "jetpt1")
    return "jet1_pT";
  if (input == "jeteta1")
    return "jet1_eta";
  if (input == "jetphi1")
    return "jet1_Phi";
  if (input == "jetpt2")
    return "jet2_pT";
  if (input == "jeteta2")
    return "jet2_eta";
  if (input == "jetphi2")
    return "jet2_Phi";
  if (input == "nalljet")
    return "nJets";
  if (input == "njet")
    return "numJetsPtGt30";
  if (input == "uphi_mva")
    return "PhiCor_UPhi";
  if (input == "uphix_mva")
    return "PhiCor_UPhi";
  if (input == "ux_mva")
    return "RecoilCor_U";
  return input;
}

References input.

Referenced by loadMVAfromFile().

Member Data Documentation

cfg_

edm::ParameterSet PFMETAlgorithmMVA::cfg_

private

Definition at line 114 of file PFMETAlgorithmMVA.h.

Referenced by initialize().

chargedSumLeptonPx_

double PFMETAlgorithmMVA::chargedSumLeptonPx_

private

Definition at line 100 of file PFMETAlgorithmMVA.h.

Referenced by setInput().

chargedSumLeptonPy_

double PFMETAlgorithmMVA::chargedSumLeptonPy_

private

Definition at line 101 of file PFMETAlgorithmMVA.h.

Referenced by setInput().

dZcut_

double PFMETAlgorithmMVA::dZcut_

private

Definition at line 77 of file PFMETAlgorithmMVA.h.

hasPhotons_

bool PFMETAlgorithmMVA::hasPhotons_

private

Definition at line 75 of file PFMETAlgorithmMVA.h.

Referenced by evaluateMVA(), and setHasPhotons().

loadMVAfromDB_

bool PFMETAlgorithmMVA::loadMVAfromDB_

private

Definition at line 112 of file PFMETAlgorithmMVA.h.

Referenced by initialize(), PFMETAlgorithmMVA(), and ~PFMETAlgorithmMVA().

mvaInputCovU1_

float* PFMETAlgorithmMVA::mvaInputCovU1_

private

Definition at line 85 of file PFMETAlgorithmMVA.h.

mvaInputCovU2_

float* PFMETAlgorithmMVA::mvaInputCovU2_

private

Definition at line 86 of file PFMETAlgorithmMVA.h.

mvaInputDPhi_

float* PFMETAlgorithmMVA::mvaInputDPhi_

private

Definition at line 84 of file PFMETAlgorithmMVA.h.

mvaInputU_

float* PFMETAlgorithmMVA::mvaInputU_

private

Definition at line 83 of file PFMETAlgorithmMVA.h.

mvaMEt_

reco::Candidate::LorentzVector PFMETAlgorithmMVA::mvaMEt_

private

Definition at line 103 of file PFMETAlgorithmMVA.h.

Referenced by computeMET(), and getMEt().

mvaMEtCov_

reco::METCovMatrix PFMETAlgorithmMVA::mvaMEtCov_

private

Definition at line 105 of file PFMETAlgorithmMVA.h.

Referenced by computeMET(), and getMEtCov().

mvaNameCovU1_

std::string PFMETAlgorithmMVA::mvaNameCovU1_

private

Definition at line 71 of file PFMETAlgorithmMVA.h.

Referenced by initialize(), and loadMVAfromFile().

mvaNameCovU2_

std::string PFMETAlgorithmMVA::mvaNameCovU2_

private

Definition at line 72 of file PFMETAlgorithmMVA.h.

Referenced by initialize(), and loadMVAfromFile().

mvaNameDPhi_

std::string PFMETAlgorithmMVA::mvaNameDPhi_

private

Definition at line 70 of file PFMETAlgorithmMVA.h.

Referenced by initialize(), and loadMVAfromFile().

mvaNameU_

std::string PFMETAlgorithmMVA::mvaNameU_

private

Definition at line 69 of file PFMETAlgorithmMVA.h.

Referenced by initialize(), and loadMVAfromFile().

mvaOutputCovU1_

float PFMETAlgorithmMVA::mvaOutputCovU1_

private

Definition at line 90 of file PFMETAlgorithmMVA.h.

Referenced by computeMET(), evaluateMVA(), getCovU1(), and print().

mvaOutputCovU2_

float PFMETAlgorithmMVA::mvaOutputCovU2_

private

Definition at line 91 of file PFMETAlgorithmMVA.h.

Referenced by computeMET(), evaluateMVA(), getCovU2(), and print().

mvaOutputDPhi_

float PFMETAlgorithmMVA::mvaOutputDPhi_

private

Definition at line 89 of file PFMETAlgorithmMVA.h.

Referenced by evaluateMVA(), getDPhi(), and print().

mvaOutputU_

float PFMETAlgorithmMVA::mvaOutputU_

private

Definition at line 88 of file PFMETAlgorithmMVA.h.

Referenced by evaluateMVA(), getU(), and print().

mvaReaderCovU1_

const GBRForest* PFMETAlgorithmMVA::mvaReaderCovU1_

private

Definition at line 109 of file PFMETAlgorithmMVA.h.

Referenced by evaluateMVA(), initialize(), and ~PFMETAlgorithmMVA().

mvaReaderCovU2_

const GBRForest* PFMETAlgorithmMVA::mvaReaderCovU2_

private

Definition at line 110 of file PFMETAlgorithmMVA.h.

Referenced by evaluateMVA(), initialize(), and ~PFMETAlgorithmMVA().

mvaReaderDPhi_

const GBRForest* PFMETAlgorithmMVA::mvaReaderDPhi_

private

Definition at line 108 of file PFMETAlgorithmMVA.h.

Referenced by evaluateMVA(), initialize(), and ~PFMETAlgorithmMVA().

mvaReaderU_

const GBRForest* PFMETAlgorithmMVA::mvaReaderU_

private

Definition at line 107 of file PFMETAlgorithmMVA.h.

Referenced by evaluateMVA(), initialize(), and ~PFMETAlgorithmMVA().

mvaType_

int PFMETAlgorithmMVA::mvaType_

private

Definition at line 74 of file PFMETAlgorithmMVA.h.

Referenced by PFMETAlgorithmMVA().

sumLeptonPx_

double PFMETAlgorithmMVA::sumLeptonPx_

private

Definition at line 98 of file PFMETAlgorithmMVA.h.

Referenced by computeMET(), evaluateMVA(), print(), and setInput().

sumLeptonPy_

double PFMETAlgorithmMVA::sumLeptonPy_

private

Definition at line 99 of file PFMETAlgorithmMVA.h.

Referenced by computeMET(), evaluateMVA(), print(), and setInput().

utils_

MvaMEtUtilities PFMETAlgorithmMVA::utils_

private

Definition at line 67 of file PFMETAlgorithmMVA.h.

Referenced by setInput().

var_

std::map<std::string, float> PFMETAlgorithmMVA::var_

private

Definition at line 81 of file PFMETAlgorithmMVA.h.

Referenced by computeMET(), createFloatVector(), evaluateMVA(), print(), and setInput().

varForCovU1_

std::vector<std::string> PFMETAlgorithmMVA::varForCovU1_

private

Definition at line 95 of file PFMETAlgorithmMVA.h.

Referenced by evaluateMVA(), and loadMVAfromFile().

varForCovU2_

std::vector<std::string> PFMETAlgorithmMVA::varForCovU2_

private

Definition at line 96 of file PFMETAlgorithmMVA.h.

Referenced by evaluateMVA(), and loadMVAfromFile().

varForDPhi_

std::vector<std::string> PFMETAlgorithmMVA::varForDPhi_

private

Definition at line 94 of file PFMETAlgorithmMVA.h.

Referenced by evaluateMVA(), and loadMVAfromFile().

varForU_

std::vector<std::string> PFMETAlgorithmMVA::varForU_

private

Definition at line 93 of file PFMETAlgorithmMVA.h.

Referenced by evaluateMVA(), and loadMVAfromFile().