PuppiAlgo Class Reference

#include <PuppiAlgo.h>

Public Member Functions
void	add (const PuppiCandidate &iParticle, const double &iVal, const unsigned int iAlgo)
int	algoId (unsigned int iAlgo) const
const std::vector< float > &	alphas ()
double	compute (std::vector< double > const &iVals, double iChi2) const
void	computeMedRMS (const unsigned int &iAlgo)
double	coneSize (unsigned int iAlgo) const
int	etaBins () const
double	etaMax (int i) const
double	etaMaxExtrap () const
double	etaMin (int i) const
void	fixAlgoEtaBin (int i_eta)
bool	isCharged (unsigned int iAlgo) const
double	median () const
double	neutralPt (double const iPUProxy) const
int	numAlgos () const
double	ptMin () const
	PuppiAlgo (edm::ParameterSet &iConfig)
void	reset ()
double	rms () const
	~PuppiAlgo ()

Static Public Member Functions
static void	fillDescriptionsPuppiAlgo (edm::ParameterSetDescription &desc)

Private Attributes
double	cur_Med
double	cur_NeutralPtMin
double	cur_NeutralPtSlope
double	cur_PtMin
double	cur_RMS
std::vector< bool >	fAdjust
std::vector< int >	fAlgoId
std::vector< bool >	fCharged
std::vector< int >	fCombId
std::vector< double >	fConeSize
std::vector< double >	fEtaMax
double	fEtaMaxExtrap
std::vector< double >	fEtaMin
std::vector< double >	fMean
std::vector< double >	fMedEtaSF
std::vector< double >	fMedian
std::vector< std::vector< double > >	fMedian_perEta
unsigned int	fNAlgos
std::vector< int >	fNCount
std::vector< double >	fNeutralPtMin
std::vector< double >	fNeutralPtSlope
std::vector< double >	fPtMin
std::vector< float >	fPups
std::vector< float >	fPupsPV
std::vector< double >	fRMS
std::vector< std::vector< double > >	fRMS_perEta
std::vector< double >	fRMSEtaSF
std::vector< double >	fRMSPtMin
std::vector< double >	fRMSScaleFactor

Detailed Description

Definition at line 10 of file PuppiAlgo.h.

Constructor & Destructor Documentation

PuppiAlgo()

PuppiAlgo::PuppiAlgo

(

edm::ParameterSet &

iConfig

)

Definition at line 8 of file PuppiAlgo.cc.

                                             {
  fEtaMin = iConfig.getParameter<std::vector<double>>("etaMin");
  fEtaMax = iConfig.getParameter<std::vector<double>>("etaMax");
  fPtMin = iConfig.getParameter<std::vector<double>>("ptMin");
  fNeutralPtMin = iConfig.getParameter<std::vector<double>>("MinNeutralPt");         // Weighted Neutral Pt Cut
  fNeutralPtSlope = iConfig.getParameter<std::vector<double>>("MinNeutralPtSlope");  // Slope vs #pv
  fRMSEtaSF = iConfig.getParameter<std::vector<double>>("RMSEtaSF");
  fMedEtaSF = iConfig.getParameter<std::vector<double>>("MedEtaSF");
  fEtaMaxExtrap = iConfig.getParameter<double>("EtaMaxExtrap");
 
  std::vector<edm::ParameterSet> lAlgos = iConfig.getParameter<std::vector<edm::ParameterSet>>("puppiAlgos");
  fNAlgos = lAlgos.size();
  //Uber Configurable Puppi
  std::vector<double> tmprms;
  std::vector<double> tmpmed;
 
  for (unsigned int i0 = 0; i0 < lAlgos.size(); i0++) {
    int pAlgoId = lAlgos[i0].getParameter<int>("algoId");
    bool pCharged = lAlgos[i0].getParameter<bool>("useCharged");
    bool pWeight0 = lAlgos[i0].getParameter<bool>("applyLowPUCorr");
    int pComb = lAlgos[i0].getParameter<int>("combOpt");                // 0=> add in chi2/1=>Multiply p-values
    double pConeSize = lAlgos[i0].getParameter<double>("cone");         // Min Pt when computing pt and rms
    double pRMSPtMin = lAlgos[i0].getParameter<double>("rmsPtMin");     // Min Pt when computing pt and rms
    double pRMSSF = lAlgos[i0].getParameter<double>("rmsScaleFactor");  // Additional Tuning parameter for Jokers
    fAlgoId.push_back(pAlgoId);
    fCharged.push_back(pCharged);
    fAdjust.push_back(pWeight0);
    fCombId.push_back(pComb);
    fConeSize.push_back(pConeSize);
    fRMSPtMin.push_back(pRMSPtMin);
    fRMSScaleFactor.push_back(pRMSSF);
    double pRMS = 0;
    double pMed = 0;
    double pMean = 0;
    int pNCount = 0;
    fRMS.push_back(pRMS);
    fMedian.push_back(pMed);
    fMean.push_back(pMean);
    fNCount.push_back(pNCount);
 
    tmprms.clear();
    tmpmed.clear();
    for (unsigned int j0 = 0; j0 < fEtaMin.size(); j0++) {
      tmprms.push_back(pRMS);
      tmpmed.push_back(pMed);
    }
    fRMS_perEta.push_back(tmprms);
    fMedian_perEta.push_back(tmpmed);
  }
 
  cur_PtMin = -99.;
  cur_NeutralPtMin = -99.;
  cur_NeutralPtSlope = -99.;
  cur_RMS = -99.;
  cur_Med = -99.;
}

References cur_Med, cur_NeutralPtMin, cur_NeutralPtSlope, cur_PtMin, cur_RMS, fAdjust, fAlgoId, fCharged, fCombId, fConeSize, fEtaMax, fEtaMaxExtrap, fEtaMin, fMean, fMedEtaSF, fMedian, fMedian_perEta, fNAlgos, fNCount, fNeutralPtMin, fNeutralPtSlope, fPtMin, fRMS, fRMS_perEta, fRMSEtaSF, fRMSPtMin, fRMSScaleFactor, and edm::ParameterSet::getParameter().

~PuppiAlgo()

PuppiAlgo::~PuppiAlgo

(

)

Definition at line 64 of file PuppiAlgo.cc.

                      {
  fPups.clear();
  fPupsPV.clear();
}

References fPups, and fPupsPV.

Member Function Documentation

add()

void PuppiAlgo::add	(	const PuppiCandidate &	iParticle,
		const double &	iVal,
		const unsigned int	iAlgo
	)

Definition at line 87 of file PuppiAlgo.cc.

                                                                                                 {
  if (iParticle.pt < fRMSPtMin[iAlgo])
    return;
  // Change from SRR : Previously used fastjet::PseudoJet::user_index to decide the particle type.
  // In CMSSW we use the user_index to specify the index in the input collection, so I invented
  // a new mechanism using the fastjet UserInfo functionality. Of course, it's still just an integer
  // but that interface could be changed (or augmented) if desired / needed.
  int puppi_id = iParticle.id;
  if (puppi_id == std::numeric_limits<int>::lowest()) {
    throw cms::Exception("PuppiRegisterNotSet") << "The puppi register is not set. This must be set before use.\n";
  }
 
  // added by Nhan -- for all eta regions, compute mean/RMS from the central charged PU
  if ((std::abs(iParticle.eta) < fEtaMaxExtrap) && (puppi_id == 2)) {
    fPups.push_back(iVal);
    fNCount[iAlgo]++;
  }
  // for the low PU case, correction.  for checking that the PU-only median will be below the PV particles
  if (std::abs(iParticle.eta) < fEtaMaxExtrap && (puppi_id == 1))
    fPupsPV.push_back(iVal);
}

References funct::abs(), PuppiCandidate::eta, Exception, fEtaMaxExtrap, fNCount, fPups, fPupsPV, fRMSPtMin, PuppiCandidate::id, and PuppiCandidate::pt.

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

algoId()

int PuppiAlgo::algoId ( unsigned int  iAlgo ) const

inline

Definition at line 30 of file PuppiAlgo.h.

{ return fAlgoId.at(iAlgo); }

References fAlgoId.

alphas()

const std::vector<float>& PuppiAlgo::alphas ( )

inline

Definition at line 22 of file PuppiAlgo.h.

{ return fPups; }

References fPups.

compute()

double PuppiAlgo::compute	(	std::vector< double > const &	iVals,
		double	iChi2
	)		const

Definition at line 183 of file PuppiAlgo.cc.

                                                                            {
  if (fAlgoId[0] == -1)
    return 1;
  double lVal = 0.;
  double lPVal = 1.;
  int lNDOF = 0;
  for (unsigned int i0 = 0; i0 < fNAlgos; i0++) {
    if (fNCount[i0] == 0)
      return 1.;                       //in the NoPU case return 1.
    if (fCombId[i0] == 1 && i0 > 0) {  //Compute the previous p-value so that p-values can be multiplieed
      double pPVal = ROOT::Math::chisquared_cdf(lVal, lNDOF);
      lPVal *= pPVal;
      lNDOF = 0;
      lVal = 0;
    }
    double pVal = iVals[i0];
    //Special Check for any algo with log(0)
    if (fAlgoId[i0] == 0 && iVals[i0] == 0)
      pVal = cur_Med;
    if (fAlgoId[i0] == 3 && iVals[i0] == 0)
      pVal = cur_Med;
    if (fAlgoId[i0] == 5 && iVals[i0] == 0)
      pVal = cur_Med;
    lVal += (pVal - cur_Med) * (fabs(pVal - cur_Med)) / cur_RMS / cur_RMS;
    lNDOF++;
    if (i0 == 0 && iChi2 != 0)
      lNDOF++;  //Add external Chi2 to first element
    if (i0 == 0 && iChi2 != 0)
      lVal += iChi2;  //Add external Chi2 to first element
  }
  //Top it off with the last calc
  lPVal *= ROOT::Math::chisquared_cdf(lVal, lNDOF);
  return lPVal;
}

References cur_Med, cur_RMS, fAlgoId, fCombId, fNAlgos, and fNCount.

computeMedRMS()

void PuppiAlgo::computeMedRMS

(

const unsigned int &

iAlgo

)

Definition at line 112 of file PuppiAlgo.cc.

                                                       {
  //std::cout << "fNCount[iAlgo] = " << fNCount[iAlgo] << std::endl;
  if (iAlgo >= fNAlgos)
    return;
  if (fNCount[iAlgo] == 0)
    return;
 
  // sort alphas
  int lNBefore = 0;
  for (unsigned int i0 = 0; i0 < iAlgo; i0++)
    lNBefore += fNCount[i0];
  std::sort(fPups.begin() + lNBefore, fPups.begin() + lNBefore + fNCount[iAlgo]);
 
  // in case you have alphas == 0
  int lNum0 = 0;
  for (int i0 = lNBefore; i0 < lNBefore + fNCount[iAlgo]; i0++) {
    if (fPups[i0] == 0)
      lNum0 = i0 - lNBefore;
  }
 
  // comput median, removed lCorr for now
  int lNHalfway = lNBefore + lNum0 + int(double(fNCount[iAlgo] - lNum0) * 0.50);
  fMedian[iAlgo] = fPups[lNHalfway];
  double lMed = fMedian[iAlgo];  //Just to make the readability easier
 
  int lNRMS = 0;
  for (int i0 = lNBefore; i0 < lNBefore + fNCount[iAlgo]; i0++) {
    fMean[iAlgo] += fPups[i0];
    if (fPups[i0] == 0)
      continue;
    // if(!fCharged[iAlgo] && fAdjust[iAlgo] && fPups[i0] > lMed) continue;
    if (fAdjust[iAlgo] && fPups[i0] > lMed)
      continue;
    lNRMS++;
    fRMS[iAlgo] += (fPups[i0] - lMed) * (fPups[i0] - lMed);
  }
  fMean[iAlgo] /= fNCount[iAlgo];
  if (lNRMS > 0)
    fRMS[iAlgo] /= lNRMS;
  if (fRMS[iAlgo] == 0)
    fRMS[iAlgo] = 1e-5;
  // here is the raw RMS
  fRMS[iAlgo] = sqrt(fRMS[iAlgo]);
 
  // some ways to do corrections to fRMS and fMedian
  fRMS[iAlgo] *= fRMSScaleFactor[iAlgo];
 
  if (fAdjust[iAlgo]) {
    //Adjust the p-value to correspond to the median
    int lNPV = 0;
    for (unsigned int i0 = 0; i0 < fPupsPV.size(); i0++)
      if (fPupsPV[i0] <= lMed)
        lNPV++;
    double lAdjust = double(lNPV) / double(lNPV + 0.5 * fNCount[iAlgo]);
    if (lAdjust > 0) {
      fMedian[iAlgo] -= sqrt(ROOT::Math::chisquared_quantile(lAdjust, 1.) * fRMS[iAlgo]);
      fRMS[iAlgo] -= sqrt(ROOT::Math::chisquared_quantile(lAdjust, 1.) * fRMS[iAlgo]);
    }
  }
 
  // fRMS_perEta[iAlgo]    *= cur_RMSEtaSF;
  // fMedian_perEta[iAlgo] *= cur_MedEtaSF;
 
  for (unsigned int j0 = 0; j0 < fEtaMin.size(); j0++) {
    fRMS_perEta[iAlgo][j0] = fRMS[iAlgo] * fRMSEtaSF[j0];
    fMedian_perEta[iAlgo][j0] = fMedian[iAlgo] * fMedEtaSF[j0];
  }
}

References MillePedeFileConverter_cfg::e, fAdjust, fEtaMin, fMean, fMedEtaSF, fMedian, fMedian_perEta, fNAlgos, fNCount, fPups, fPupsPV, fRMS, fRMS_perEta, fRMSEtaSF, fRMSScaleFactor, createfilelist::int, and mathSSE::sqrt().

coneSize()

double PuppiAlgo::coneSize ( unsigned int  iAlgo ) const

inline

Definition at line 32 of file PuppiAlgo.h.

{ return fConeSize.at(iAlgo); }

References fConeSize.

etaBins()

int PuppiAlgo::etaBins ( ) const

inline

Definition at line 24 of file PuppiAlgo.h.

{ return fEtaMin.size(); }

References fEtaMin.

etaMax()

double PuppiAlgo::etaMax ( int  i ) const

inline

Definition at line 26 of file PuppiAlgo.h.

{ return fEtaMax[i]; }

References fEtaMax, and mps_fire::i.

etaMaxExtrap()

double PuppiAlgo::etaMaxExtrap ( ) const

inline

Definition at line 38 of file PuppiAlgo.h.

{ return fEtaMaxExtrap; }

References fEtaMaxExtrap.

etaMin()

double PuppiAlgo::etaMin ( int  i ) const

inline

Definition at line 25 of file PuppiAlgo.h.

{ return fEtaMin[i]; }

References fEtaMin, and mps_fire::i.

fillDescriptionsPuppiAlgo()

void PuppiAlgo::fillDescriptionsPuppiAlgo ( edm::ParameterSetDescription &  desc )

static

Definition at line 218 of file PuppiAlgo.cc.

                                                                          {
  edm::ParameterSetDescription puppialgos;
  puppialgos.add<int>("algoId", 5);
  puppialgos.add<bool>("useCharged", false);
  puppialgos.add<bool>("applyLowPUCorr", false);
  puppialgos.add<int>("combOpt", 5);
  puppialgos.add<double>("cone", .4);
  puppialgos.add<double>("rmsPtMin", .1);
  puppialgos.add<double>("rmsScaleFactor", 1.0);
  std::vector<edm::ParameterSet> VPSetPuppiAlgos;
  edm::ParameterSet puppiset;
  puppiset.addParameter<int>("algoId", 5);
  puppiset.addParameter<bool>("useCharged", false);
  puppiset.addParameter<bool>("applyLowPUCorr", false);
  puppiset.addParameter<int>("combOpt", 5);
  puppiset.addParameter<double>("cone", .4);
  puppiset.addParameter<double>("rmsPtMin", .1);
  puppiset.addParameter<double>("rmsScaleFactor", 1.0);
  VPSetPuppiAlgos.push_back(puppiset);
 
  edm::ParameterSetDescription algos;
  algos.addVPSet("puppiAlgos", puppialgos, VPSetPuppiAlgos);
  std::vector<edm::ParameterSet> VPSetAlgos;
  edm::ParameterSet algosset;
  algos.add<std::vector<double>>("etaMin", {0.});
  algos.add<std::vector<double>>("etaMax", {2.5});
  algos.add<std::vector<double>>("ptMin", {0.});
  algos.add<std::vector<double>>("MinNeutralPt", {0.2});
  algos.add<std::vector<double>>("MinNeutralPtSlope", {0.015});
  algos.add<std::vector<double>>("RMSEtaSF", {1.0});
  algos.add<std::vector<double>>("MedEtaSF", {1.0});
  algos.add<double>("EtaMaxExtrap", 2.0);
  algosset.addParameter<std::vector<double>>("etaMin", {0.});
  algosset.addParameter<std::vector<double>>("etaMax", {2.5});
  algosset.addParameter<std::vector<double>>("ptMin", {0.});
  algosset.addParameter<std::vector<double>>("MinNeutralPt", {0.2});
  algosset.addParameter<std::vector<double>>("MinNeutralPtSlope", {0.015});
  algosset.addParameter<std::vector<double>>("RMSEtaSF", {1.0});
  algosset.addParameter<std::vector<double>>("MedEtaSF", {1.0});
  algosset.addParameter<double>("EtaMaxExtrap", 2.0);
  algosset.addParameter<std::vector<edm::ParameterSet>>("puppiAlgos", VPSetPuppiAlgos);
  VPSetAlgos.push_back(algosset);
  desc.addVPSet("algos", algos, VPSetAlgos);
}

References edm::ParameterSetDescription::add(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSet(), and hltPFPuppi_cfi::algos.

Referenced by PuppiProducer::fillDescriptions().

fixAlgoEtaBin()

void PuppiAlgo::fixAlgoEtaBin

(

int

i_eta

)

Definition at line 79 of file PuppiAlgo.cc.

                                       {
  cur_PtMin = fPtMin[i_eta];
  cur_NeutralPtMin = fNeutralPtMin[i_eta];
  cur_NeutralPtSlope = fNeutralPtSlope[i_eta];
  cur_RMS = fRMS_perEta[0][i_eta];     // 0 is number of algos within this eta bin
  cur_Med = fMedian_perEta[0][i_eta];  // 0 is number of algos within this eta bin
}

References cur_Med, cur_NeutralPtMin, cur_NeutralPtSlope, cur_PtMin, cur_RMS, fMedian_perEta, fNeutralPtMin, fNeutralPtSlope, fPtMin, and fRMS_perEta.

isCharged()

bool PuppiAlgo::isCharged ( unsigned int  iAlgo ) const

inline

Definition at line 31 of file PuppiAlgo.h.

{ return fCharged.at(iAlgo); }

References fCharged.

median()

double PuppiAlgo::median ( ) const

inline

Definition at line 36 of file PuppiAlgo.h.

{ return cur_Med; }

References cur_Med.

neutralPt()

double PuppiAlgo::neutralPt ( double const  iPUProxy ) const

inline

Definition at line 33 of file PuppiAlgo.h.

{ return cur_NeutralPtMin + iPUProxy * cur_NeutralPtSlope; }

References cur_NeutralPtMin, and cur_NeutralPtSlope.

numAlgos()

int PuppiAlgo::numAlgos ( ) const

inline

Definition at line 29 of file PuppiAlgo.h.

{ return fNAlgos; }

References fNAlgos.

ptMin()

double PuppiAlgo::ptMin ( ) const

inline

Definition at line 27 of file PuppiAlgo.h.

{ return cur_PtMin; }

References cur_PtMin.

reset()

void PuppiAlgo::reset

(

void

)

Definition at line 68 of file PuppiAlgo.cc.

                      {
  fPups.clear();
  fPupsPV.clear();
  for (unsigned int i0 = 0; i0 < fNAlgos; i0++) {
    fMedian[i0] = 0;
    fRMS[i0] = 0;
    fMean[i0] = 0;
    fNCount[i0] = 0;
  }
}

References fMean, fMedian, fNAlgos, fNCount, fPups, fPupsPV, and fRMS.

Referenced by MatrixReader.MatrixReader::__init__(), data_sources.json_list::next(), and MatrixReader.MatrixReader::showRaw().

rms()

double PuppiAlgo::rms ( ) const

inline

Definition at line 35 of file PuppiAlgo.h.

{ return cur_RMS; }

References cur_RMS.

Member Data Documentation

cur_Med

double PuppiAlgo::cur_Med

private

Definition at line 56 of file PuppiAlgo.h.

Referenced by compute(), fixAlgoEtaBin(), median(), and PuppiAlgo().

cur_NeutralPtMin

double PuppiAlgo::cur_NeutralPtMin

private

Definition at line 53 of file PuppiAlgo.h.

Referenced by fixAlgoEtaBin(), neutralPt(), and PuppiAlgo().

cur_NeutralPtSlope

double PuppiAlgo::cur_NeutralPtSlope

private

Definition at line 54 of file PuppiAlgo.h.

Referenced by fixAlgoEtaBin(), neutralPt(), and PuppiAlgo().

cur_PtMin

double PuppiAlgo::cur_PtMin

private

Definition at line 52 of file PuppiAlgo.h.

Referenced by fixAlgoEtaBin(), ptMin(), and PuppiAlgo().

cur_RMS

double PuppiAlgo::cur_RMS

private

Definition at line 55 of file PuppiAlgo.h.

Referenced by compute(), fixAlgoEtaBin(), PuppiAlgo(), and rms().

fAdjust

std::vector<bool> PuppiAlgo::fAdjust

private

Definition at line 67 of file PuppiAlgo.h.

Referenced by computeMedRMS(), and PuppiAlgo().

fAlgoId

std::vector<int> PuppiAlgo::fAlgoId

private

Definition at line 65 of file PuppiAlgo.h.

Referenced by algoId(), compute(), and PuppiAlgo().

fCharged

std::vector<bool> PuppiAlgo::fCharged

private

Definition at line 66 of file PuppiAlgo.h.

Referenced by isCharged(), and PuppiAlgo().

fCombId

std::vector<int> PuppiAlgo::fCombId

private

Definition at line 68 of file PuppiAlgo.h.

Referenced by compute(), and PuppiAlgo().

fConeSize

std::vector<double> PuppiAlgo::fConeSize

private

Definition at line 69 of file PuppiAlgo.h.

Referenced by coneSize(), and PuppiAlgo().

fEtaMax

std::vector<double> PuppiAlgo::fEtaMax

private

Definition at line 42 of file PuppiAlgo.h.

Referenced by etaMax(), and PuppiAlgo().

fEtaMaxExtrap

double PuppiAlgo::fEtaMaxExtrap

private

Definition at line 50 of file PuppiAlgo.h.

Referenced by add(), etaMaxExtrap(), and PuppiAlgo().

fEtaMin

std::vector<double> PuppiAlgo::fEtaMin

private

Definition at line 43 of file PuppiAlgo.h.

Referenced by computeMedRMS(), etaBins(), etaMin(), and PuppiAlgo().

fMean

std::vector<double> PuppiAlgo::fMean

private

Definition at line 72 of file PuppiAlgo.h.

Referenced by computeMedRMS(), PuppiAlgo(), and reset().

fMedEtaSF

std::vector<double> PuppiAlgo::fMedEtaSF

private

Definition at line 49 of file PuppiAlgo.h.

Referenced by computeMedRMS(), and PuppiAlgo().

fMedian

std::vector<double> PuppiAlgo::fMedian

private

Definition at line 59 of file PuppiAlgo.h.

Referenced by computeMedRMS(), PuppiAlgo(), and reset().

fMedian_perEta

std::vector<std::vector<double> > PuppiAlgo::fMedian_perEta

private

Definition at line 61 of file PuppiAlgo.h.

Referenced by computeMedRMS(), fixAlgoEtaBin(), and PuppiAlgo().

fNAlgos

unsigned int PuppiAlgo::fNAlgos

private

Definition at line 41 of file PuppiAlgo.h.

Referenced by compute(), computeMedRMS(), numAlgos(), PuppiAlgo(), and reset().

fNCount

std::vector<int> PuppiAlgo::fNCount

private

Definition at line 73 of file PuppiAlgo.h.

Referenced by add(), compute(), computeMedRMS(), PuppiAlgo(), and reset().

fNeutralPtMin

std::vector<double> PuppiAlgo::fNeutralPtMin

private

Definition at line 45 of file PuppiAlgo.h.

Referenced by fixAlgoEtaBin(), and PuppiAlgo().

fNeutralPtSlope

std::vector<double> PuppiAlgo::fNeutralPtSlope

private

Definition at line 46 of file PuppiAlgo.h.

Referenced by fixAlgoEtaBin(), and PuppiAlgo().

fPtMin

std::vector<double> PuppiAlgo::fPtMin

private

Definition at line 44 of file PuppiAlgo.h.

Referenced by fixAlgoEtaBin(), and PuppiAlgo().

fPups

std::vector<float> PuppiAlgo::fPups

private

Definition at line 63 of file PuppiAlgo.h.

Referenced by add(), alphas(), computeMedRMS(), reset(), and ~PuppiAlgo().

fPupsPV

std::vector<float> PuppiAlgo::fPupsPV

private

Definition at line 64 of file PuppiAlgo.h.

Referenced by add(), computeMedRMS(), reset(), and ~PuppiAlgo().

fRMS

std::vector<double> PuppiAlgo::fRMS

private

Definition at line 58 of file PuppiAlgo.h.

Referenced by computeMedRMS(), PuppiAlgo(), and reset().

fRMS_perEta

std::vector<std::vector<double> > PuppiAlgo::fRMS_perEta

private

Definition at line 60 of file PuppiAlgo.h.

Referenced by computeMedRMS(), fixAlgoEtaBin(), and PuppiAlgo().

fRMSEtaSF

std::vector<double> PuppiAlgo::fRMSEtaSF

private

Definition at line 48 of file PuppiAlgo.h.

Referenced by computeMedRMS(), and PuppiAlgo().

fRMSPtMin

std::vector<double> PuppiAlgo::fRMSPtMin

private

Definition at line 70 of file PuppiAlgo.h.

Referenced by add(), and PuppiAlgo().

fRMSScaleFactor

std::vector<double> PuppiAlgo::fRMSScaleFactor

private

Definition at line 71 of file PuppiAlgo.h.

Referenced by computeMedRMS(), and PuppiAlgo().