#include <HiFJGridEmptyAreaCalculator.h>

Inheritance diagram for HiFJGridEmptyAreaCalculator:

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

	~HiFJGridEmptyAreaCalculator () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	beginStream (edm::StreamID) override

void	endStream () override

void	produce (edm::Event &, const edm::EventSetup &) override

setting a new event
const double	twopi_ = 2 * M_PI
	information about the grid More...

double	ymin_
	internal parameters for grid More...

double	ymax_

double	dy_

double	dphi_

double	tileArea_

double	dyJet_

double	yminJet_

double	ymaxJet_

double	totalInboundArea_

double	etaminJet_

double	etamaxJet_

int	ny_

int	nphi_

int	ntotal_

int	ntotalJet_

int	nyJet_

double	gridWidth_
	input parameters More...

double	band_

int	hiBinCut_

bool	doCentrality_

bool	keepGridInfo_

std::vector< double >	rhoVsEta_

std::vector< double >	meanRhoVsEta_

std::vector< double >	etaMaxGrid_

std::vector< double >	etaMinGrid_

edm::EDGetTokenT< edm::View< reco::Jet > >	jetsToken_
	input tokens More...

edm::EDGetTokenT< reco::PFCandidateCollection >	pfCandsToken_

edm::EDGetTokenT< std::vector< double > >	mapEtaToken_

edm::EDGetTokenT< std::vector< double > >	mapRhoToken_

edm::EDGetTokenT< std::vector< double > >	mapRhoMToken_

edm::EDGetTokenT< int >	centralityBinToken_

void	setupGrid (double eta_min, double eta_max)
	configure the grid More...

void	setupGridJet (const reco::Jet *jet)

int	tileIndexJet (const reco::PFCandidate *pfCand)
	retrieve the grid cell index for a given PseudoJet More...

int	tileIndexEta (const reco::PFCandidate *pfCand)

int	tileIndexEtaJet (const reco::PFCandidate *pfCand)

int	tileIndexPhi (const reco::PFCandidate *pfCand)

int	numJetGridCells (std::vector< std::pair< int, int >> &indices)
	number of grid cells that overlap with jet constituents filling in the in between area More...

void	calculateAreaFractionOfJets (const edm::Event &iEvent, const edm::EventSetup &iSetup)

void	calculateGridRho (const edm::Event &iEvent, const edm::EventSetup &iSetup)

int	n_tiles ()

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 24 of file HiFJGridEmptyAreaCalculator.h.

Constructor & Destructor Documentation

◆ HiFJGridEmptyAreaCalculator()

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

explicit

Definition at line 16 of file HiFJGridEmptyAreaCalculator.cc.

References centralityBinToken_, dphi_, dy_, dyJet_, etamaxJet_, etaminJet_, edm::ParameterSet::getParameter(), jetsToken_, keepGridInfo_, mapEtaToken_, mapRhoMToken_, mapRhoToken_, nphi_, ntotal_, ntotalJet_, ny_, nyJet_, pfCandsToken_, tileArea_, totalInboundArea_, ymax_, ymaxJet_, ymin_, and yminJet_.

     : gridWidth_(iConfig.getParameter<double>("gridWidth")),
       band_(iConfig.getParameter<double>("bandWidth")),
       hiBinCut_(iConfig.getParameter<int>("hiBinCut")),
       doCentrality_(iConfig.getParameter<bool>("doCentrality")),
       keepGridInfo_(iConfig.getParameter<bool>("keepGridInfo")) {
   ymin_ = -99;
   ymax_ = -99;
   dy_ = -99;
   dphi_ = -99;
   tileArea_ = -99;
 
   dyJet_ = 99;
   yminJet_ = -99;
   ymaxJet_ = -99;
   totalInboundArea_ = -99;
   etaminJet_ = -99;
   etamaxJet_ = -99;
 
   ny_ = 0;
   nphi_ = 0;
   ntotal_ = 0;
 
   ntotalJet_ = 0;
   nyJet_ = 0;
 
   pfCandsToken_ = consumes<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("pfCandSource"));
   mapEtaToken_ = consumes<std::vector<double>>(iConfig.getParameter<edm::InputTag>("mapEtaEdges"));
   mapRhoToken_ = consumes<std::vector<double>>(iConfig.getParameter<edm::InputTag>("mapToRho"));
   mapRhoMToken_ = consumes<std::vector<double>>(iConfig.getParameter<edm::InputTag>("mapToRhoM"));
   jetsToken_ = consumes<edm::View<reco::Jet>>(iConfig.getParameter<edm::InputTag>("jetSource"));
   centralityBinToken_ = consumes<int>(iConfig.getParameter<edm::InputTag>("CentralityBinSrc"));
 
   //register your products
   produces<std::vector<double>>("mapEmptyCorrFac");
   produces<std::vector<double>>("mapToRhoCorr");
   produces<std::vector<double>>("mapToRhoMCorr");
   produces<std::vector<double>>("mapToRhoCorr1Bin");
   produces<std::vector<double>>("mapToRhoMCorr1Bin");
   //rho calculation on a grid using median
   if (keepGridInfo_) {
     produces<std::vector<double>>("mapRhoVsEtaGrid");
     produces<std::vector<double>>("mapMeanRhoVsEtaGrid");
     produces<std::vector<double>>("mapEtaMaxGrid");
     produces<std::vector<double>>("mapEtaMinGrid");
   }
 }

◆ ~HiFJGridEmptyAreaCalculator()

HiFJGridEmptyAreaCalculator::~HiFJGridEmptyAreaCalculator ( )

override

Definition at line 64 of file HiFJGridEmptyAreaCalculator.cc.

                                                           {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

◆ beginStream()

void HiFJGridEmptyAreaCalculator::beginStream ( edm::StreamID )

overrideprivate

Definition at line 444 of file HiFJGridEmptyAreaCalculator.cc.

444 {}

◆ calculateAreaFractionOfJets()

void HiFJGridEmptyAreaCalculator::calculateAreaFractionOfJets	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

private

calculates the area of jets that fall within the eta range by scaling kt areas using grid areas

Definition at line 227 of file HiFJGridEmptyAreaCalculator.cc.

References etamaxJet_, etaminJet_, iEvent, metsig::jet, METSignificanceParams_cfi::jeta, PDWG_EXODelayedJetMET_cff::jets, jetsToken_, numJetGridCells(), setupGridJet(), tileIndexEtaJet(), tileIndexPhi(), totalInboundArea_, and twopi_.

Referenced by produce().

                                                                                                                  {
   edm::Handle<edm::View<reco::Jet>> jets;
   iEvent.getByToken(jetsToken_, jets);
 
   //calculate jet kt area fraction inside boundary by grid
   totalInboundArea_ = 0;
 
   for (auto jet = jets->begin(); jet != jets->end(); ++jet) {
     if (jet->eta() < etaminJet_ || jet->eta() > etamaxJet_)
       continue;
 
     double areaKt = jet->jetArea();
     setupGridJet(&*jet);
     std::vector<std::pair<int, int>> pfIndicesJet;
     std::vector<std::pair<int, int>> pfIndicesJetInbound;
     int nConstitJet = 0;
     int nConstitJetInbound = 0;
     for (auto daughter : jet->getJetConstituentsQuick()) {
       auto pfCandidate = static_cast<const reco::PFCandidate*>(daughter);
 
       int jeta = tileIndexEtaJet(&*pfCandidate);
       int jphi = tileIndexPhi(&*pfCandidate);
       pfIndicesJet.push_back(std::make_pair(jphi, jeta));
       nConstitJet++;
       if (pfCandidate->eta() < etaminJet_ && pfCandidate->eta() > etamaxJet_)
         continue;
       pfIndicesJetInbound.push_back(std::make_pair(jphi, jeta));
       nConstitJetInbound++;
     }
 
     //if the jet is well within the eta range just add the area
     if (nConstitJet == nConstitJetInbound) {
       totalInboundArea_ += areaKt;
       continue;
     }
 
     //for jets that fall outside of eta range calculate fraction of area
     //inside the range with a grid
     int nthis = 0;
     if (nConstitJet > 0)
       nthis = numJetGridCells(pfIndicesJet);
 
     int nthisInbound = 0;
     if (nConstitJetInbound > 0)
       nthisInbound = numJetGridCells(pfIndicesJetInbound);
 
     double fractionArea = ((double)nthisInbound) / ((double)nthis);
     totalInboundArea_ += areaKt * fractionArea;
   }
 
   //divide by the total area in that range
   totalInboundArea_ /= ((etamaxJet_ - etaminJet_) * twopi_);
 
   //the fraction can still be greater than 1 because kt area fraction inside
   //the range can differ from what we calculated with the grid
   if (totalInboundArea_ > 1)
     totalInboundArea_ = 1;
 }

◆ calculateGridRho()

void HiFJGridEmptyAreaCalculator::calculateGridRho	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

private

Definition at line 171 of file HiFJGridEmptyAreaCalculator.cc.

References reco::LeafCandidate::eta(), iEvent, createfilelist::int, METSignificanceParams_cfi::jeta, meanRhoVsEta_, nphi_, ny_, pfCandsToken_, edm::Handle< T >::product(), reco::LeafCandidate::pt(), rhoVsEta_, jetUpdater_cfi::sort, tileArea_, tileIndexEta(), tileIndexPhi(), ymax_, and ymin_.

Referenced by produce().

                                                                                                       {
   vector<vector<double>> scalarPt(ny_, vector<double>(nphi_, 0.0));
 
   edm::Handle<reco::PFCandidateCollection> pfCands;
   iEvent.getByToken(pfCandsToken_, pfCands);
   const reco::PFCandidateCollection* pfCandidateColl = pfCands.product();
   for (unsigned icand = 0; icand < pfCandidateColl->size(); icand++) {
     const reco::PFCandidate pfCandidate = pfCandidateColl->at(icand);
     //use ony the particles within the eta range
     if (pfCandidate.eta() < ymin_ || pfCandidate.eta() > ymax_)
       continue;
     int jeta = tileIndexEta(&pfCandidate);
     int jphi = tileIndexPhi(&pfCandidate);
     scalarPt[jeta][jphi] += pfCandidate.pt();
   }
 
   rhoVsEta_.resize(ny_);
   meanRhoVsEta_.resize(ny_);
   for (int jeta = 0; jeta < ny_; jeta++) {
     rhoVsEta_[jeta] = 0;
     meanRhoVsEta_[jeta] = 0;
     vector<double> rhoVsPhi;
     int nEmpty = 0;
 
     for (int jphi = 0; jphi < nphi_; jphi++) {
       double binpt = scalarPt[jeta][jphi];
       meanRhoVsEta_[jeta] += binpt;
       //fill in the vector for median calculation
       if (binpt > 0)
         rhoVsPhi.push_back(binpt);
       else
         nEmpty++;
     }
     meanRhoVsEta_[jeta] /= ((double)nphi_);
     meanRhoVsEta_[jeta] /= tileArea_;
 
     //median calculation
     sort(rhoVsPhi.begin(), rhoVsPhi.end());
     //use only the nonzero grid cells for median calculation;
     int nFull = nphi_ - nEmpty;
     if (nFull == 0) {
       rhoVsEta_[jeta] = 0;
       continue;
     }
     if (nFull % 2 == 0) {
       rhoVsEta_[jeta] = (rhoVsPhi[(int)(nFull / 2 - 1)] + rhoVsPhi[(int)(nFull / 2)]) / 2;
     } else {
       rhoVsEta_[jeta] = rhoVsPhi[(int)(nFull / 2)];
     }
     //correct for empty cells
     rhoVsEta_[jeta] *= (((double)nFull) / ((double)nphi_));
     //normalize to area
     rhoVsEta_[jeta] /= tileArea_;
   }
 }

◆ endStream()

void HiFJGridEmptyAreaCalculator::endStream ( )

overrideprivate

Definition at line 446 of file HiFJGridEmptyAreaCalculator.cc.

446 {}

◆ fillDescriptions()

void HiFJGridEmptyAreaCalculator::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 448 of file HiFJGridEmptyAreaCalculator.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

                                                                                              {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("jetSource", edm::InputTag("kt4PFJets"));
   desc.add<edm::InputTag>("CentralityBinSrc", edm::InputTag("centralityBin"));
   desc.add<edm::InputTag>("mapEtaEdges", edm::InputTag("mapEtaEdges"));
   desc.add<edm::InputTag>("mapToRho", edm::InputTag("mapToRho"));
   desc.add<edm::InputTag>("mapToRhoM", edm::InputTag("mapToRhoM"));
   desc.add<edm::InputTag>("pfCandSource", edm::InputTag("particleFlow"));
   desc.add<double>("gridWidth", 0.05);
   desc.add<double>("bandWidth", 0.2);
   desc.add<bool>("doCentrality", true);
   desc.add<int>("hiBinCut", 100);
   desc.add<bool>("keepGridInfo", false);
   descriptions.add("hiFJGridEmptyAreaCalculator", desc);
 }

◆ n_tiles()

int HiFJGridEmptyAreaCalculator::n_tiles ( )

inlineprivate

Definition at line 105 of file HiFJGridEmptyAreaCalculator.h.

References ntotal_.

105 { return ntotal_; }

HiFJGridEmptyAreaCalculator::ntotal_

int ntotal_

Definition: HiFJGridEmptyAreaCalculator.h:87

◆ numJetGridCells()

int HiFJGridEmptyAreaCalculator::numJetGridCells ( std::vector< std::pair< int, int >> & indices )

private

number of grid cells that overlap with jet constituents filling in the in between area

Definition at line 416 of file HiFJGridEmptyAreaCalculator.cc.

References dqmdumpme::indices, METSignificanceParams_cfi::jeta, and jetUpdater_cfi::sort.

Referenced by calculateAreaFractionOfJets().

                                                                                       {
   int ngrid = 0;
   //sort phi eta grid indices in phi
   std::sort(indices.begin(), indices.end());
   int lowestJPhi = indices[0].first;
   int lowestJEta = indices[0].second;
   int highestJEta = lowestJEta;
 
   //for each fixed phi value calculate the number of grids in eta
   for (unsigned int iconst = 1; iconst < indices.size(); iconst++) {
     int jphi = indices[iconst].first;
     int jeta = indices[iconst].second;
     if (jphi == lowestJPhi) {
       if (jeta < lowestJEta)
         lowestJEta = jeta;
       if (jeta > highestJEta)
         highestJEta = jeta;
     } else {
       lowestJPhi = jphi;
       ngrid += highestJEta - lowestJEta + 1;
       lowestJEta = jeta;
       highestJEta = jeta;
     }
   }
   ngrid += highestJEta - lowestJEta + 1;
   return ngrid;
 }

◆ produce()

void HiFJGridEmptyAreaCalculator::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 69 of file HiFJGridEmptyAreaCalculator.cc.

References band_, calculateAreaFractionOfJets(), calculateGridRho(), centralityBinToken_, doCentrality_, MillePedeFileConverter_cfg::e, TrackingDataMCValidation_Standalone_cff::etamax, etaMaxGrid_, etamaxJet_, TrackingDataMCValidation_Standalone_cff::etamin, etaMinGrid_, etaminJet_, hiBinCut_, hcalRecHitTable_cff::ieta, iEvent, createfilelist::int, keepGridInfo_, mapEtaToken_, mapRhoMToken_, mapRhoToken_, meanRhoVsEta_, eostools::move(), neta, ny_, rho, rhoVsEta_, setupGrid(), and totalInboundArea_.

                                                                                        {
   using namespace edm;
   //Values from rho calculator
   edm::Handle<std::vector<double>> mapEtaRanges;
   iEvent.getByToken(mapEtaToken_, mapEtaRanges);
 
   edm::Handle<std::vector<double>> mapRho;
   iEvent.getByToken(mapRhoToken_, mapRho);
 
   edm::Handle<std::vector<double>> mapRhoM;
   iEvent.getByToken(mapRhoMToken_, mapRhoM);
 
   // if doCentrality is set to true calculate empty area correction
   // for only events with hiBin > hiBinCut
   int hiBin = -1;
   bool doEmptyArea = true;
   if (doCentrality_) {
     edm::Handle<int> cbin;
     iEvent.getByToken(centralityBinToken_, cbin);
     hiBin = *cbin;
 
     if (hiBin < hiBinCut_)
       doEmptyArea = false;
   }
 
   //Define output vectors
   int neta = (int)mapEtaRanges->size();
 
   auto mapToRhoCorrOut = std::make_unique<std::vector<double>>(neta - 1, 1e-6);
   auto mapToRhoMCorrOut = std::make_unique<std::vector<double>>(neta - 1, 1e-6);
   auto mapToRhoCorr1BinOut = std::make_unique<std::vector<double>>(neta - 1, 1e-6);
   auto mapToRhoMCorr1BinOut = std::make_unique<std::vector<double>>(neta - 1, 1e-6);
 
   setupGrid(mapEtaRanges->at(0), mapEtaRanges->at(neta - 1));
 
   //calculate empty area correction over full acceptance leaving eta bands on the sides
   double allAcceptanceCorr = 1;
   if (doEmptyArea) {
     etaminJet_ = mapEtaRanges->at(0) - band_;
     etamaxJet_ = mapEtaRanges->at(neta - 1) + band_;
 
     calculateAreaFractionOfJets(iEvent, iSetup);
 
     allAcceptanceCorr = totalInboundArea_;
   }
 
   //calculate empty area correction in each eta range
   for (int ieta = 0; ieta < (neta - 1); ieta++) {
     double correctionKt = 1;
     double rho = mapRho->at(ieta);
     double rhoM = mapRhoM->at(ieta);
 
     if (doEmptyArea) {
       double etamin = mapEtaRanges->at(ieta);
       double etamax = mapEtaRanges->at(ieta + 1);
 
       etaminJet_ = etamin + band_;
       etamaxJet_ = etamax - band_;
 
       calculateAreaFractionOfJets(iEvent, iSetup);
       correctionKt = totalInboundArea_;
     }
 
     mapToRhoCorrOut->at(ieta) = correctionKt * rho;
     mapToRhoMCorrOut->at(ieta) = correctionKt * rhoM;
 
     mapToRhoCorr1BinOut->at(ieta) = allAcceptanceCorr * rho;
     mapToRhoMCorr1BinOut->at(ieta) = allAcceptanceCorr * rhoM;
   }
 
   iEvent.put(std::move(mapToRhoCorrOut), "mapToRhoCorr");
   iEvent.put(std::move(mapToRhoMCorrOut), "mapToRhoMCorr");
   iEvent.put(std::move(mapToRhoCorr1BinOut), "mapToRhoCorr1Bin");
   iEvent.put(std::move(mapToRhoMCorr1BinOut), "mapToRhoMCorr1Bin");
 
   //calculate rho from grid as a function of eta over full range using PF candidates
 
   auto mapRhoVsEtaGridOut = std::make_unique<std::vector<double>>(ny_, 0.);
   auto mapMeanRhoVsEtaGridOut = std::make_unique<std::vector<double>>(ny_, 0.);
   auto mapEtaMaxGridOut = std::make_unique<std::vector<double>>(ny_, 0.);
   auto mapEtaMinGridOut = std::make_unique<std::vector<double>>(ny_, 0.);
   calculateGridRho(iEvent, iSetup);
   if (keepGridInfo_) {
     for (int ieta = 0; ieta < ny_; ieta++) {
       mapRhoVsEtaGridOut->at(ieta) = rhoVsEta_[ieta];
       mapMeanRhoVsEtaGridOut->at(ieta) = meanRhoVsEta_[ieta];
       mapEtaMaxGridOut->at(ieta) = etaMaxGrid_[ieta];
       mapEtaMinGridOut->at(ieta) = etaMinGrid_[ieta];
     }
 
     iEvent.put(std::move(mapRhoVsEtaGridOut), "mapRhoVsEtaGrid");
     iEvent.put(std::move(mapMeanRhoVsEtaGridOut), "mapMeanRhoVsEtaGrid");
     iEvent.put(std::move(mapEtaMaxGridOut), "mapEtaMaxGrid");
     iEvent.put(std::move(mapEtaMinGridOut), "mapEtaMinGrid");
   }
 }

◆ setupGrid()

void HiFJGridEmptyAreaCalculator::setupGrid	(	double	eta_min,
		double	eta_max
	)

private

configure the grid

tell the background estimator that it has a new event, composed of the specified particles.

Definition at line 291 of file HiFJGridEmptyAreaCalculator.cc.

References cms::cuda::assert(), dphi_, dy_, TrackingDataMCValidation_Standalone_cff::etamax, etaMaxGrid_, TrackingDataMCValidation_Standalone_cff::etamin, etaMinGrid_, gridWidth_, createfilelist::int, METSignificanceParams_cfi::jeta, nphi_, ntotal_, ny_, tileArea_, twopi_, ymax_, and ymin_.

Referenced by produce().

                                                                         {
   // since we've exchanged the arguments of the grid constructor,
   // there's a danger of calls with exchanged ymax,spacing arguments --
   // the following check should catch most such situations.
   ymin_ = etamin;
   ymax_ = etamax;
 
   assert(ymax_ - ymin_ >= gridWidth_);
 
   // this grid-definition code is becoming repetitive -- it should
   // probably be moved somewhere central...
   double nyDouble = (ymax_ - ymin_) / gridWidth_;
   ny_ = int(nyDouble + 0.5);
   dy_ = (ymax_ - ymin_) / ny_;
 
   nphi_ = int(twopi_ / gridWidth_ + 0.5);
   dphi_ = twopi_ / nphi_;
 
   // some sanity checking (could throw a fastjet::Error)
   assert(ny_ >= 1 && nphi_ >= 1);
 
   ntotal_ = nphi_ * ny_;
   //_scalar_pt.resize(_ntotal);
   tileArea_ = dy_ * dphi_;
 
   etaMaxGrid_.resize(ny_);
   etaMinGrid_.resize(ny_);
   for (int jeta = 0; jeta < ny_; jeta++) {
     etaMinGrid_[jeta] = etamin + dy_ * ((double)jeta);
     etaMaxGrid_[jeta] = etamin + dy_ * ((double)jeta + 1.);
   }
 }

◆ setupGridJet()

void HiFJGridEmptyAreaCalculator::setupGridJet ( const reco::Jet * jet )

private

Definition at line 373 of file HiFJGridEmptyAreaCalculator.cc.

References cms::cuda::assert(), dyJet_, gridWidth_, createfilelist::int, metsig::jet, nphi_, ntotalJet_, nyJet_, ymaxJet_, and yminJet_.

Referenced by calculateAreaFractionOfJets().

                                                                  {
   // since we've exchanged the arguments of the grid constructor,
   // there's a danger of calls with exchanged ymax,spacing arguments --
   // the following check should catch most such situations.
   yminJet_ = jet->eta() - 0.6;
   ymaxJet_ = jet->eta() + 0.6;
 
   assert(ymaxJet_ - yminJet_ >= gridWidth_);
 
   // this grid-definition code is becoming repetitive -- it should
   // probably be moved somewhere central...
   double nyDouble = (ymaxJet_ - yminJet_) / gridWidth_;
   nyJet_ = int(nyDouble + 0.5);
   dyJet_ = (ymaxJet_ - yminJet_) / nyJet_;
 
   assert(nyJet_ >= 1);
 
   ntotalJet_ = nphi_ * nyJet_;
   //_scalar_pt.resize(_ntotal);
 }

◆ tileIndexEta()

int HiFJGridEmptyAreaCalculator::tileIndexEta ( const reco::PFCandidate * pfCand )

private

Definition at line 348 of file HiFJGridEmptyAreaCalculator.cc.

References cms::cuda::assert(), dy_, reco::LeafCandidate::eta(), createfilelist::int, ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::iy(), ny_, and ymin_.

Referenced by calculateGridRho().

                                                                            {
   // directly taking int does not work for values between -1 and 0
   // so use floor instead
   // double iy_double = (p.rap() - _ymin) / _dy;
   // if (iy_double < 0.0) return -1;
   // int iy = int(iy_double);
   // if (iy >= _ny) return -1;
 
   // writing it as below gives a huge speed gain (factor two!). Even
   // though answers are identical and the routine here is not the
   // speed-critical step. It's not at all clear why.
   int iy = int(floor((pfCand->eta() - ymin_) / dy_));
   if (iy < 0 || iy >= ny_)
     return -1;
 
   assert(iy < ny_ && iy >= 0);
 
   return iy;
 }

◆ tileIndexEtaJet()

int HiFJGridEmptyAreaCalculator::tileIndexEtaJet ( const reco::PFCandidate * pfCand )

private

Definition at line 396 of file HiFJGridEmptyAreaCalculator.cc.

References cms::cuda::assert(), dy_, reco::LeafCandidate::eta(), createfilelist::int, nyJet_, and yminJet_.

Referenced by calculateAreaFractionOfJets().

                                                                               {
   // directly taking int does not work for values between -1 and 0
   // so use floor instead
   // double iy_double = (p.rap() - _ymin) / _dy;
   // if (iy_double < 0.0) return -1;
   // int iy = int(iy_double);
   // if (iy >= _ny) return -1;
 
   // writing it as below gives a huge speed gain (factor two!). Even
   // though answers are identical and the routine here is not the
   // speed-critical step. It's not at all clear why.
   int iyjet = int(floor((pfCand->eta() - yminJet_) / dy_));
   if (iyjet < 0 || iyjet >= nyJet_)
     return -1;
 
   assert(iyjet < nyJet_ && iyjet >= 0);
 
   return iyjet;
 }

◆ tileIndexJet()

int HiFJGridEmptyAreaCalculator::tileIndexJet ( const reco::PFCandidate * pfCand )

private

retrieve the grid cell index for a given PseudoJet

◆ tileIndexPhi()

int HiFJGridEmptyAreaCalculator::tileIndexPhi ( const reco::PFCandidate * pfCand )

private

Definition at line 326 of file HiFJGridEmptyAreaCalculator.cc.

References cms::cuda::assert(), dphi_, createfilelist::int, hcalRecHitTable_cff::iphi, nphi_, reco::LeafCandidate::phi(), and twopi_.

Referenced by calculateAreaFractionOfJets(), and calculateGridRho().

                                                                            {
   // directly taking int does not work for values between -1 and 0
   // so use floor instead
   // double iy_double = (p.rap() - _ymin) / _dy;
   // if (iy_double < 0.0) return -1;
   // int iy = int(iy_double);
   // if (iy >= _ny) return -1;
 
   // writing it as below gives a huge speed gain (factor two!). Even
   // though answers are identical and the routine here is not the
   // speed-critical step. It's not at all clear why.
 
   int iphi = int((pfCand->phi() + (twopi_ / 2.)) / dphi_);
   assert(iphi >= 0 && iphi <= nphi_);
   if (iphi == nphi_)
     iphi = 0;  // just in case of rounding errors
 
   return iphi;
 }