#include <LinearizedPuppiAlgo.h>

Inheritance diagram for l1tpf_impl::LinearizedPuppiAlgo:

Public Member Functions
void	doPUGlobals (const std::vector< Region > &rs, float npu, std::vector< float > &globals) const override

	LinearizedPuppiAlgo (const edm::ParameterSet &)

const std::vector< std::string > &	puGlobalNames () const override

void	runNeutralsPU (Region &r, float npu, const std::vector< float > &globals) const override

	~LinearizedPuppiAlgo () override

Public Member Functions inherited from l1tpf_impl::PuppiAlgo
void	doPUGlobals (const std::vector< Region > &rs, float npu, std::vector< float > &globals) const override

const std::vector< std::string > &	puGlobalNames () const override

	PuppiAlgo (const edm::ParameterSet &)

void	runNeutralsPU (Region &r, float npu, const std::vector< float > &globals) const override

	~PuppiAlgo () override

Public Member Functions inherited from l1tpf_impl::PUAlgoBase
virtual void	doVertexing (std::vector< Region > &rs, VertexAlgo algo, float &vz) const

	PUAlgoBase (const edm::ParameterSet &)

virtual void	runChargedPV (Region &r, float z0) const

virtual	~PUAlgoBase ()

Protected Member Functions
void	computePuppiWeights (Region &r, float npu, const std::vector< float > &alphaC, const std::vector< float > &alphaF) const

Protected Member Functions inherited from l1tpf_impl::PuppiAlgo
virtual void	computePuppiAlphas (const Region &r, std::vector< float > &alphaC, std::vector< float > &alphaF) const

virtual void	computePuppiMedRMS (const std::vector< Region > &rs, float &alphaCMed, float &alphaCRms, float &alphaFMed, float &alphaFRms) const

void	computePuppiWeights (Region &r, const std::vector< float > &alphaC, const std::vector< float > &alphaF, float alphaCMed, float alphaCRms, float alphaFMed, float alphaFRms) const

virtual void	fillPuppi (Region &r) const

Protected Attributes
std::vector< float >	puppiAlphaCrops_

std::vector< float >	puppiAlphaCropsPhotons_

std::vector< float >	puppiAlphaSlopes_

std::vector< float >	puppiAlphaSlopesPhotons_

std::vector< float >	puppiAlphaZeros_

std::vector< float >	puppiAlphaZerosPhotons_

std::vector< float >	puppiPriors_

std::vector< float >	puppiPriorsPhotons_

std::vector< float >	puppiPtSlopes_

std::vector< float >	puppiPtSlopesPhotons_

std::vector< float >	puppiPtZeros_

std::vector< float >	puppiPtZerosPhotons_

Protected Attributes inherited from l1tpf_impl::PuppiAlgo
std::vector< int16_t >	intPuppiEtaCuts_

std::vector< int16_t >	intPuppiPtCuts_

std::vector< int16_t >	intPuppiPtCutsPhotons_

float	puppiDr_

float	puppiDrMin_

std::vector< float >	puppiEtaCuts_

std::vector< float >	puppiPtCuts_

std::vector< float >	puppiPtCutsPhotons_

float	puppiPtMax_

bool	puppiUsingBareTracks_

Protected Attributes inherited from l1tpf_impl::PUAlgoBase
int	debug_

float	etaCharged_

bool	vtxAdaptiveCut_

float	vtxRes_

Additional Inherited Members
Public Types inherited from l1tpf_impl::PUAlgoBase
enum	VertexAlgo { VertexAlgo::Old, VertexAlgo::TP, VertexAlgo::External }
	global operations More...

Detailed Description

Definition at line 8 of file LinearizedPuppiAlgo.h.

Constructor & Destructor Documentation

LinearizedPuppiAlgo::LinearizedPuppiAlgo ( const edm::ParameterSet & iConfig )

Definition at line 19 of file LinearizedPuppiAlgo.cc.

References puppiAlphaCrops_, puppiAlphaCropsPhotons_, puppiAlphaSlopes_, puppiAlphaSlopesPhotons_, puppiAlphaZeros_, puppiAlphaZerosPhotons_, l1tpf_impl::PuppiAlgo::puppiEtaCuts_, puppiPriors_, puppiPriorsPhotons_, puppiPtSlopes_, puppiPtSlopesPhotons_, puppiPtZeros_, and puppiPtZerosPhotons_.

     : PuppiAlgo(iConfig),
       puppiPriors_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiPriors"))),
       puppiPriorsPhotons_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiPriorsPhotons"))),
       puppiPtSlopes_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiPtSlopes"))),
       puppiPtSlopesPhotons_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiPtSlopesPhotons"))),
       puppiPtZeros_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiPtZeros"))),
       puppiPtZerosPhotons_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiPtZerosPhotons"))),
       puppiAlphaSlopes_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiAlphaSlopes"))),
       puppiAlphaSlopesPhotons_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiAlphaSlopesPhotons"))),
       puppiAlphaZeros_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiAlphaZeros"))),
       puppiAlphaZerosPhotons_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiAlphaZerosPhotons"))),
       puppiAlphaCrops_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiAlphaCrops"))),
       puppiAlphaCropsPhotons_(vd2vf(iConfig.getParameter<std::vector<double>>("puppiAlphaCropsPhotons"))) {
   if (puppiPriors_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiPriors\n");
   if (puppiPtSlopes_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiPtSlopes\n");
   if (puppiPtZeros_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiPtZeros\n");
   if (puppiAlphaSlopes_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiAlphaSlopes\n");
   if (puppiAlphaZeros_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiAlphaZeros\n");
   if (puppiAlphaCrops_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiAlphaCrops\n");
   if (puppiPriorsPhotons_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiPriorsPhotons\n");
   if (puppiPtSlopesPhotons_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiPtSlopesPhotons\n");
   if (puppiPtZerosPhotons_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiPtZerosPhotons\n");
   if (puppiAlphaSlopesPhotons_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiAlphaSlopesPhotons\n");
   if (puppiAlphaZerosPhotons_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiAlphaZerosPhotons\n");
   if (puppiAlphaCropsPhotons_.size() != puppiEtaCuts_.size())
     throw cms::Exception("Configuration", "Mismatched lenght for puppiAlphaCropsPhotons\n");
 }

LinearizedPuppiAlgo::~LinearizedPuppiAlgo ( )

override

Definition at line 59 of file LinearizedPuppiAlgo.cc.

59 {}

Member Function Documentation

void LinearizedPuppiAlgo::computePuppiWeights	(	Region &	r,
		float	npu,
		const std::vector< float > &	alphaC,
		const std::vector< float > &	alphaF
	)		const

protected

Definition at line 75 of file LinearizedPuppiAlgo.cc.

References funct::abs(), alpha, central, l1t::PFCandidate::ChargedHadron, l1tpf_impl::PFParticle::chargedPV, dbgPrintf(), l1tpf_impl::PUAlgoBase::debug_, l1t::PFCandidate::Electron, l1tpf_impl::PUAlgoBase::etaCharged_, funct::exp(), validate-o2o-wbm::f, l1tpf_impl::Region::globalAbsEta(), l1tpf_impl::PFParticle::hwId, log, l1t::PFCandidate::Muon, np, AlCaHLTBitMon_ParallelJobs::p, l1tpf_impl::Region::pf, l1t::PFCandidate::Photon, bookConverter::prior, puppiAlphaCrops_, puppiAlphaCropsPhotons_, puppiAlphaSlopes_, puppiAlphaSlopesPhotons_, puppiAlphaZeros_, puppiAlphaZerosPhotons_, l1tpf_impl::PuppiAlgo::puppiEtaCuts_, puppiPriors_, puppiPriorsPhotons_, puppiPtSlopes_, puppiPtSlopesPhotons_, puppiPtZeros_, puppiPtZerosPhotons_, and l1tpf_impl::Region::relativeCoordinates.

Referenced by runNeutralsPU().

                                                                                     {
   if (debug_ && npu > 0)
     dbgPrintf("LinPup\t npu estimate %7.2f --> log(npu/200) = %+6.2f \n", npu, std::log(npu / 200.f));
   for (unsigned int ip = 0, np = r.pf.size(); ip < np; ++ip) {
     PFParticle &p = r.pf[ip];
     // charged
     if (p.hwId == l1t::PFCandidate::ChargedHadron || p.hwId == l1t::PFCandidate::Electron ||
         p.hwId == l1t::PFCandidate::Muon) {
       p.setPuppiW(p.chargedPV || p.hwId == l1t::PFCandidate::Muon ? 1.0 : 0);
       if (debug_ == 2)
         dbgPrintf(
             "LinPup\t charged id %1d pt %7.2f eta %+5.2f phi %+5.2f   fromPV %1d                                       "
             "                        --> puppi weight %.3f   puppi pt %7.2f \n",
             p.hwId,
             p.floatPt(),
             p.floatEta(),
             p.floatPhi(),
             p.chargedPV,
             p.floatPuppiW(),
             p.floatPt() * p.floatPuppiW());
       continue;
     }
     // neutral
     float absEta = r.relativeCoordinates ? r.globalAbsEta(p.floatEta()) : std::abs(p.floatEta());
     bool central = absEta < etaCharged_;  // FIXME could make a better integer implementation
     bool photon = (p.hwId == l1t::PFCandidate::Photon);
     // get alpha
     float alpha = central ? alphaC[ip] : alphaF[ip];
     alpha = (alpha > 0 ? std::log(alpha) : 0);
     // get eta bin
     unsigned int ietaBin = 0, lastBin = puppiEtaCuts_.size() - 1;
     while (ietaBin < lastBin && absEta > puppiEtaCuts_[ietaBin]) {
       ietaBin++;
     }
     float alphaZero = (photon ? puppiAlphaZerosPhotons_ : puppiAlphaZeros_)[ietaBin];
     float alphaSlope = (photon ? puppiAlphaSlopesPhotons_ : puppiAlphaSlopes_)[ietaBin];
     float alphaCrop = (photon ? puppiAlphaCropsPhotons_ : puppiAlphaCrops_)[ietaBin];
     float x2a = std::clamp(alphaSlope * (alpha - alphaZero), -alphaCrop, alphaCrop);
     // weight by pT
     float ptZero = (photon ? puppiPtZerosPhotons_ : puppiPtZeros_)[ietaBin];
     float ptSlope = (photon ? puppiPtSlopesPhotons_ : puppiPtSlopes_)[ietaBin];
     float x2pt = ptSlope * (p.floatPt() - ptZero);
     // weight by prior
     float prior = (photon ? puppiPriorsPhotons_ : puppiPriors_)[ietaBin];
     float x2prior = (npu > 0 ? std::log(npu / 200.f) : 0) + prior;
     // total
     float x2 = x2a + x2pt - x2prior;
     p.setPuppiW(1.0 / (1.0 + std::exp(-x2)));
     if (debug_ == 1 || debug_ == 2 || debug_ == int(10 + ietaBin))
       dbgPrintf(
           "LinPup\t neutral id %1d pt %7.2f eta %+5.2f phi %+5.2f   alpha %+6.2f   x2a %+5.2f   x2pt %+6.2f   x2prior "
           "%+6.2f -->  x2 %+6.2f --> puppi weight %.3f   puppi pt %7.2f \n",
           p.hwId,
           p.floatPt(),
           p.floatEta(),
           p.floatPhi(),
           alpha,
           x2a,
           x2pt,
           -x2prior,
           x2,
           p.floatPuppiW(),
           p.floatPt() * p.floatPuppiW());
   }
 }

void LinearizedPuppiAlgo::doPUGlobals	(	const std::vector< Region > &	rs,
		float	npu,
		std::vector< float > &	globals
	)		const

overridevirtual

Implements l1tpf_impl::PUAlgoBase.

Definition at line 65 of file LinearizedPuppiAlgo.cc.

                                                                                                              {
   globals.clear();
 }

const std::vector< std::string > & LinearizedPuppiAlgo::puGlobalNames ( ) const

overridevirtual

Reimplemented from l1tpf_impl::PUAlgoBase.

Definition at line 61 of file LinearizedPuppiAlgo.cc.

                                                                      {
   static const std::vector<std::string> names_{};
   return names_;
 }

void LinearizedPuppiAlgo::runNeutralsPU	(	Region &	r,
		float	npu,
		const std::vector< float > &	globals
	)		const

overridevirtual

Implements l1tpf_impl::PUAlgoBase.

Definition at line 68 of file LinearizedPuppiAlgo.cc.

References l1tpf_impl::PuppiAlgo::computePuppiAlphas(), computePuppiWeights(), and l1tpf_impl::PuppiAlgo::fillPuppi().

                                                                                                    {
   std::vector<float> alphaC, alphaF;
   PuppiAlgo::computePuppiAlphas(r, alphaC, alphaF);
   computePuppiWeights(r, npu, alphaC, alphaF);
   PuppiAlgo::fillPuppi(r);
 }