PuppiContainer Class Reference

#include <PuppiContainer.h>

Public Member Functions
void	initialize (const std::vector< RecoObj > &iRecoObjects)
const std::vector< PuppiCandidate > &	pfParticles () const
const std::vector< double > &	puppiAlphas ()
const std::vector< double > &	puppiAlphasMed ()
const std::vector< double > &	puppiAlphasRMS ()
	PuppiContainer (const edm::ParameterSet &iConfig)
int	puppiNAlgos ()
const std::vector< double > &	puppiRawAlphas ()
const std::vector< double > &	puppiWeights ()
const std::vector< PuppiCandidate > &	pvParticles () const
void	setNPV (int iNPV)
	~PuppiContainer ()

Protected Member Functions
double	getChi2FromdZ (double iDZ)
int	getPuppiId (float iPt, float iEta)
void	getRawAlphas (int iOpt, std::vector< PuppiCandidate > const &iConstits, std::vector< PuppiCandidate > const &iParticles, std::vector< PuppiCandidate > const &iChargeParticles)
void	getRMSAvg (int iOpt, std::vector< PuppiCandidate > const &iConstits, std::vector< PuppiCandidate > const &iParticles, std::vector< PuppiCandidate > const &iChargeParticles)
double	goodVar (PuppiCandidate const &iPart, std::vector< PuppiCandidate > const &iParts, int iOpt, const double iRCone)
double	var_within_R (int iId, const std::vector< PuppiCandidate > &particles, const PuppiCandidate &centre, const double R)

Protected Attributes
std::vector< double >	fAlphaMed
std::vector< double >	fAlphaRMS
bool	fApplyCHS
std::vector< PuppiCandidate >	fChargedPV
double	fEtaMaxPhotons
bool	fInvert
int	fNAlgos
double	fNeutralMinPt
double	fNeutralSlope
int	fNPV
std::vector< PuppiCandidate >	fPFParticles
double	fPtMaxNeutrals
double	fPtMaxNeutralsStartSlope
double	fPtMaxPhotons
std::vector< PuppiAlgo >	fPuppiAlgo
bool	fPuppiDiagnostics
double	fPuppiWeightCut
double	fPVFrac
std::vector< double >	fRawAlphas
const std::vector< RecoObj > *	fRecoParticles
bool	fUseExp
std::vector< double >	fVals
std::vector< double >	fWeights

Detailed Description

Definition at line 8 of file PuppiContainer.h.

Constructor & Destructor Documentation

PuppiContainer()

PuppiContainer::PuppiContainer

(

const edm::ParameterSet &

iConfig

)

Definition at line 12 of file PuppiContainer.cc.

                                                             {
  fPuppiDiagnostics = iConfig.getParameter<bool>("puppiDiagnostics");
  fApplyCHS = iConfig.getParameter<bool>("applyCHS");
  fInvert = iConfig.getParameter<bool>("invertPuppi");
  fUseExp = iConfig.getParameter<bool>("useExp");
  fPuppiWeightCut = iConfig.getParameter<double>("MinPuppiWeight");
  fPtMaxPhotons = iConfig.getParameter<double>("PtMaxPhotons");
  fEtaMaxPhotons = iConfig.getParameter<double>("EtaMaxPhotons");
  fPtMaxNeutrals = iConfig.getParameter<double>("PtMaxNeutrals");
  fPtMaxNeutralsStartSlope = iConfig.getParameter<double>("PtMaxNeutralsStartSlope");
  std::vector<edm::ParameterSet> lAlgos = iConfig.getParameter<std::vector<edm::ParameterSet> >("algos");
  fNAlgos = lAlgos.size();
  for (unsigned int i0 = 0; i0 < lAlgos.size(); i0++) {
    PuppiAlgo pPuppiConfig(lAlgos[i0]);
    fPuppiAlgo.push_back(pPuppiConfig);
  }
}

References edm::ParameterSet::getParameter().

~PuppiContainer()

PuppiContainer::~PuppiContainer

(

)

Definition at line 66 of file PuppiContainer.cc.

{}

Member Function Documentation

getChi2FromdZ()

double PuppiContainer::getChi2FromdZ ( double  iDZ )

protected

Definition at line 230 of file PuppiContainer.cc.

                                               {
  //We need to obtain prob of PU + (1-Prob of LV)
  // Prob(LV) = Gaus(dZ,sigma) where sigma = 1.5mm  (its really more like 1mm)
  //double lProbLV = ROOT::Math::normal_cdf_c(std::abs(iDZ),0.2)*2.; //*2 is to do it double sided
  //Take iDZ to be corrected by sigma already
  double lProbLV = ROOT::Math::normal_cdf_c(std::abs(iDZ), 1.) * 2.;  //*2 is to do it double sided
  double lProbPU = 1 - lProbLV;
  if (lProbPU <= 0)
    lProbPU = 1e-16;  //Quick Trick to through out infs
  if (lProbPU >= 0)
    lProbPU = 1 - 1e-16;  //Ditto
  double lChi2PU = TMath::ChisquareQuantile(lProbPU, 1);
  lChi2PU *= lChi2PU;
  return lChi2PU;
}

References funct::abs(), and MillePedeFileConverter_cfg::e.

getPuppiId()

int PuppiContainer::getPuppiId ( float  iPt, float  iEta  )

protected

Definition at line 213 of file PuppiContainer.cc.

                                                    {
  int lId = -1;
  for (int i0 = 0; i0 < fNAlgos; i0++) {
    int nEtaBinsPerAlgo = fPuppiAlgo[i0].etaBins();
    for (int i1 = 0; i1 < nEtaBinsPerAlgo; i1++) {
      if ((std::abs(iEta) > fPuppiAlgo[i0].etaMin(i1)) && (std::abs(iEta) < fPuppiAlgo[i0].etaMax(i1))) {
        fPuppiAlgo[i0].fixAlgoEtaBin(i1);
        if (iPt > fPuppiAlgo[i0].ptMin()) {
          lId = i0;
          break;
        }
      }
    }
  }
  //if(lId == -1) std::cerr << "Error : Full fiducial range is not defined " << std::endl;
  return lId;
}

References funct::abs(), ALCARECOTkAlBeamHalo_cff::etaMax, ALCARECOTkAlBeamHalo_cff::etaMin, testProducerWithPsetDescEmpty_cfi::i1, L1TowerCalibrationProducer_cfi::iEta, and ptMin.

getRawAlphas()

void PuppiContainer::getRawAlphas ( int  iOpt, std::vector< PuppiCandidate > const &  iConstits, std::vector< PuppiCandidate > const &  iParticles, std::vector< PuppiCandidate > const &  iChargeParticles  )

protected

Definition at line 188 of file PuppiContainer.cc.

                                                                                      {
  for (int j0 = 0; j0 < fNAlgos; j0++) {
    for (unsigned int i0 = 0; i0 < iConstits.size(); i0++) {
      double pVal = -1;
      //Get the Puppi Sub Algo (given iteration)
      int pAlgo = fPuppiAlgo[j0].algoId(iOpt);
      bool pCharged = fPuppiAlgo[j0].isCharged(iOpt);
      double pCone = fPuppiAlgo[j0].coneSize(iOpt);
      //Compute the Puppi Metric
      if (!pCharged)
        pVal = goodVar(iConstits[i0], iParticles, pAlgo, pCone);
      if (pCharged)
        pVal = goodVar(iConstits[i0], iChargedParticles, pAlgo, pCone);
      fRawAlphas.push_back(pVal);
      if (!edm::isFinite(pVal)) {
        LogDebug("NotFound") << "====> Value is Nan " << pVal << " == " << iConstits[i0].pt() << " -- "
                             << iConstits[i0].eta() << endl;
        continue;
      }
    }
  }
}

References edm::isFinite(), and LogDebug.

getRMSAvg()

void PuppiContainer::getRMSAvg ( int  iOpt, std::vector< PuppiCandidate > const &  iConstits, std::vector< PuppiCandidate > const &  iParticles, std::vector< PuppiCandidate > const &  iChargeParticles  )

protected

Definition at line 136 of file PuppiContainer.cc.

                                                                                   {
  for (unsigned int i0 = 0; i0 < iConstits.size(); i0++) {
    double pVal = -1;
    //Calculate the Puppi Algo to use
    int pPupId = getPuppiId(iConstits[i0].pt(), iConstits[i0].eta());
    if (pPupId == -1 || fPuppiAlgo[pPupId].numAlgos() <= iOpt) {
      fVals.push_back(-1);
      continue;
    }
    //Get the Puppi Sub Algo (given iteration)
    int pAlgo = fPuppiAlgo[pPupId].algoId(iOpt);
    bool pCharged = fPuppiAlgo[pPupId].isCharged(iOpt);
    double pCone = fPuppiAlgo[pPupId].coneSize(iOpt);
    //Compute the Puppi Metric
    if (!pCharged)
      pVal = goodVar(iConstits[i0], iParticles, pAlgo, pCone);
    if (pCharged)
      pVal = goodVar(iConstits[i0], iChargedParticles, pAlgo, pCone);
    fVals.push_back(pVal);
    //if(std::isnan(pVal) || std::isinf(pVal)) cerr << "====> Value is Nan " << pVal << " == " << iConstits[i0].pt() << " -- " << iConstits[i0].eta() << endl;
    if (!edm::isFinite(pVal)) {
      LogDebug("NotFound") << "====> Value is Nan " << pVal << " == " << iConstits[i0].pt() << " -- "
                           << iConstits[i0].eta() << endl;
      continue;
    }
 
    // // fPuppiAlgo[pPupId].add(iConstits[i0],pVal,iOpt);
    //code added by Nhan, now instead for every algorithm give it all the particles
    for (int i1 = 0; i1 < fNAlgos; i1++) {
      pAlgo = fPuppiAlgo[i1].algoId(iOpt);
      pCharged = fPuppiAlgo[i1].isCharged(iOpt);
      pCone = fPuppiAlgo[i1].coneSize(iOpt);
      double curVal = -1;
      if (i1 != pPupId) {
        if (!pCharged)
          curVal = goodVar(iConstits[i0], iParticles, pAlgo, pCone);
        if (pCharged)
          curVal = goodVar(iConstits[i0], iChargedParticles, pAlgo, pCone);
      } else {  //no need to repeat the computation
        curVal = pVal;
      }
      //std::cout << "i1 = " << i1 << ", curVal = " << curVal << ", eta = " << iConstits[i0].eta() << ", pupID = " << pPupId << std::endl;
      fPuppiAlgo[i1].add(iConstits[i0], curVal, iOpt);
    }
  }
  for (int i0 = 0; i0 < fNAlgos; i0++)
    fPuppiAlgo[i0].computeMedRMS(iOpt);
}

References PVValHelper::eta, testProducerWithPsetDescEmpty_cfi::i1, edm::isFinite(), LogDebug, and DiDispStaMuonMonitor_cfi::pt.

goodVar()

double PuppiContainer::goodVar ( PuppiCandidate const &  iPart, std::vector< PuppiCandidate > const &  iParts, int  iOpt, const double  iRCone  )

protected

Definition at line 68 of file PuppiContainer.cc.

                                                    {
  return var_within_R(iOpt, iParts, iPart, iRCone);
}

initialize()

void PuppiContainer::initialize

(

const std::vector< RecoObj > &

iRecoObjects

)

Definition at line 30 of file PuppiContainer.cc.

                                                                      {
  //Clear everything
  fPFParticles.resize(0);
  fChargedPV.resize(0);
  fWeights.resize(0);
  fVals.resize(0);
  fRawAlphas.resize(0);
  fAlphaMed.resize(0);
  fAlphaRMS.resize(0);
  //fChargedNoPV.resize(0);
  //Link to the RecoObjects
  fPVFrac = 0.;
  fNPV = 1.;
  fRecoParticles = &iRecoObjects;
  for (auto const &rParticle : *fRecoParticles) {
    PuppiCandidate curPseudoJet;
    // float nom = sqrt((rParticle.m)*(rParticle.m) + (rParticle.pt)*(rParticle.pt)*(cosh(rParticle.eta))*(cosh(rParticle.eta))) + (rParticle.pt)*sinh(rParticle.eta);//hacked
    // float denom = sqrt((rParticle.m)*(rParticle.m) + (rParticle.pt)*(rParticle.pt));//hacked
    // float rapidity = log(nom/denom);//hacked
    if (edm::isFinite(rParticle.rapidity)) {
      curPseudoJet.reset_PtYPhiM(rParticle.pt, rParticle.rapidity, rParticle.phi, rParticle.m);  //hacked
    } else {
      curPseudoJet.reset_PtYPhiM(0, 99., 0, 0);  //skipping may have been a better choice
    }
    //curPseudoJet.reset_PtYPhiM(rParticle.pt,rParticle.eta,rParticle.phi,rParticle.m);
    // fill puppi_register
    curPseudoJet.set_info(rParticle.id);
    // fill vector of pseudojets for internal references
    fPFParticles.push_back(curPseudoJet);
    //Take Charged particles associated to PV
    if (std::abs(rParticle.id) == 1)
      fChargedPV.push_back(curPseudoJet);
    //if(rParticle.id == 3) _chargedNoPV.push_back(curPseudoJet);
    // if(fNPV < rParticle.vtxId) fNPV = rParticle.vtxId;
  }
}

References funct::abs(), edm::isFinite(), and PuppiCandidate::set_info().

pfParticles()

const std::vector<PuppiCandidate>& PuppiContainer::pfParticles ( ) const

inline

Definition at line 15 of file PuppiContainer.h.

{ return fPFParticles; }

References fPFParticles.

puppiAlphas()

const std::vector<double>& PuppiContainer::puppiAlphas ( )

inline

Definition at line 19 of file PuppiContainer.h.

{ return fVals; }

References fVals.

puppiAlphasMed()

const std::vector<double>& PuppiContainer::puppiAlphasMed ( )

inline

Definition at line 21 of file PuppiContainer.h.

{ return fAlphaMed; }

References fAlphaMed.

puppiAlphasRMS()

const std::vector<double>& PuppiContainer::puppiAlphasRMS ( )

inline

Definition at line 22 of file PuppiContainer.h.

{ return fAlphaRMS; }

References fAlphaRMS.

puppiNAlgos()

int PuppiContainer::puppiNAlgos ( )

inline

Definition at line 24 of file PuppiContainer.h.

{ return fNAlgos; }

References fNAlgos.

puppiRawAlphas()

const std::vector<double>& PuppiContainer::puppiRawAlphas ( )

inline

Definition at line 18 of file PuppiContainer.h.

{ return fRawAlphas; }

References fRawAlphas.

puppiWeights()

const std::vector< double > & PuppiContainer::puppiWeights

(

)

Definition at line 245 of file PuppiContainer.cc.

                                                      {
  int lNParticles = fRecoParticles->size();
 
  fWeights.clear();
  fWeights.reserve(lNParticles);
  fVals.clear();
  fVals.reserve(lNParticles);
  for (int i0 = 0; i0 < fNAlgos; i0++)
    fPuppiAlgo[i0].reset();
 
  int lNMaxAlgo = 1;
  for (int i0 = 0; i0 < fNAlgos; i0++)
    lNMaxAlgo = std::max(fPuppiAlgo[i0].numAlgos(), lNMaxAlgo);
  //Run through all compute mean and RMS
  for (int i0 = 0; i0 < lNMaxAlgo; i0++) {
    getRMSAvg(i0, fPFParticles, fPFParticles, fChargedPV);
  }
  if (fPuppiDiagnostics)
    getRawAlphas(0, fPFParticles, fPFParticles, fChargedPV);
 
  std::vector<double> pVals;
  pVals.reserve(lNParticles);
  for (int i0 = 0; i0 < lNParticles; i0++) {
    //Refresh
    pVals.clear();
    double pWeight = 1;
    //Get the Puppi Id and if ill defined move on
    const auto &rParticle = (*fRecoParticles)[i0];
    int pPupId = getPuppiId(rParticle.pt, rParticle.eta);
    if (pPupId == -1) {
      fWeights.push_back(0);
      fAlphaMed.push_back(-10);
      fAlphaRMS.push_back(-10);
      continue;
    }
 
    // fill the p-values
    double pChi2 = 0;
    if (fUseExp) {
      //Compute an Experimental Puppi Weight with delta Z info (very simple example)
      pChi2 = getChi2FromdZ(rParticle.dZ);
      //Now make sure Neutrals are not set
      if ((std::abs(rParticle.pdgId) == 22) || (std::abs(rParticle.pdgId) == 130))
        pChi2 = 0;
    }
    //Fill and compute the PuppiWeight
    int lNAlgos = fPuppiAlgo[pPupId].numAlgos();
    for (int i1 = 0; i1 < lNAlgos; i1++)
      pVals.push_back(fVals[lNParticles * i1 + i0]);
 
    pWeight = fPuppiAlgo[pPupId].compute(pVals, pChi2);
    //Apply the CHS weights
    if (rParticle.id == 1 && fApplyCHS)
      pWeight = 1;
    if (rParticle.id == 2 && fApplyCHS)
      pWeight = 0;
    //Apply weight of 1 for leptons if puppiNoLep
    if (rParticle.id == 3)
      pWeight = 1;
    //Basic Weight Checks
    if (!edm::isFinite(pWeight)) {
      pWeight = 0.0;
      LogDebug("PuppiWeightError") << "====> Weight is nan : " << pWeight << " : pt " << rParticle.pt
                                   << " -- eta : " << rParticle.eta << " -- Value" << fVals[i0]
                                   << " -- id :  " << rParticle.id << " --  NAlgos: " << lNAlgos << std::endl;
    }
    //Basic Cuts
    if (pWeight * fPFParticles[i0].pt() < fPuppiAlgo[pPupId].neutralPt(fNPV) && rParticle.id == 0)
      pWeight = 0;  //threshold cut on the neutral Pt
    // Protect high pT photons (important for gamma to hadronic recoil balance)
    if ((fPtMaxPhotons > 0) && (rParticle.pdgId == 22) && (std::abs(fPFParticles[i0].eta()) < fEtaMaxPhotons) &&
        (fPFParticles[i0].pt() > fPtMaxPhotons))
      pWeight = 1.;
    // Protect high pT neutrals
    else if ((fPtMaxNeutrals > 0) && (rParticle.id == 0))
      pWeight =
          std::clamp((fPFParticles[i0].pt() - fPtMaxNeutralsStartSlope) / (fPtMaxNeutrals - fPtMaxNeutralsStartSlope),
                     pWeight,
                     1.);
    if (pWeight < fPuppiWeightCut)
      pWeight = 0;  //==> Elminate the low Weight stuff
    if (fInvert)
      pWeight = 1. - pWeight;
    //std::cout << "rParticle.pt = " <<  rParticle.pt << ", rParticle.charge = " << rParticle.charge << ", rParticle.id = " << rParticle.id << ", weight = " << pWeight << std::endl;
 
    fWeights.push_back(pWeight);
    fAlphaMed.push_back(fPuppiAlgo[pPupId].median());
    fAlphaRMS.push_back(fPuppiAlgo[pPupId].rms());
    //Now get rid of the thrown out weights for the particle collection
 
    // leave these lines in, in case want to move eventually to having no 1-to-1 correspondence between puppi and pf cands
    // if( std::abs(pWeight) < std::numeric_limits<double>::denorm_min() ) continue; // this line seems not to work like it's supposed to...
    // if(std::abs(pWeight) <= 0. ) continue;
  }
  return fWeights;
}

References funct::abs(), testProducerWithPsetDescEmpty_cfi::i1, edm::isFinite(), LogDebug, SiStripPI::max, pfParticleNetPreprocessParams_cfi::median, DiDispStaMuonMonitor_cfi::pt, reset(), and SiStripPI::rms.

pvParticles()

const std::vector<PuppiCandidate>& PuppiContainer::pvParticles ( ) const

inline

Definition at line 16 of file PuppiContainer.h.

{ return fChargedPV; }

References fChargedPV.

setNPV()

void PuppiContainer::setNPV ( int  iNPV )

inline

Definition at line 13 of file PuppiContainer.h.

{ fNPV = iNPV; }

References fNPV.

var_within_R()

double PuppiContainer::var_within_R ( int  iId, const std::vector< PuppiCandidate > &  particles, const PuppiCandidate &  centre, const double  R  )

protected

Definition at line 75 of file PuppiContainer.cc.

                                                    {
  if (iId == -1)
    return 1;
 
  //this is a circle in rapidity-phi
  //it would make more sense to have var definition consistent
  //fastjet::Selector sel = fastjet::SelectorCircle(R);
  //sel.set_reference(centre);
  //the original code used Selector infrastructure: it is too heavy here
  //logic of SelectorCircle is preserved below
 
  vector<double> near_dR2s;
  near_dR2s.reserve(std::min(50UL, particles.size()));
  vector<double> near_pts;
  near_pts.reserve(std::min(50UL, particles.size()));
  const double r2 = R * R;
  for (auto const &part : particles) {
    if (part.puppi_register() == 3)
      continue;
    //squared_distance is in (y,phi) coords: rap() has faster access -> check it first
    if (std::abs(part.rap() - centre.rap()) < R && part.squared_distance(centre) < r2) {
      near_dR2s.push_back(reco::deltaR2(part, centre));
      near_pts.push_back(part.pt());
    }
  }
  double var = 0;
  //double lSumPt = 0;
  //if(iId == 1) for(auto  pt : near_pts) lSumPt += pt;
  auto nParts = near_dR2s.size();
  for (auto i = 0UL; i < nParts; ++i) {
    auto dr2 = near_dR2s[i];
    auto pt = near_pts[i];
    if (dr2 < 0.0001)
      continue;
    if (iId == 0)
      var += (pt / dr2);
    else if (iId == 1)
      var += pt;
    else if (iId == 2)
      var += (1. / dr2);
    else if (iId == 3)
      var += (1. / dr2);
    else if (iId == 4)
      var += pt;
    else if (iId == 5)
      var += (pt * pt / dr2);
  }
  if (iId == 1)
    var += centre.pt();  //Sum in a cone
  else if (iId == 0 && var != 0)
    var = log(var);
  else if (iId == 3 && var != 0)
    var = log(var);
  else if (iId == 5 && var != 0)
    var = log(var);
  return var;
}

References funct::abs(), reco::deltaR2(), mps_fire::i, dqm-mbProfile::log, min(), ecalTrigSettings_cff::particles, DiDispStaMuonMonitor_cfi::pt, dttmaxenums::R, diffTwoXMLs::r2, and trigObjTnPSource_cfi::var.

Member Data Documentation

fAlphaMed

std::vector<double> PuppiContainer::fAlphaMed

protected

Definition at line 50 of file PuppiContainer.h.

Referenced by puppiAlphasMed().

fAlphaRMS

std::vector<double> PuppiContainer::fAlphaRMS

protected

Definition at line 51 of file PuppiContainer.h.

Referenced by puppiAlphasRMS().

fApplyCHS

bool PuppiContainer::fApplyCHS

protected

Definition at line 53 of file PuppiContainer.h.

fChargedPV

std::vector<PuppiCandidate> PuppiContainer::fChargedPV

protected

Definition at line 46 of file PuppiContainer.h.

Referenced by pvParticles().

fEtaMaxPhotons

double PuppiContainer::fEtaMaxPhotons

protected

Definition at line 60 of file PuppiContainer.h.

fInvert

bool PuppiContainer::fInvert

protected

Definition at line 54 of file PuppiContainer.h.

fNAlgos

int PuppiContainer::fNAlgos

protected

Definition at line 63 of file PuppiContainer.h.

Referenced by puppiNAlgos().

fNeutralMinPt

double PuppiContainer::fNeutralMinPt

protected

Definition at line 56 of file PuppiContainer.h.

fNeutralSlope

double PuppiContainer::fNeutralSlope

protected

Definition at line 57 of file PuppiContainer.h.

fNPV

int PuppiContainer::fNPV

protected

Definition at line 64 of file PuppiContainer.h.

Referenced by setNPV().

fPFParticles

std::vector<PuppiCandidate> PuppiContainer::fPFParticles

protected

Definition at line 45 of file PuppiContainer.h.

Referenced by pfParticles().

fPtMaxNeutrals

double PuppiContainer::fPtMaxNeutrals

protected

Definition at line 61 of file PuppiContainer.h.

fPtMaxNeutralsStartSlope

double PuppiContainer::fPtMaxNeutralsStartSlope

protected

Definition at line 62 of file PuppiContainer.h.

fPtMaxPhotons

double PuppiContainer::fPtMaxPhotons

protected

Definition at line 59 of file PuppiContainer.h.

fPuppiAlgo

std::vector<PuppiAlgo> PuppiContainer::fPuppiAlgo

protected

Definition at line 66 of file PuppiContainer.h.

fPuppiDiagnostics

bool PuppiContainer::fPuppiDiagnostics

protected

Definition at line 43 of file PuppiContainer.h.

fPuppiWeightCut

double PuppiContainer::fPuppiWeightCut

protected

Definition at line 58 of file PuppiContainer.h.

fPVFrac

double PuppiContainer::fPVFrac

protected

Definition at line 65 of file PuppiContainer.h.

fRawAlphas

std::vector<double> PuppiContainer::fRawAlphas

protected

Definition at line 49 of file PuppiContainer.h.

Referenced by puppiRawAlphas().

fRecoParticles

const std::vector<RecoObj>* PuppiContainer::fRecoParticles

protected

Definition at line 44 of file PuppiContainer.h.

fUseExp

bool PuppiContainer::fUseExp

protected

Definition at line 55 of file PuppiContainer.h.

fVals

std::vector<double> PuppiContainer::fVals

protected

Definition at line 48 of file PuppiContainer.h.

Referenced by puppiAlphas().

fWeights

std::vector<double> PuppiContainer::fWeights

protected

Definition at line 47 of file PuppiContainer.h.