#include <PuppiContainer.h>

Public Member Functions
void	initialize (const std::vector< RecoObj > &iRecoObjects)

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

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

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

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

	PuppiContainer (const edm::ParameterSet &iConfig)

int	puppiNAlgos ()

std::vector< PuppiCandidate > const &	puppiParticles () const

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

std::vector< double > const &	puppiWeights ()

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

const std::vector< int > &	recoToPup () 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

bool	fInvert

int	fNAlgos

double	fNeutralMinPt

double	fNeutralSlope

int	fNPV

std::vector< PuppiCandidate >	fPFParticles

double	fPtMax

double	fPtMaxNeutralsStartSlope

std::vector< PuppiCandidate >	fPupParticles

std::vector< PuppiAlgo >	fPuppiAlgo

bool	fPuppiDiagnostics

double	fPuppiWeightCut

double	fPVFrac

std::vector< double >	fRawAlphas

const std::vector< RecoObj > *	fRecoParticles

std::vector< int >	fRecoToPup

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 ( const edm::ParameterSet & iConfig )

Definition at line 14 of file PuppiContainer.cc.

References edm::ParameterSet::getParameter().

                                                              {
     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");
     fPtMax           = 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);
     }
 }

PuppiContainer::~PuppiContainer ( )

Definition at line 82 of file PuppiContainer.cc.

82 {}

Member Function Documentation

double PuppiContainer::getChi2FromdZ ( double iDZ )

protected

Definition at line 219 of file PuppiContainer.cc.

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

Referenced by puppiParticles().

                                                {
     //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;
 }

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

protected

Definition at line 202 of file PuppiContainer.cc.

References funct::abs(), ALCARECOTkAlBeamHalo_cff::etaMax, ALCARECOTkAlBeamHalo_cff::etaMin, and ptMin.

Referenced by puppiParticles().

                                                         {
     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;
 }

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

protected

Definition at line 185 of file PuppiContainer.cc.

References edm::isFinite(), and LogDebug.

Referenced by puppiParticles().

                                                                                                                                                                                     {
     for(int j0 = 0; j0 < fNAlgos; j0++){
         for(unsigned int i0 = 0; i0 < iConstits.size(); i0++ ) {
             //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
             double const pVal = goodVar(iConstits[i0],pCharged ? iChargedParticles : iParticles,pAlgo,pCone);
             fRawAlphas.push_back(pVal);
             if( ! edm::isFinite(pVal)) {
                 LogDebug( "NotFound" )  << "====> Value is Nan " << pVal << " == " << iConstits[i0].pt << " -- " << iConstits[i0].eta << endl;
                 continue;
             }
         }
     }
 }

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.

References funct::abs(), PVValHelper::eta, edm::isFinite(), LogDebug, or, and EnergyCorrector::pt.

Referenced by puppiParticles().

                                                                                                                                                                                  {
     for(unsigned int i0 = 0; i0 < iConstits.size(); i0++ ) {
         //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:
         //  - calculate goodVar only for candidates that (1) will not be assigned a predefined weight (e.g 0, 1),
         //    or (2) are required for computations inside puppi-algos (see call to PuppiAlgo::add below)
         double pVal = -1;
         if (not(fApplyCHS and (iConstits[i0].id == 1 or iConstits[i0].id == 2))
             or (std::abs(iConstits[i0].eta) < fPuppiAlgo[pPupId].etaMaxExtrap() and iConstits[i0].puppi_register != 0)) {
           pVal = goodVar(iConstits[i0],pCharged ? iChargedParticles : iParticles,pAlgo,pCone);
         }
         fVals.push_back(pVal);
 
         if( ! edm::isFinite(pVal)) {
             LogDebug( "NotFound" )  << "====> Value is Nan " << pVal << " == " << iConstits[i0].pt << " -- " << iConstits[i0].eta << endl;
             continue;
         }
         
         // code added by Nhan: now instead for every algorithm give it all the particles
         for(int i1 = 0; i1 < fNAlgos; i1++){
             // skip cands outside of algo's etaMaxExtrap, as they would anyway be ignored inside PuppiAlgo::add (see end of the block)
             if(not(std::abs(iConstits[i0].eta) < fPuppiAlgo[i1].etaMaxExtrap() and iConstits[i0].puppi_register != 0))
               continue;
 
             auto curVal = pVal;
             // recompute goodVar if algo has changed
             if (i1 != pPupId) {
               pAlgo    = fPuppiAlgo[i1].algoId   (iOpt);
               pCharged = fPuppiAlgo[i1].isCharged(iOpt);
               pCone    = fPuppiAlgo[i1].coneSize (iOpt);
               curVal = goodVar(iConstits[i0],pCharged ? iChargedParticles : iParticles,pAlgo,pCone);
             }
 
             fPuppiAlgo[i1].add(iConstits[i0],curVal,iOpt);
         }
     }
     for(int i0 = 0; i0 < fNAlgos; i0++) fPuppiAlgo[i0].computeMedRMS(iOpt,fPVFrac);
 }

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

protected

Definition at line 84 of file PuppiContainer.cc.

Referenced by puppiParticles().

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

void PuppiContainer::initialize ( const std::vector< RecoObj > & iRecoObjects )

Definition at line 30 of file PuppiContainer.cc.

References funct::abs(), PuppiCandidate::e, PuppiCandidate::eta, PuppiCandidate::id, edm::isFinite(), PuppiCandidate::m, or, PuppiCandidate::phi, PuppiCandidate::pt, PuppiCandidate::puppi_register, PuppiCandidate::px, PuppiCandidate::py, PuppiCandidate::pz, and PuppiCandidate::rapidity.

                                                                       {
     //Clear everything
     fPFParticles  .resize(0);
     fChargedPV    .resize(0);
     fPupParticles .resize(0);
     fWeights      .resize(0);
     fVals.resize(0);
     fRawAlphas.resize(0);
     fAlphaMed     .resize(0);
     fAlphaRMS     .resize(0);
     fPVFrac = 0.;
     fNPV    = 1.;
     //Link to the RecoObjects
     fRecoParticles = &iRecoObjects;
     fPFParticles.reserve(iRecoObjects.size());
     fChargedPV.reserve(iRecoObjects.size());
     fRecoToPup.clear();
     fRecoToPup.reserve(fRecoParticles->size());
     for (auto const& rParticle : *fRecoParticles){
         // usage of fastjet::PseudoJet is only needed to enforce
         // the no-change policy for backports (no numerical differences in outputs)
         fastjet::PseudoJet curPseudoJet;
         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     
         }                   
         int puppi_register = 0;
         if(rParticle.id == 0 or rParticle.charge == 0)  puppi_register = 0; // zero is neutral hadron
         if(rParticle.id == 1 and rParticle.charge != 0) puppi_register = rParticle.charge; // from PV use the
         if(rParticle.id == 2 and rParticle.charge != 0) puppi_register = rParticle.charge+5; // from NPV use the charge as key +5 as key
         PuppiCandidate pCand;
         pCand.id = rParticle.id;
         pCand.puppi_register = puppi_register;
         pCand.pt = curPseudoJet.pt();
         pCand.rapidity = curPseudoJet.rap();
         pCand.eta = curPseudoJet.eta();
         pCand.phi = curPseudoJet.phi();
         pCand.m = curPseudoJet.m();
         pCand.px = curPseudoJet.px();
         pCand.py = curPseudoJet.py();
         pCand.pz = curPseudoJet.pz();
         pCand.e = curPseudoJet.E();
         // fill vector of pseudojets for internal references
         fPFParticles.push_back(pCand);
         //Take Charged particles associated to PV
         if(std::abs(rParticle.id) == 1) fChargedPV.push_back(pCand);
         if(std::abs(rParticle.id) >= 1 ) fPVFrac+=1.;
     }
     if (fPVFrac != 0) fPVFrac = double(fChargedPV.size())/fPVFrac;
     else fPVFrac = 0;
 }

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

inline

Definition at line 15 of file PuppiContainer.h.

References fPFParticles.

15 { return fPFParticles; }

PuppiContainer::fPFParticles

std::vector< PuppiCandidate > fPFParticles

Definition: PuppiContainer.h:38

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

inline

Definition at line 19 of file PuppiContainer.h.

References fVals.

19 { return fVals; }

PuppiContainer::fVals

std::vector< double > fVals

Definition: PuppiContainer.h:42

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

inline

Definition at line 21 of file PuppiContainer.h.

References fAlphaMed.

21 {return fAlphaMed;}

PuppiContainer::fAlphaMed

std::vector< double > fAlphaMed

Definition: PuppiContainer.h:44

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

inline

Definition at line 22 of file PuppiContainer.h.

References fAlphaRMS.

22 {return fAlphaRMS;}

PuppiContainer::fAlphaRMS

std::vector< double > fAlphaRMS

Definition: PuppiContainer.h:45

int PuppiContainer::puppiNAlgos ( )

inline

Definition at line 25 of file PuppiContainer.h.

References fNAlgos.

25 { return fNAlgos; }

PuppiContainer::fNAlgos

int fNAlgos

Definition: PuppiContainer.h:56

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

inline

Definition at line 26 of file PuppiContainer.h.

References fPupParticles, getChi2FromdZ(), getPuppiId(), getRawAlphas(), getRMSAvg(), goodVar(), HadronAndPartonSelector_cfi::particles, dttmaxenums::R, and var_within_R().

26 { return fPupParticles;}

PuppiContainer::fPupParticles

std::vector< PuppiCandidate > fPupParticles

Definition: PuppiContainer.h:40

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

inline

Definition at line 18 of file PuppiContainer.h.

References fRawAlphas.

18 { return fRawAlphas; }

PuppiContainer::fRawAlphas

std::vector< double > fRawAlphas

Definition: PuppiContainer.h:43

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

Definition at line 232 of file PuppiContainer.cc.

References PuppiCandidate::e, edm::isFinite(), LogDebug, PuppiCandidate::m, SiStripPI::max, pfDeepBoostedJetPreprocessParams_cfi::median, PuppiCandidate::pt, EnergyCorrector::pt, PuppiCandidate::px, PuppiCandidate::py, PuppiCandidate::pz, reset(), and SiStripPI::rms.

Referenced by pvParticles().

                                                        {
     int lNParticles    = fRecoParticles->size();
 
     fPupParticles .clear();
     fPupParticles.reserve(lNParticles);
     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(pWeight);
             fAlphaMed.push_back(-10);
             fAlphaRMS.push_back(-10);
             fRecoToPup.push_back(-1);
             continue;
         } else {
           fRecoToPup.push_back(fPupParticles.size());//watch out: there should be no skips after this
         }
         // 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(rParticle.pfType > 3) 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;
         //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
         if((fPtMax>0) && (rParticle.id == 0))
           pWeight =  std::clamp((fPFParticles[i0].pt - fPtMaxNeutralsStartSlope) / (fPtMax - 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; 
         
         //Produce
         PuppiCandidate curjet(fPFParticles[i0]);
         curjet.pt *= pWeight;
         curjet.m *= pWeight;
         curjet.px *= pWeight;
         curjet.py *= pWeight;
         curjet.pz *= pWeight;
         curjet.e *= pWeight;
 
         fPupParticles.push_back(curjet);
     }
     return fWeights;
 }

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

inline

Definition at line 16 of file PuppiContainer.h.

References fChargedPV, and puppiWeights().

16 { return fChargedPV; }

PuppiContainer::fChargedPV

std::vector< PuppiCandidate > fChargedPV

Definition: PuppiContainer.h:39

const std::vector<int>& PuppiContainer::recoToPup ( ) const

inline

Definition at line 23 of file PuppiContainer.h.

References fRecoToPup.

23 {return fRecoToPup;}

PuppiContainer::fRecoToPup

std::vector< int > fRecoToPup

Definition: PuppiContainer.h:46

void PuppiContainer::setNPV ( int iNPV )

inline

Definition at line 13 of file PuppiContainer.h.

References fNPV.

13 { fNPV = iNPV; }

PuppiContainer::fNPV

int fNPV

Definition: PuppiContainer.h:57

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

protected

Definition at line 88 of file PuppiContainer.cc.

References funct::abs(), reco::deltaR2(), PuppiCandidate::eta, cmsBatch::log, or, PuppiCandidate::phi, PuppiCandidate::pt, EnergyCorrector::pt, dttmaxenums::R, diffTwoXMLs::r2, PuppiCandidate::rapidity, and JetChargeProducer_cfi::var.

Referenced by puppiParticles().

                                                                                                                                   {
     if (iId == -1)
       return 1.;
 
     double const r2 = R * R;
     double var = 0.;
 
     for (auto const &cand : particles) {
       if (std::abs(cand.rapidity - centre.rapidity) < R) {
         auto const dr2y = reco::deltaR2(cand.rapidity, cand.phi, centre.rapidity, centre.phi);
         if (dr2y < r2) {
           auto const dr2 = reco::deltaR2(cand.eta, cand.phi, centre.eta, centre.phi);
           if (dr2 < 0.0001)
             continue;
           auto const pt = cand.pt;
           switch (iId) {
             case 5:
               var += (pt * pt / dr2);
               break;
             case 4:
               var += pt;
               break;
             case 3:
               var += (1. / dr2);
               break;
             case 2:
               var += (1. / dr2);
               break;
             case 1:
               var += pt;
               break;
             case 0:
               var += (pt / dr2);
               break;
           }
         }
       }
     }
 
     if ((var != 0.) and ((iId == 0) or (iId == 3) or (iId == 5)))
       var = log(var);
     else if (iId == 1)
       var += centre.pt;
 
     return var;
 }

Member Data Documentation

std::vector<double> PuppiContainer::fAlphaMed

protected

Definition at line 44 of file PuppiContainer.h.

Referenced by puppiAlphasMed().

std::vector<double> PuppiContainer::fAlphaRMS

protected

Definition at line 45 of file PuppiContainer.h.

Referenced by puppiAlphasRMS().

bool PuppiContainer::fApplyCHS

protected

Definition at line 48 of file PuppiContainer.h.

std::vector<PuppiCandidate> PuppiContainer::fChargedPV

protected

Definition at line 39 of file PuppiContainer.h.

Referenced by pvParticles().

bool PuppiContainer::fInvert

protected

Definition at line 49 of file PuppiContainer.h.

int PuppiContainer::fNAlgos

protected

Definition at line 56 of file PuppiContainer.h.

Referenced by puppiNAlgos().

double PuppiContainer::fNeutralMinPt

protected

Definition at line 51 of file PuppiContainer.h.

double PuppiContainer::fNeutralSlope

protected

Definition at line 52 of file PuppiContainer.h.

int PuppiContainer::fNPV

protected

Definition at line 57 of file PuppiContainer.h.

Referenced by setNPV().

std::vector<PuppiCandidate> PuppiContainer::fPFParticles

protected

Definition at line 38 of file PuppiContainer.h.

Referenced by pfParticles().

double PuppiContainer::fPtMax

protected

Definition at line 54 of file PuppiContainer.h.

double PuppiContainer::fPtMaxNeutralsStartSlope

protected

Definition at line 55 of file PuppiContainer.h.

std::vector<PuppiCandidate> PuppiContainer::fPupParticles

protected

Definition at line 40 of file PuppiContainer.h.

Referenced by puppiParticles().

std::vector<PuppiAlgo> PuppiContainer::fPuppiAlgo

protected

Definition at line 59 of file PuppiContainer.h.

bool PuppiContainer::fPuppiDiagnostics

protected

Definition at line 36 of file PuppiContainer.h.

double PuppiContainer::fPuppiWeightCut

protected

Definition at line 53 of file PuppiContainer.h.

double PuppiContainer::fPVFrac

protected

Definition at line 58 of file PuppiContainer.h.

std::vector<double> PuppiContainer::fRawAlphas

protected

Definition at line 43 of file PuppiContainer.h.

Referenced by puppiRawAlphas().

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

protected

Definition at line 37 of file PuppiContainer.h.

std::vector<int> PuppiContainer::fRecoToPup

protected

Definition at line 46 of file PuppiContainer.h.

Referenced by recoToPup().

bool PuppiContainer::fUseExp

protected

Definition at line 50 of file PuppiContainer.h.

std::vector<double> PuppiContainer::fVals

protected

Definition at line 42 of file PuppiContainer.h.

Referenced by puppiAlphas().

std::vector<double> PuppiContainer::fWeights

protected

Definition at line 41 of file PuppiContainer.h.

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation