#include <PFAlgo2HGC.h>

Inheritance diagram for l1tpf_impl::PFAlgo2HGC:

Public Member Functions
	PFAlgo2HGC (const edm::ParameterSet &)

void	runPF (Region &r) const override

Public Member Functions inherited from l1tpf_impl::PFAlgoBase
	PFAlgoBase (const edm::ParameterSet &)

virtual	~PFAlgoBase ()

Protected Types
enum	BadTrackStatus { BadTK_NoCalo = 1 }

enum	GoodTrackStatus { GoodTK_Calo_TkPt = 0, GoodTK_Calo_TkCaloPt = 1, GoodTk_Calo_CaloPt = 2, GoodTK_NoCalo = 3 }

enum	MuMatchMode { MuMatchMode::BoxBestByPtRatio, MuMatchMode::DrBestByPtRatio, MuMatchMode::DrBestByPtDiff }

enum	TkCaloLinkMetric { TkCaloLinkMetric::BestByDR = 0, TkCaloLinkMetric::BestByDRPt = 1, TkCaloLinkMetric::BestByDR2Pt2 = 2 }

Protected Member Functions
void	calo_relink (Region &r, const std::vector< int > &calo2ntk, const std::vector< float > &calo2sumtkpt, const std::vector< float > &calo2sumtkpterr) const
	try to recover split hadron showers (v1.0): More...

void	link_tk2calo (Region &r, std::vector< int > &tk2calo) const
	track to calo matching More...

void	link_tk2mu (Region &r, std::vector< int > &tk2mu, std::vector< int > &mu2tk) const
	do muon track linking (also sets track.muonLink) More...

void	linkedcalo_algo (Region &r, const std::vector< int > &calo2ntk, const std::vector< float > &calo2sumtkpt, const std::vector< float > &calo2sumtkpterr, std::vector< float > &calo2alpha) const
	process matched calo clusters, compare energy to sum track pt, compute track rescaling factor if needed More...

void	linkedtk_algo (Region &r, const std::vector< int > &tk2calo, const std::vector< int > &calo2ntk, const std::vector< float > &calo2alpha) const
	process matched tracks, if necessary rescale or average More...

void	save_muons (Region &r, const std::vector< int > &tk2mu) const
	save muons in output list More...

void	sum_tk2calo (Region &r, const std::vector< int > &tk2calo, std::vector< int > &calo2ntk, std::vector< float > &calo2sumtkpt, std::vector< float > &calo2sumtkpterr) const
	for each calo, compute the sum of the track pt More...

void	unlinkedcalo_algo (Region &r) const
	process unmatched calo clusters More...

void	unlinkedtk_algo (Region &r, const std::vector< int > &tk2calo) const
	promote unlinked low pt tracks to hadrons More...

Protected Member Functions inherited from l1tpf_impl::PFAlgoBase
PFParticle &	addCaloToPF (Region &r, const CaloCluster &calo) const

PFParticle &	addCaloToPF (std::vector< PFParticle > &pfs, const CaloCluster &calo) const

PFParticle &	addTrackToPF (Region &r, const PropagatedTrack &tk) const

PFParticle &	addTrackToPF (std::vector< PFParticle > &pfs, const PropagatedTrack &tk) const

void	initRegion (Region &r) const

Protected Attributes
float	caloReLinkDr_

bool	caloReLinkStep_

float	caloReLinkThreshold_

bool	caloTrkWeightedAverage_

float	drMatch_

float	drMatchMu_

bool	ecalPriority_

bool	emCaloUseAlsoCaloSigma_

float	maxInvisiblePt_

enum l1tpf_impl::PFAlgo2HGC::MuMatchMode	muMatchMode_

float	ptMatchHigh_

float	ptMatchLow_

bool	rescaleTracks_

bool	rescaleUnmatchedTrack_

bool	sumTkCaloErr2_

float	tightTrackMaxChi2_

float	tightTrackMaxInvisiblePt_

unsigned int	tightTrackMinStubs_

TkCaloLinkMetric	tkCaloLinkMetric_

bool	trackEmUseAlsoTrackSigma_

bool	useTrackCaloSigma_

Protected Attributes inherited from l1tpf_impl::PFAlgoBase
int	debug_

Detailed Description

Definition at line 7 of file PFAlgo2HGC.h.

Member Enumeration Documentation

◆ BadTrackStatus

enum l1tpf_impl::PFAlgo2HGC::BadTrackStatus

protected

Enumerator
BadTK_NoCalo

Definition at line 25 of file PFAlgo2HGC.h.

25 { BadTK_NoCalo = 1 };

l1tpf_impl::PFAlgo2HGC::BadTK_NoCalo

Definition: PFAlgo2HGC.h:25

◆ GoodTrackStatus

enum l1tpf_impl::PFAlgo2HGC::GoodTrackStatus

protected

Enumerator
GoodTK_Calo_TkPt
GoodTK_Calo_TkCaloPt
GoodTk_Calo_CaloPt
GoodTK_NoCalo

Definition at line 24 of file PFAlgo2HGC.h.

24 { GoodTK_Calo_TkPt = 0, GoodTK_Calo_TkCaloPt = 1, GoodTk_Calo_CaloPt = 2, GoodTK_NoCalo = 3 };

l1tpf_impl::PFAlgo2HGC::GoodTK_Calo_TkCaloPt

Definition: PFAlgo2HGC.h:24

l1tpf_impl::PFAlgo2HGC::GoodTK_NoCalo

Definition: PFAlgo2HGC.h:24

l1tpf_impl::PFAlgo2HGC::GoodTk_Calo_CaloPt

Definition: PFAlgo2HGC.h:24

l1tpf_impl::PFAlgo2HGC::GoodTK_Calo_TkPt

Definition: PFAlgo2HGC.h:24

◆ MuMatchMode

enum l1tpf_impl::PFAlgo2HGC::MuMatchMode

strongprotected

Enumerator
BoxBestByPtRatio
DrBestByPtRatio
DrBestByPtDiff

Definition at line 14 of file PFAlgo2HGC.h.

14 { BoxBestByPtRatio, DrBestByPtRatio, DrBestByPtDiff } muMatchMode_;

l1tpf_impl::PFAlgo2HGC::muMatchMode_

enum l1tpf_impl::PFAlgo2HGC::MuMatchMode muMatchMode_

◆ TkCaloLinkMetric

enum l1tpf_impl::PFAlgo2HGC::TkCaloLinkMetric

strongprotected

Enumerator
BestByDR
BestByDRPt
BestByDR2Pt2

Definition at line 17 of file PFAlgo2HGC.h.

17 { BestByDR = 0, BestByDRPt = 1, BestByDR2Pt2 = 2 };

Constructor & Destructor Documentation

◆ PFAlgo2HGC()

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

Definition at line 19 of file PFAlgo2HGC.cc.

References BestByDR, BestByDR2Pt2, BestByDRPt, BoxBestByPtRatio, caloReLinkDr_, caloReLinkStep_, caloReLinkThreshold_, caloTrkWeightedAverage_, l1tpf_impl::PFAlgoBase::debug_, DrBestByPtDiff, DrBestByPtRatio, drMatch_, drMatchMu_, ecalPriority_, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), maxInvisiblePt_, muMatchMode_, ptMatchHigh_, ptMatchLow_, rescaleTracks_, AlCaHLTBitMon_QueryRunRegistry::string, sumTkCaloErr2_, tightTrackMaxChi2_, tightTrackMaxInvisiblePt_, tightTrackMinStubs_, tkCaloLinkMetric_, and useTrackCaloSigma_.

                                                      : PFAlgoBase(iConfig) {
   debug_ = iConfig.getUntrackedParameter<int>("debugPFAlgo2HGC", iConfig.getUntrackedParameter<int>("debug", 0));
   edm::ParameterSet linkcfg = iConfig.getParameter<edm::ParameterSet>("linking");
   drMatchMu_ = linkcfg.getParameter<double>("trackMuDR");
 
   std::string muMatchMode = linkcfg.getParameter<std::string>("trackMuMatch");
   if (muMatchMode == "boxBestByPtRatio")
     muMatchMode_ = MuMatchMode::BoxBestByPtRatio;
   else if (muMatchMode == "drBestByPtRatio")
     muMatchMode_ = MuMatchMode::DrBestByPtRatio;
   else if (muMatchMode == "drBestByPtDiff")
     muMatchMode_ = MuMatchMode::DrBestByPtDiff;
   else
     throw cms::Exception("Configuration", "bad value for trackMuMatch configurable");
 
   std::string tkCaloLinkMetric = linkcfg.getParameter<std::string>("trackCaloLinkMetric");
   if (tkCaloLinkMetric == "bestByDR")
     tkCaloLinkMetric_ = TkCaloLinkMetric::BestByDR;
   else if (tkCaloLinkMetric == "bestByDRPt")
     tkCaloLinkMetric_ = TkCaloLinkMetric::BestByDRPt;
   else if (tkCaloLinkMetric == "bestByDR2Pt2")
     tkCaloLinkMetric_ = TkCaloLinkMetric::BestByDR2Pt2;
   else
     throw cms::Exception("Configuration", "bad value for tkCaloLinkMetric configurable");
 
   drMatch_ = linkcfg.getParameter<double>("trackCaloDR");
   ptMatchLow_ = linkcfg.getParameter<double>("trackCaloNSigmaLow");
   ptMatchHigh_ = linkcfg.getParameter<double>("trackCaloNSigmaHigh");
   useTrackCaloSigma_ = linkcfg.getParameter<bool>("useTrackCaloSigma");
   maxInvisiblePt_ = linkcfg.getParameter<double>("maxInvisiblePt");
 
   caloReLinkStep_ = linkcfg.getParameter<bool>("caloReLink");
   caloReLinkDr_ = linkcfg.getParameter<double>("caloReLinkDR");
   caloReLinkThreshold_ = linkcfg.getParameter<double>("caloReLinkThreshold");
   rescaleTracks_ = linkcfg.getParameter<bool>("rescaleTracks");
   caloTrkWeightedAverage_ = linkcfg.getParameter<bool>("useCaloTrkWeightedAverage");
   sumTkCaloErr2_ = linkcfg.getParameter<bool>("sumTkCaloErr2");
   ecalPriority_ = linkcfg.getParameter<bool>("ecalPriority");
   tightTrackMinStubs_ = linkcfg.getParameter<unsigned>("tightTrackMinStubs");
   tightTrackMaxChi2_ = linkcfg.getParameter<double>("tightTrackMaxChi2");
   tightTrackMaxInvisiblePt_ = linkcfg.getParameter<double>("tightTrackMaxInvisiblePt");
 }

Member Function Documentation

◆ calo_relink()

void PFAlgo2HGC::calo_relink	(	Region &	r,
		const std::vector< int > &	calo2ntk,
		const std::vector< float > &	calo2sumtkpt,
		const std::vector< float > &	calo2sumtkpterr
	)		const

protected

try to recover split hadron showers (v1.0):

OPTIONAL STEP: try to recover split hadron showers (v1.0):

Definition at line 408 of file PFAlgo2HGC.cc.

References caloReLinkDr_, caloReLinkThreshold_, dbgPrintf(), l1tpf_impl::PFAlgoBase::debug_, flavorHistoryFilter_cfi::dr, alignCSCRings::r, and useTrackCaloSigma_.

Referenced by runPF().

                                                                             {
   //     take hadrons that are not track matched, close by a hadron which has an excess of track pt vs calo pt
   //     add this pt to the calo pt of the other cluster
   //     off by default, as it seems to not do much in jets even if it helps remove tails in single-pion events
   std::vector<float> addtopt(r.calo.size(), 0);
   for (int ic = 0, nc = r.calo.size(); ic < nc; ++ic) {
     auto &calo = r.calo[ic];
     if (calo2ntk[ic] != 0 || calo.used || r.globalAbsEta(calo.floatEta()) > 2.5)
       continue;
     int i2best = -1;
     float drbest = caloReLinkDr_;
     for (int ic2 = 0; ic2 < nc; ++ic2) {
       const auto &calo2 = r.calo[ic2];
       if (calo2ntk[ic2] == 0 || calo2.used || r.globalAbsEta(calo2.floatEta()) > 2.5)
         continue;
       float dr = floatDR(calo, calo2);
       //if (debug_ && dr < 0.5) dbgPrintf("PFAlgo2HGC \t calo  %3d (pt %7.2f) with no tracks is at dr %.3f from calo %3d with pt %7.2f (sum tk pt %7.2f), track excess %7.2f +- %7.2f\n", ic, calo.floatPt(), dr, ic2, calo2.floatPt(), calo2sumtkpt[ic2], calo2sumtkpt[ic2] - calo2.floatPt(), useTrackCaloSigma_ ? calo2sumtkpterr[ic2] : calo2.floatPtErr());
       if (dr < drbest) {
         float ptdiff =
             calo2sumtkpt[ic2] - calo2.floatPt() + (useTrackCaloSigma_ ? calo2sumtkpterr[ic2] : calo2.floatPtErr());
         if (ptdiff >= caloReLinkThreshold_ * calo.floatPt()) {
           i2best = ic2;
           drbest = dr;
         }
       }
     }
     if (i2best != -1) {
       const auto &calo2 = r.calo[i2best];
       if (debug_)
         dbgPrintf(
             "PFAlgo2HGC \t calo  %3d (pt %7.2f) with no tracks matched within dr %.3f with calo %3d with pt %7.2f (sum "
             "tk pt %7.2f), track excess %7.2f +- %7.2f\n",
             ic,
             calo.floatPt(),
             drbest,
             i2best,
             calo2.floatPt(),
             calo2sumtkpt[i2best],
             calo2sumtkpt[i2best] - calo2.floatPt(),
             useTrackCaloSigma_ ? calo2sumtkpterr[i2best] : calo2.floatPtErr());
       calo.used = true;
       addtopt[i2best] += calo.floatPt();
     }
   }
   // we do this at the end, so that the above loop is parallelizable
   for (int ic = 0, nc = r.calo.size(); ic < nc; ++ic) {
     if (addtopt[ic]) {
       auto &calo = r.calo[ic];
       if (debug_)
         dbgPrintf("PFAlgo2HGC \t calo  %3d (pt %7.2f, sum tk pt %7.2f) is increased to pt %7.2f after merging\n",
                   ic,
                   calo.floatPt(),
                   calo2sumtkpt[ic],
                   calo.floatPt() + addtopt[ic]);
       calo.setFloatPt(calo.floatPt() + addtopt[ic]);
     }
   }
 }

◆ link_tk2calo()

void PFAlgo2HGC::link_tk2calo	(	Region &	r,
		std::vector< int > &	tk2calo
	)		const

protected

track to calo matching

Definition at line 257 of file PFAlgo2HGC.cc.

References BestByDR, BestByDR2Pt2, BestByDRPt, dbgPrintf(), l1tpf_impl::PFAlgoBase::debug_, flavorHistoryFilter_cfi::dr, drMatch_, ptMatchLow_, alignCSCRings::r, and tkCaloLinkMetric_.

Referenced by runPF().

                                                                       {
   // track to calo matching (first iteration, with a lower bound on the calo pt; there may be another one later)
   for (int itk = 0, ntk = r.track.size(); itk < ntk; ++itk) {
     const auto &tk = r.track[itk];
     if (tk.muonLink || tk.used)
       continue;  // not necessary but just a waste of CPU otherwise
     float drbest = drMatch_, dptscale = 0;
     switch (tkCaloLinkMetric_) {
       case TkCaloLinkMetric::BestByDR:
         drbest = drMatch_;
         break;
       case TkCaloLinkMetric::BestByDRPt:
         drbest = 1.0;
         dptscale = drMatch_ / tk.floatCaloPtErr();
         break;
       case TkCaloLinkMetric::BestByDR2Pt2:
         drbest = 1.0;
         dptscale = drMatch_ / tk.floatCaloPtErr();
         break;
     }
     float minCaloPt = tk.floatPt() - ptMatchLow_ * tk.floatCaloPtErr();
     if (debug_)
       dbgPrintf(
           "PFAlgo2HGC \t track %3d (pt %7.2f) to be matched to calo, min pT %7.2f\n", itk, tk.floatPt(), minCaloPt);
     for (int ic = 0, nc = r.calo.size(); ic < nc; ++ic) {
       auto &calo = r.calo[ic];
       if (calo.used || calo.floatPt() <= minCaloPt)
         continue;
       float dr = floatDR(tk, calo), dq;
       switch (tkCaloLinkMetric_) {
         case TkCaloLinkMetric::BestByDR:
           if (dr < drbest) {
             tk2calo[itk] = ic;
             drbest = dr;
           }
           break;
         case TkCaloLinkMetric::BestByDRPt:
           dq = dr + std::max<float>(tk.floatPt() - calo.floatPt(), 0.) * dptscale;
           if (debug_ > 2 && dr < 0.3)
             dbgPrintf("PFAlgo2HGC \t\t\t track %3d (pt %7.2f) vs calo %3d (pt %7.2f): dr %.3f, dq %.3f\n",
                       itk,
                       tk.floatPt(),
                       ic,
                       calo.floatPt(),
                       dr,
                       dq);
           if (dr < drMatch_ && dq < drbest) {
             tk2calo[itk] = ic;
             drbest = dq;
           }
           break;
         case TkCaloLinkMetric::BestByDR2Pt2:
           dq = hypot(dr, std::max<float>(tk.floatPt() - calo.floatPt(), 0.) * dptscale);
           if (debug_ > 2 && dr < 0.3)
             dbgPrintf("PFAlgo2HGC \t\t\t track %3d (pt %7.2f) vs calo %3d (pt %7.2f): dr %.3f, dq %.3f\n",
                       itk,
                       tk.floatPt(),
                       ic,
                       calo.floatPt(),
                       dr,
                       dq);
           if (dr < drMatch_ && dq < drbest) {
             tk2calo[itk] = ic;
             drbest = dq;
           }
           break;
       }
     }
     if (debug_ && tk2calo[itk] != -1)
       dbgPrintf("PFAlgo2HGC \t track %3d (pt %7.2f) matches to calo %3d (pt %7.2f) with dist %.3f (dr %.3f)\n",
                 itk,
                 tk.floatPt(),
                 tk2calo[itk],
                 r.calo[tk2calo[itk]].floatPt(),
                 drbest,
                 floatDR(tk, r.calo[tk2calo[itk]]));
     // now we re-do this for debugging sake, it may be done for real later
     if (debug_ && tk2calo[itk] == -1) {
       int ibest = -1;
       drbest = 0.3;
       for (int ic = 0, nc = r.calo.size(); ic < nc; ++ic) {
         auto &calo = r.calo[ic];
         if (calo.used)
           continue;
         float dr = floatDR(tk, calo);
         if (dr < drbest) {
           ibest = ic;
           drbest = dr;
         }
       }
       if (ibest != -1)
         dbgPrintf(
             "PFAlgo2HGC \t track %3d (pt %7.2f) would match to calo %3d (pt %7.2f) with dr %.3f if the pt min and dr "
             "requirement had been relaxed\n",
             itk,
             tk.floatPt(),
             ibest,
             r.calo[ibest].floatPt(),
             drbest);
     }
   }
 }

◆ link_tk2mu()

void PFAlgo2HGC::link_tk2mu	(	Region &	r,
		std::vector< int > &	tk2mu,
		std::vector< int > &	mu2tk
	)		const

protected

do muon track linking (also sets track.muonLink)

Definition at line 167 of file PFAlgo2HGC.cc.

References funct::abs(), BoxBestByPtRatio, reco::ceil(), dbgPrintf(), l1tpf_impl::PFAlgoBase::debug_, PbPb_ZMuSkimMuonDPG_cff::deltaR, HLT_2022v12_cff::distance, flavorHistoryFilter_cfi::dr, DrBestByPtDiff, DrBestByPtRatio, drMatchMu_, M_PI, amptDefaultParameters_cff::mu, muMatchMode_, convertSQLiteXML::ok, alignCSCRings::r, and mathSSE::sqrt().

Referenced by runPF().

                                                                                          {
   // do a rectangular match for the moment; make a box of the same are as a 0.2 cone
   int intDrMuonMatchBox = std::ceil(drMatchMu_ * CaloCluster::ETAPHI_SCALE * std::sqrt(M_PI / 4));
   for (int itk = 0, ntk = r.track.size(); itk < ntk; ++itk) {
     tk2mu[itk] = false;
   }
   for (int imu = 0, nmu = r.muon.size(); imu < nmu; ++imu) {
     const auto &mu = r.muon[imu];
     if (debug_)
       dbgPrintf("PFAlgo2HGC \t muon  %3d (pt %7.2f, eta %+5.2f, phi %+5.2f) \n",
                 imu,
                 mu.floatPt(),
                 mu.floatEta(),
                 mu.floatPhi());
     float minDistance = 9e9;
     switch (muMatchMode_) {
       case MuMatchMode::BoxBestByPtRatio:
         minDistance = 4.;
         break;
       case MuMatchMode::DrBestByPtRatio:
         minDistance = 4.;
         break;
       case MuMatchMode::DrBestByPtDiff:
         minDistance = 0.5 * mu.floatPt();
         break;
     }
     int imatch = -1;
     for (int itk = 0, ntk = r.track.size(); itk < ntk; ++itk) {
       const auto &tk = r.track[itk];
       int deta = std::abs(mu.hwEta - tk.hwEta);
       int dphi = std::abs((mu.hwPhi - tk.hwPhi) % CaloCluster::PHI_WRAP);
       float dr = floatDR(mu, tk);
       float dpt = std::abs(mu.floatPt() - tk.floatPt());
       float dptr = (mu.hwPt > tk.hwPt ? mu.floatPt() / tk.floatPt() : tk.floatPt() / mu.floatPt());
       bool ok = false;
       float distance = 9e9;
       switch (muMatchMode_) {
         case MuMatchMode::BoxBestByPtRatio:
           ok = (deta < intDrMuonMatchBox) && (dphi < intDrMuonMatchBox);
           distance = dptr;
           break;
         case MuMatchMode::DrBestByPtRatio:
           ok = (dr < drMatchMu_);
           distance = dptr;
           break;
         case MuMatchMode::DrBestByPtDiff:
           ok = (dr < drMatchMu_);
           distance = dpt;
           break;
       }
       if (debug_ && dr < 0.4) {
         dbgPrintf(
             "PFAlgo2HGC \t\t possible match with track %3d (pt %7.2f, caloeta %+5.2f, calophi %+5.2f, dr %.2f, eta "
             "%+5.2f, phi %+5.2f, dr %.2f):  angular %1d, distance %.3f (vs %.3f)\n",
             itk,
             tk.floatPt(),
             tk.floatEta(),
             tk.floatPhi(),
             dr,
             tk.floatVtxEta(),
             tk.floatVtxPhi(),
             deltaR(mu.floatEta(), mu.floatPhi(), tk.floatVtxEta(), tk.floatVtxPhi()),
             (ok ? 1 : 0),
             distance,
             minDistance);
       }
       if (!ok)
         continue;
       // FIXME for the moment, we do the floating point matching in pt
       if (distance < minDistance) {
         minDistance = distance;
         imatch = itk;
       }
     }
     if (debug_ && imatch > -1)
       dbgPrintf("PFAlgo2HGC \t muon  %3d (pt %7.2f) linked to track %3d (pt %7.2f)\n",
                 imu,
                 mu.floatPt(),
                 imatch,
                 r.track[imatch].floatPt());
     if (debug_ && imatch == -1)
       dbgPrintf("PFAlgo2HGC \t muon  %3d (pt %7.2f) not linked to any track\n", imu, mu.floatPt());
     mu2tk[imu] = imatch;
     if (imatch > -1) {
       tk2mu[imatch] = imu;
       r.track[imatch].muonLink = true;
     }
   }
 }

◆ linkedcalo_algo()

void PFAlgo2HGC::linkedcalo_algo	(	Region &	r,
		const std::vector< int > &	calo2ntk,
		const std::vector< float > &	calo2sumtkpt,
		const std::vector< float > &	calo2sumtkpterr,
		std::vector< float > &	calo2alpha
	)		const

protected

process matched calo clusters, compare energy to sum track pt, compute track rescaling factor if needed

----------— next step (needs the previous) -------------—

Definition at line 472 of file PFAlgo2HGC.cc.

References l1tpf_impl::PFAlgoBase::addCaloToPF(), dbgPrintf(), l1tpf_impl::PFAlgoBase::debug_, ecalPriority_, SiStripPI::min, l1t::PFCandidate::NeutralHadron, AlCaHLTBitMon_ParallelJobs::p, l1t::PFCandidate::Photon, ptMatchHigh_, ptMatchLow_, alignCSCRings::r, rescaleTracks_, and useTrackCaloSigma_.

Referenced by runPF().

                                                                      {
   // process matched calo clusters, compare energy to sum track pt
   for (int ic = 0, nc = r.calo.size(); ic < nc; ++ic) {
     auto &calo = r.calo[ic];
     if (calo2ntk[ic] == 0 || calo.used)
       continue;
     float ptdiff = calo.floatPt() - calo2sumtkpt[ic];
     float pterr = useTrackCaloSigma_ ? calo2sumtkpterr[ic] : calo.floatPtErr();
     if (debug_)
       dbgPrintf(
           "PFAlgo2HGC \t calo  %3d (pt %7.2f +- %7.2f, empt %7.2f) has %2d tracks (sumpt %7.2f, sumpterr %7.2f), ptdif "
           "%7.2f +- %7.2f\n",
           ic,
           calo.floatPt(),
           calo.floatPtErr(),
           calo.floatEmPt(),
           calo2ntk[ic],
           calo2sumtkpt[ic],
           calo2sumtkpterr[ic],
           ptdiff,
           pterr);
     if (ptdiff > +ptMatchHigh_ * pterr) {
       if (ecalPriority_) {
         if (calo.floatEmPt() > 1) {
           float emptdiff = std::min(ptdiff, calo.floatEmPt());
           if (debug_)
             dbgPrintf(
                 "PFAlgo2HGC \t calo  %3d (pt %7.2f, empt %7.2f)    ---> make photon with pt %7.2f, reduce ptdiff to "
                 "%7.2f +- %7.2f\n",
                 ic,
                 calo.floatPt(),
                 calo.floatEmPt(),
                 emptdiff,
                 ptdiff - emptdiff,
                 pterr);
           auto &p = addCaloToPF(r, calo);
           p.setFloatPt(emptdiff);
           p.hwId = l1t::PFCandidate::Photon;
           ptdiff -= emptdiff;
         }
         if (ptdiff > 2) {
           if (debug_)
             dbgPrintf("PFAlgo2HGC \t calo  %3d (pt %7.2f, empt %7.2f)    ---> make also neutral hadron with pt %7.2f\n",
                       ic,
                       calo.floatPt(),
                       calo.floatEmPt(),
                       ptdiff);
           auto &p = addCaloToPF(r, calo);
           p.setFloatPt(ptdiff);
           p.hwId = l1t::PFCandidate::NeutralHadron;
         }
       } else {
         if (debug_)
           dbgPrintf("PFAlgo2HGC \t calo  %3d (pt %7.2f)    ---> promoted to neutral with pt %7.2f\n",
                     ic,
                     calo.floatPt(),
                     ptdiff);
         auto &p = addCaloToPF(r, calo);
         p.setFloatPt(ptdiff);
         calo.hwFlags = 0;
       }
     } else if (ptdiff > -ptMatchLow_ * pterr) {
       // nothing to do (weighted average happens when we process the tracks)
       calo.hwFlags = 1;
       if (debug_)
         dbgPrintf(
             "PFAlgo2HGC \t calo  %3d (pt %7.2f)    ---> to be deleted, will use tracks instead\n", ic, calo.floatPt());
     } else {
       // tracks overshoot, rescale to tracks to calo
       calo2alpha[ic] = rescaleTracks_ ? calo.floatPt() / calo2sumtkpt[ic] : 1.0;
       calo.hwFlags = 2;
       if (debug_ && rescaleTracks_)
         dbgPrintf("PFAlgo2HGC \t calo  %3d (pt %7.2f)    ---> tracks overshoot and will be scaled down by %.4f\n",
                   ic,
                   calo.floatPt(),
                   calo2alpha[ic]);
       if (debug_ && !rescaleTracks_)
         dbgPrintf("PFAlgo2HGC \t calo  %3d (pt %7.2f)    ---> tracks overshoot by %.4f\n",
                   ic,
                   calo.floatPt(),
                   calo2sumtkpt[ic] / calo.floatPt());
     }
     calo.used = true;
   }
 }

◆ linkedtk_algo()

void PFAlgo2HGC::linkedtk_algo	(	Region &	r,
		const std::vector< int > &	tk2calo,
		const std::vector< int > &	calo2ntk,
		const std::vector< float > &	calo2alpha
	)		const

protected

process matched tracks, if necessary rescale or average

Definition at line 563 of file PFAlgo2HGC.cc.

References l1tpf_impl::PFAlgoBase::addTrackToPF(), caloTrkWeightedAverage_, dbgPrintf(), l1tpf_impl::PFAlgoBase::debug_, l1t::PFCandidate::Electron, GoodTk_Calo_CaloPt, GoodTK_Calo_TkCaloPt, GoodTK_Calo_TkPt, createfilelist::int, AlCaHLTBitMon_ParallelJobs::p, funct::pow(), and alignCSCRings::r.

Referenced by runPF().

                                                                          {
   // process matched tracks, if necessary rescale or average
   for (int itk = 0, ntk = r.track.size(); itk < ntk; ++itk) {
     auto &tk = r.track[itk];
     if (tk2calo[itk] == -1 || tk.muonLink || tk.used)
       continue;
     auto &p = addTrackToPF(r, tk);
     tk.used = true;
     const auto &calo = r.calo[tk2calo[itk]];
     if (calo.isEM)
       p.hwId = l1t::PFCandidate::Electron;
     p.cluster.src = calo.src;
     if (calo.hwFlags == 1) {
       // can do weighted average if there's just one track
       if (calo2ntk[tk2calo[itk]] == 1 && caloTrkWeightedAverage_) {
         p.hwStatus = GoodTK_Calo_TkPt;
         float ptavg = tk.floatPt();
         if (tk.floatPtErr() > 0) {
           float wcalo = 1.0 / std::pow(tk.floatCaloPtErr(), 2);
           float wtk = 1.0 / std::pow(tk.floatPtErr(), 2);
           ptavg = (calo.floatPt() * wcalo + tk.floatPt() * wtk) / (wcalo + wtk);
           p.hwStatus = GoodTK_Calo_TkCaloPt;
         }
         p.setFloatPt(ptavg);
         if (debug_)
           dbgPrintf(
               "PFAlgo2HGC \t track %3d (pt %7.2f +- %7.2f) combined with calo %3d (pt %7.2f +- %7.2f (from tk) "
               "yielding candidate of pt %7.2f\n",
               itk,
               tk.floatPt(),
               tk.floatPtErr(),
               tk2calo[itk],
               calo.floatPt(),
               tk.floatCaloPtErr(),
               ptavg);
       } else {
         p.hwStatus = GoodTK_Calo_TkPt;
         if (debug_)
           dbgPrintf("PFAlgo2HGC \t track %3d (pt %7.2f) linked to calo %3d promoted to %s\n",
                     itk,
                     tk.floatPt(),
                     tk2calo[itk],
                     (p.hwId == l1t::PFCandidate::Electron ? "electron" : "charged hadron"));
       }
     } else if (calo.hwFlags == 2) {
       // must rescale
       p.setFloatPt(tk.floatPt() * calo2alpha[tk2calo[itk]]);
       p.hwStatus = GoodTk_Calo_CaloPt;
       if (debug_)
         dbgPrintf(
             "PFAlgo2HGC \t track %3d (pt %7.2f, stubs %2d chi2 %7.1f) linked to calo %3d promoted to %s with pt %7.2f "
             "after maybe rescaling\n",
             itk,
             tk.floatPt(),
             int(tk.hwStubs),
             tk.hwChi2 * 0.1f,
             tk2calo[itk],
             (p.hwId == l1t::PFCandidate::Electron ? "electron" : "charged hadron"),
             p.floatPt());
     }
   }
 }

◆ runPF()

void PFAlgo2HGC::runPF ( Region & r ) const

overridevirtual

-———— first step (can all go in parallel) -—————

-———— next step (needs the previous) ----————

----——— next step (needs the previous) -------——— OPTIONAL STEP: try to recover split hadron showers (v1.0):

-------—— next step (needs the previous) ----------——

----------— next step (needs the previous) -------------— process matched tracks, if necessary rescale or average

Implements l1tpf_impl::PFAlgoBase.

Definition at line 62 of file PFAlgo2HGC.cc.

References calo_relink(), caloReLinkStep_, dbgPrintf(), l1tpf_impl::PFAlgoBase::debug_, l1tpf_impl::PFAlgoBase::initRegion(), createfilelist::int, link_tk2calo(), link_tk2mu(), linkedcalo_algo(), linkedtk_algo(), amptDefaultParameters_cff::mu, alignCSCRings::r, save_muons(), sum_tk2calo(), unlinkedcalo_algo(), and unlinkedtk_algo().

                                       {
   initRegion(r);
 
 
   if (debug_) {
     dbgPrintf(
         "PFAlgo2HGC\nPFAlgo2HGC region eta [ %+5.2f , %+5.2f ], phi [ %+5.2f , %+5.2f ], fiducial eta [ %+5.2f , "
         "%+5.2f ], phi [ %+5.2f , %+5.2f ]\n",
         r.etaMin - r.etaExtra,
         r.etaMax + r.etaExtra,
         r.phiCenter - r.phiHalfWidth - r.phiExtra,
         r.phiCenter + r.phiHalfWidth + r.phiExtra,
         r.etaMin,
         r.etaMax,
         r.phiCenter - r.phiHalfWidth,
         r.phiCenter + r.phiHalfWidth);
     dbgPrintf(
         "PFAlgo2HGC \t N(track) %3lu   N(calo) %3lu   N(mu) %3lu\n", r.track.size(), r.calo.size(), r.muon.size());
     for (int itk = 0, ntk = r.track.size(); itk < ntk; ++itk) {
       const auto &tk = r.track[itk];
       dbgPrintf(
           "PFAlgo2HGC \t track %3d: pt %7.2f +- %5.2f  vtx eta %+5.2f  vtx phi %+5.2f  calo eta %+5.2f  calo phi "
           "%+5.2f  fid %1d  calo ptErr %7.2f stubs %2d chi2 %7.1f\n",
           itk,
           tk.floatPt(),
           tk.floatPtErr(),
           tk.floatVtxEta(),
           tk.floatVtxPhi(),
           tk.floatEta(),
           tk.floatPhi(),
           int(r.fiducialLocal(tk.floatEta(), tk.floatPhi())),
           tk.floatCaloPtErr(),
           int(tk.hwStubs),
           tk.hwChi2 * 0.1f);
     }
     for (int ic = 0, nc = r.calo.size(); ic < nc; ++ic) {
       auto &calo = r.calo[ic];
       dbgPrintf(
           "PFAlgo2HGC \t calo  %3d: pt %7.2f +- %5.2f  vtx eta %+5.2f  vtx phi %+5.2f  calo eta %+5.2f  calo phi "
           "%+5.2f  fid %1d  calo ptErr %7.2f em pt %7.2f isEM %1d \n",
           ic,
           calo.floatPt(),
           calo.floatPtErr(),
           calo.floatEta(),
           calo.floatPhi(),
           calo.floatEta(),
           calo.floatPhi(),
           int(r.fiducialLocal(calo.floatEta(), calo.floatPhi())),
           calo.floatPtErr(),
           calo.floatEmPt(),
           calo.isEM);
     }
     for (int im = 0, nm = r.muon.size(); im < nm; ++im) {
       auto &mu = r.muon[im];
       dbgPrintf(
           "PFAlgo2HGC \t muon  %3d: pt %7.2f           vtx eta %+5.2f  vtx phi %+5.2f  calo eta %+5.2f  calo phi "
           "%+5.2f  fid %1d\n",
           im,
           mu.floatPt(),
           mu.floatEta(),
           mu.floatPhi(),
           mu.floatEta(),
           mu.floatPhi(),
           int(r.fiducialLocal(mu.floatEta(), mu.floatPhi())));
     }
   }
 
   std::vector<int> tk2mu(r.track.size(), -1), mu2tk(r.muon.size(), -1);
   link_tk2mu(r, tk2mu, mu2tk);
 
   // track to calo matching (first iteration, with a lower bound on the calo pt; there may be another one later)
   std::vector<int> tk2calo(r.track.size(), -1);
   link_tk2calo(r, tk2calo);
 
   // for each calo, compute the sum of the track pt
   std::vector<int> calo2ntk(r.calo.size(), 0);
   std::vector<float> calo2sumtkpt(r.calo.size(), 0);
   std::vector<float> calo2sumtkpterr(r.calo.size(), 0);
   sum_tk2calo(r, tk2calo, calo2ntk, calo2sumtkpt, calo2sumtkpterr);
 
   // in the meantime, promote unlinked low pt tracks to hadrons
   unlinkedtk_algo(r, tk2calo);
 
   //     off by default, as it seems to not do much in jets even if it helps remove tails in single-pion events
   if (caloReLinkStep_)
     calo_relink(r, calo2ntk, calo2sumtkpt, calo2sumtkpterr);
 
   // process matched calo clusters, compare energy to sum track pt
   std::vector<float> calo2alpha(r.calo.size(), 1);
   linkedcalo_algo(r, calo2ntk, calo2sumtkpt, calo2sumtkpterr, calo2alpha);
 
   linkedtk_algo(r, tk2calo, calo2ntk, calo2alpha);
   // process unmatched calo clusters
   unlinkedcalo_algo(r);
   // finally do muons
   save_muons(r, tk2mu);
 }

◆ save_muons()

void PFAlgo2HGC::save_muons	(	Region &	r,
		const std::vector< int > &	tk2mu
	)		const

protected

save muons in output list

Definition at line 640 of file PFAlgo2HGC.cc.

References l1tpf_impl::PFAlgoBase::addTrackToPF(), dbgPrintf(), l1tpf_impl::PFAlgoBase::debug_, AlCaHLTBitMon_ParallelJobs::p, and alignCSCRings::r.

Referenced by runPF().

                                                                         {
   // finally do muons
   for (int itk = 0, ntk = r.track.size(); itk < ntk; ++itk) {
     if (r.track[itk].muonLink) {
       auto &p = addTrackToPF(r, r.track[itk]);
       p.muonsrc = r.muon[tk2mu[itk]].src;
       if (debug_)
         dbgPrintf("PFAlgo2HGC \t track %3d (pt %7.2f) promoted to muon.\n", itk, r.track[itk].floatPt());
     }
   }
 }

◆ sum_tk2calo()

void PFAlgo2HGC::sum_tk2calo	(	Region &	r,
		const std::vector< int > &	tk2calo,
		std::vector< int > &	calo2ntk,
		std::vector< float > &	calo2sumtkpt,
		std::vector< float > &	calo2sumtkpterr
	)		const

protected

for each calo, compute the sum of the track pt

Definition at line 360 of file PFAlgo2HGC.cc.

References funct::pow(), alignCSCRings::r, mathSSE::sqrt(), and sumTkCaloErr2_.

Referenced by runPF().

                                                                       {
   // for each calo, compute the sum of the track pt
   for (int ic = 0, nc = r.calo.size(); ic < nc; ++ic) {
     const auto &calo = r.calo[ic];
     if (r.globalAbsEta(calo.floatEta()) > 2.5)
       continue;
     for (int itk = 0, ntk = r.track.size(); itk < ntk; ++itk) {
       if (tk2calo[itk] == ic) {
         const auto &tk = r.track[itk];
         if (tk.muonLink || tk.used)
           continue;
         calo2ntk[ic]++;
         calo2sumtkpt[ic] += tk.floatPt();
         calo2sumtkpterr[ic] += std::pow(tk.floatCaloPtErr(), sumTkCaloErr2_ ? 2 : 1);
       }
     }
     if (sumTkCaloErr2_ && calo2sumtkpterr[ic] > 0)
       calo2sumtkpterr[ic] = std::sqrt(calo2sumtkpterr[ic]);
   }
 }

◆ unlinkedcalo_algo()

void PFAlgo2HGC::unlinkedcalo_algo ( Region & r ) const

protected

process unmatched calo clusters

Definition at line 629 of file PFAlgo2HGC.cc.

References l1tpf_impl::PFAlgoBase::addCaloToPF(), dbgPrintf(), l1tpf_impl::PFAlgoBase::debug_, and alignCSCRings::r.

Referenced by runPF().

                                                   {
   // process unmatched calo clusters
   for (int ic = 0, nc = r.calo.size(); ic < nc; ++ic) {
     if (!r.calo[ic].used) {
       addCaloToPF(r, r.calo[ic]);
       if (debug_)
         dbgPrintf("PFAlgo2HGC \t calo  %3d (pt %7.2f) not linked, promoted to neutral\n", ic, r.calo[ic].floatPt());
     }
   }
 }

◆ unlinkedtk_algo()

void PFAlgo2HGC::unlinkedtk_algo	(	Region &	r,
		const std::vector< int > &	tk2calo
	)		const

protected

promote unlinked low pt tracks to hadrons

Definition at line 385 of file PFAlgo2HGC.cc.

References l1tpf_impl::PFAlgoBase::addTrackToPF(), dbgPrintf(), l1tpf_impl::PFAlgoBase::debug_, GoodTK_NoCalo, maxInvisiblePt_, L1TPhase2Offline_cfi::maxPt, AlCaHLTBitMon_ParallelJobs::p, alignCSCRings::r, tightTrackMaxChi2_, tightTrackMaxInvisiblePt_, and tightTrackMinStubs_.

Referenced by runPF().

                                                                                {
   // in the meantime, promote unlinked low pt tracks to hadrons
   for (int itk = 0, ntk = r.track.size(); itk < ntk; ++itk) {
     auto &tk = r.track[itk];
     if (tk2calo[itk] != -1 || tk.muonLink || tk.used)
       continue;
     float maxPt = (tk.hwStubs >= tightTrackMinStubs_ && tk.hwChi2 < 10. * tightTrackMaxChi2_)
                       ? tightTrackMaxInvisiblePt_
                       : maxInvisiblePt_;
     if (tk.floatPt() < maxPt) {
       if (debug_)
         dbgPrintf(
             "PFAlgo2HGC \t track %3d (pt %7.2f) not matched to calo, kept as charged hadron\n", itk, tk.floatPt());
       auto &p = addTrackToPF(r, tk);
       p.hwStatus = GoodTK_NoCalo;
       tk.used = true;
     } else {
       if (debug_)
         dbgPrintf("PFAlgo2HGC \t track %3d (pt %7.2f) not matched to calo, dropped\n", itk, tk.floatPt());
     }
   }
 }

Member Data Documentation

◆ caloReLinkDr_

float l1tpf_impl::PFAlgo2HGC::caloReLinkDr_

protected

Definition at line 20 of file PFAlgo2HGC.h.

Referenced by calo_relink(), and PFAlgo2HGC().

◆ caloReLinkStep_

bool l1tpf_impl::PFAlgo2HGC::caloReLinkStep_

protected

Definition at line 19 of file PFAlgo2HGC.h.

Referenced by PFAlgo2HGC(), and runPF().

◆ caloReLinkThreshold_

float l1tpf_impl::PFAlgo2HGC::caloReLinkThreshold_

protected

Definition at line 20 of file PFAlgo2HGC.h.

Referenced by calo_relink(), and PFAlgo2HGC().

◆ caloTrkWeightedAverage_

bool l1tpf_impl::PFAlgo2HGC::caloTrkWeightedAverage_

protected

Definition at line 16 of file PFAlgo2HGC.h.

Referenced by linkedtk_algo(), and PFAlgo2HGC().

◆ drMatch_

float l1tpf_impl::PFAlgo2HGC::drMatch_

protected

Definition at line 15 of file PFAlgo2HGC.h.

Referenced by link_tk2calo(), and PFAlgo2HGC().

◆ drMatchMu_

float l1tpf_impl::PFAlgo2HGC::drMatchMu_

protected

Definition at line 13 of file PFAlgo2HGC.h.

Referenced by link_tk2mu(), and PFAlgo2HGC().

◆ ecalPriority_

bool l1tpf_impl::PFAlgo2HGC::ecalPriority_

protected

Definition at line 21 of file PFAlgo2HGC.h.

Referenced by linkedcalo_algo(), and PFAlgo2HGC().

◆ emCaloUseAlsoCaloSigma_

bool l1tpf_impl::PFAlgo2HGC::emCaloUseAlsoCaloSigma_

protected

Definition at line 21 of file PFAlgo2HGC.h.

◆ maxInvisiblePt_

float l1tpf_impl::PFAlgo2HGC::maxInvisiblePt_

protected

Definition at line 15 of file PFAlgo2HGC.h.

Referenced by PFAlgo2HGC(), and unlinkedtk_algo().

◆ muMatchMode_

enum l1tpf_impl::PFAlgo2HGC::MuMatchMode l1tpf_impl::PFAlgo2HGC::muMatchMode_

protected

Referenced by link_tk2mu(), and PFAlgo2HGC().

◆ ptMatchHigh_

float l1tpf_impl::PFAlgo2HGC::ptMatchHigh_

protected

Definition at line 15 of file PFAlgo2HGC.h.

Referenced by linkedcalo_algo(), and PFAlgo2HGC().

◆ ptMatchLow_

float l1tpf_impl::PFAlgo2HGC::ptMatchLow_

protected

Definition at line 15 of file PFAlgo2HGC.h.

Referenced by link_tk2calo(), linkedcalo_algo(), and PFAlgo2HGC().

◆ rescaleTracks_

bool l1tpf_impl::PFAlgo2HGC::rescaleTracks_

protected

Definition at line 21 of file PFAlgo2HGC.h.

Referenced by linkedcalo_algo(), and PFAlgo2HGC().

◆ rescaleUnmatchedTrack_

bool l1tpf_impl::PFAlgo2HGC::rescaleUnmatchedTrack_

protected

Definition at line 16 of file PFAlgo2HGC.h.

◆ sumTkCaloErr2_

bool l1tpf_impl::PFAlgo2HGC::sumTkCaloErr2_

protected

Definition at line 21 of file PFAlgo2HGC.h.

Referenced by PFAlgo2HGC(), and sum_tk2calo().

◆ tightTrackMaxChi2_

float l1tpf_impl::PFAlgo2HGC::tightTrackMaxChi2_

protected

Definition at line 23 of file PFAlgo2HGC.h.

Referenced by PFAlgo2HGC(), and unlinkedtk_algo().

◆ tightTrackMaxInvisiblePt_

float l1tpf_impl::PFAlgo2HGC::tightTrackMaxInvisiblePt_

protected

Definition at line 23 of file PFAlgo2HGC.h.

Referenced by PFAlgo2HGC(), and unlinkedtk_algo().

◆ tightTrackMinStubs_

unsigned int l1tpf_impl::PFAlgo2HGC::tightTrackMinStubs_

protected

Definition at line 22 of file PFAlgo2HGC.h.

Referenced by PFAlgo2HGC(), and unlinkedtk_algo().

◆ tkCaloLinkMetric_

TkCaloLinkMetric l1tpf_impl::PFAlgo2HGC::tkCaloLinkMetric_

protected

Definition at line 18 of file PFAlgo2HGC.h.

Referenced by link_tk2calo(), and PFAlgo2HGC().

◆ trackEmUseAlsoTrackSigma_

bool l1tpf_impl::PFAlgo2HGC::trackEmUseAlsoTrackSigma_

protected

Definition at line 21 of file PFAlgo2HGC.h.

◆ useTrackCaloSigma_

bool l1tpf_impl::PFAlgo2HGC::useTrackCaloSigma_

protected

Definition at line 16 of file PFAlgo2HGC.h.

Referenced by calo_relink(), linkedcalo_algo(), and PFAlgo2HGC().

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ BadTrackStatus

◆ GoodTrackStatus

◆ MuMatchMode

◆ TkCaloLinkMetric

Constructor & Destructor Documentation

◆ PFAlgo2HGC()

Member Function Documentation

◆ calo_relink()

◆ link_tk2calo()

◆ link_tk2mu()

◆ linkedcalo_algo()

◆ linkedtk_algo()

◆ runPF()

◆ save_muons()

◆ sum_tk2calo()

◆ unlinkedcalo_algo()

◆ unlinkedtk_algo()

Member Data Documentation

◆ caloReLinkDr_

◆ caloReLinkStep_

◆ caloReLinkThreshold_

◆ caloTrkWeightedAverage_

◆ drMatch_

◆ drMatchMu_

◆ ecalPriority_

◆ emCaloUseAlsoCaloSigma_

◆ maxInvisiblePt_

◆ muMatchMode_

◆ ptMatchHigh_

◆ ptMatchLow_

◆ rescaleTracks_

◆ rescaleUnmatchedTrack_

◆ sumTkCaloErr2_

◆ tightTrackMaxChi2_

◆ tightTrackMaxInvisiblePt_

◆ tightTrackMinStubs_

◆ tkCaloLinkMetric_

◆ trackEmUseAlsoTrackSigma_

◆ useTrackCaloSigma_