#include <RecoJets/FFTJetProducers/plugins/FFTJetPileupProcessor.cc>

Inheritance diagram for FFTJetPileupProcessor:

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

	FFTJetPileupProcessor ()=delete

	FFTJetPileupProcessor (const FFTJetPileupProcessor &)=delete

FFTJetPileupProcessor &	operator= (const FFTJetPileupProcessor &)=delete

	~FFTJetPileupProcessor () override

Public Member Functions inherited from fftjetcms::FFTJetInterface
	FFTJetInterface ()=delete

	FFTJetInterface (const FFTJetInterface &)=delete

FFTJetInterface &	operator= (const FFTJetInterface &)=delete

	~FFTJetInterface () 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

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

Protected Member Functions inherited from fftjetcms::FFTJetInterface
template<class Ptr >
void	checkConfig (const Ptr &ptr, const char *message)

void	discretizeEnergyFlow ()

	FFTJetInterface (const edm::ParameterSet &)

double	getEventScale () const

void	loadInputCollection (const edm::Event &)

bool	storeInSinglePrecision () const

const reco::Particle::Point &	vertexUsed () const

Private Member Functions
void	buildKernelConvolver (const edm::ParameterSet &)

void	loadFlatteningFactors (const edm::EventSetup &iSetup)

void	mixExtraGrid ()

Private Attributes
std::unique_ptr< fftjet::Grid2d< fftjetcms::Real > >	convolvedFlow

std::unique_ptr< fftjet::AbsConvolverBase< Real > >	convolver

unsigned	convolverMaxBin

unsigned	convolverMinBin

unsigned	currentFileNum

std::unique_ptr< MyFFTEngine >	engine

FFTJetLookupTableSequenceLoader	esLoader

std::vector< double >	etaFlatteningFactors

std::vector< std::string >	externalGridFiles

double	externalGridMaxEnergy

std::unique_ptr< fftjet::EquidistantInLogSpace >	filterScales

std::string	flatteningTableCategory

std::string	flatteningTableName

std::string	flatteningTableRecord

std::ifstream	gridStream

std::unique_ptr< fftjet::AbsFrequencyKernel >	kernel2d

bool	loadFlatteningFactorsFromDB

unsigned	nPercentiles

std::vector< double >	percentileData

double	pileupEtaPhiArea

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

Protected Attributes inherited from fftjetcms::FFTJetInterface
const AnomalousTower	anomalous

std::vector< unsigned >	candidateIndex

const bool	doPVCorrection

std::unique_ptr< fftjet::Grid2d< fftjetcms::Real > >	energyFlow

const std::vector< double >	etaDependentMagnutideFactors

std::vector< fftjetcms::VectorLike >	eventData

edm::Handle< reco::CandidateView >	inputCollection

const edm::InputTag	inputLabel

const JetType	jetType

const std::string	outputLabel

const edm::InputTag	srcPVs

Detailed Description

Description: Runs FFTJet multiscale pileup filtering code and saves the results

Implementation: [Notes on implementation]

Definition at line 53 of file FFTJetPileupProcessor.cc.

Constructor & Destructor Documentation

◆ FFTJetPileupProcessor() [1/3]

FFTJetPileupProcessor::FFTJetPileupProcessor ( const edm::ParameterSet & ps )

explicit

Definition at line 123 of file FFTJetPileupProcessor.cc.

References DefaultFFTJetRcdMapper< DataType >::acquireToken(), buildKernelConvolver(), fftjetcms::FFTJetInterface::checkConfig(), convolvedFlow, fftjetcms::FFTJetInterface::energyFlow, esLoader, etaFlatteningFactors, Exception, fftjetcms::fftjet_Grid2d_parser(), filterScales, flatteningTableRecord, edm::ParameterSet::getParameter(), fftjetcommon_cfi::maxScale, fftjetcommon_cfi::minScale, nPercentiles, fftjetcommon_cfi::nScales, fftjetcms::FFTJetInterface::outputLabel, percentileData, and mitigatedMETSequence_cff::U.

     : FFTJetInterface(ps),
       etaFlatteningFactors(ps.getParameter<std::vector<double>>("etaFlatteningFactors")),
       nPercentiles(ps.getParameter<unsigned>("nPercentiles")),
       convolverMinBin(ps.getParameter<unsigned>("convolverMinBin")),
       convolverMaxBin(ps.getParameter<unsigned>("convolverMaxBin")),
       pileupEtaPhiArea(ps.getParameter<double>("pileupEtaPhiArea")),
       externalGridFiles(ps.getParameter<std::vector<std::string>>("externalGridFiles")),
       externalGridMaxEnergy(ps.getParameter<double>("externalGridMaxEnergy")),
       currentFileNum(externalGridFiles.size() + 1U),
       flatteningTableRecord(ps.getParameter<std::string>("flatteningTableRecord")),
       flatteningTableName(ps.getParameter<std::string>("flatteningTableName")),
       flatteningTableCategory(ps.getParameter<std::string>("flatteningTableCategory")),
       loadFlatteningFactorsFromDB(ps.getParameter<bool>("loadFlatteningFactorsFromDB")) {
   // Build the discretization grid
   energyFlow = fftjet_Grid2d_parser(ps.getParameter<edm::ParameterSet>("GridConfiguration"));
   checkConfig(energyFlow, "invalid discretization grid");
 
   // Copy of the grid which will be used for convolutions
   convolvedFlow = std::make_unique<fftjet::Grid2d<fftjetcms::Real>>(*energyFlow);
 
   // Make sure the size of flattening factors is appropriate
   if (!etaFlatteningFactors.empty()) {
     if (etaFlatteningFactors.size() != convolvedFlow->nEta())
       throw cms::Exception("FFTJetBadConfig") << "ERROR in FFTJetPileupProcessor constructor:"
                                                  " number of elements in the \"etaFlatteningFactors\""
                                                  " vector is inconsistent with the discretization grid binning"
                                               << std::endl;
   }
 
   // Build the FFT engine(s), pattern recognition kernel(s),
   // and the kernel convolver
   buildKernelConvolver(ps);
 
   // Build the set of pattern recognition scales
   const unsigned nScales = ps.getParameter<unsigned>("nScales");
   const double minScale = ps.getParameter<double>("minScale");
   const double maxScale = ps.getParameter<double>("maxScale");
   if (minScale <= 0.0 || maxScale < minScale || nScales == 0U)
     throw cms::Exception("FFTJetBadConfig") << "invalid filter scales" << std::endl;
 
   filterScales = std::make_unique<fftjet::EquidistantInLogSpace>(minScale, maxScale, nScales);
 
   percentileData.resize(nScales * nPercentiles);
 
   produces<reco::DiscretizedEnergyFlow>(outputLabel);
   produces<std::pair<double, double>>(outputLabel);
 
   esLoader.acquireToken(flatteningTableRecord, consumesCollector());
 }

◆ FFTJetPileupProcessor() [2/3]

FFTJetPileupProcessor::FFTJetPileupProcessor ( )

delete

◆ FFTJetPileupProcessor() [3/3]

FFTJetPileupProcessor::FFTJetPileupProcessor ( const FFTJetPileupProcessor & )

delete

◆ ~FFTJetPileupProcessor()

FFTJetPileupProcessor::~FFTJetPileupProcessor ( )

override

Definition at line 201 of file FFTJetPileupProcessor.cc.

201 {}

Member Function Documentation

◆ buildKernelConvolver()

void FFTJetPileupProcessor::buildKernelConvolver ( const edm::ParameterSet & ps )

private

Definition at line 174 of file FFTJetPileupProcessor.cc.

References convolver, convolverMaxBin, convolverMinBin, fftjetcms::FFTJetInterface::energyFlow, engine, Exception, edm::ParameterSet::getParameter(), kernel2d, fftjeteflowsmoother_cfi::kernelEtaScale, fftjeteflowsmoother_cfi::kernelPhiScale, and M_PI.

Referenced by FFTJetPileupProcessor().

                                                                           {
   // Get the eta and phi scales for the kernel(s)
   double kernelEtaScale = ps.getParameter<double>("kernelEtaScale");
   const double kernelPhiScale = ps.getParameter<double>("kernelPhiScale");
   if (kernelEtaScale <= 0.0 || kernelPhiScale <= 0.0)
     throw cms::Exception("FFTJetBadConfig") << "invalid kernel scales" << std::endl;
 
   if (convolverMinBin || convolverMaxBin)
     if (convolverMinBin >= convolverMaxBin || convolverMaxBin > energyFlow->nEta())
       throw cms::Exception("FFTJetBadConfig") << "invalid convolver bin range" << std::endl;
 
   // FFT assumes that the grid extent in eta is 2*Pi. Adjust the
   // kernel scale in eta to compensate.
   kernelEtaScale *= (2.0 * M_PI / (energyFlow->etaMax() - energyFlow->etaMin()));
 
   // Build the FFT engine
   engine = std::make_unique<MyFFTEngine>(energyFlow->nEta(), energyFlow->nPhi());
 
   // 2d kernel
   kernel2d = std::unique_ptr<fftjet::AbsFrequencyKernel>(
       new fftjet::DiscreteGauss2d(kernelEtaScale, kernelPhiScale, energyFlow->nEta(), energyFlow->nPhi()));
 
   // 2d convolver
   convolver = std::unique_ptr<fftjet::AbsConvolverBase<Real>>(new fftjet::FrequencyKernelConvolver<Real, Complex>(
       engine.get(), kernel2d.get(), convolverMinBin, convolverMaxBin));
 }

◆ loadFlatteningFactors()

void FFTJetPileupProcessor::loadFlatteningFactors ( const edm::EventSetup & iSetup )

private

Definition at line 322 of file FFTJetPileupProcessor.cc.

References fftjetcms::FFTJetInterface::energyFlow, esLoader, PVValHelper::eta, etaFlatteningFactors, f, flatteningTableCategory, flatteningTableName, flatteningTableRecord, h, hcalRecHitTable_cff::ieta, DefaultFFTJetRcdMapper< DataType >::load(), HLT_2024v12_cff::nEta, and mitigatedMETSequence_cff::U.

Referenced by produce().

                                                                              {
   edm::ESHandle<FFTJetLookupTableSequence> h = esLoader.load(flatteningTableRecord, iSetup);
   std::shared_ptr<npstat::StorableMultivariateFunctor> f = (*h)[flatteningTableCategory][flatteningTableName];
 
   // Fill out the table of flattening factors as a function of eta
   const unsigned nEta = energyFlow->nEta();
   etaFlatteningFactors.clear();
   etaFlatteningFactors.reserve(nEta);
   for (unsigned ieta = 0; ieta < nEta; ++ieta) {
     const double eta = energyFlow->etaBinCenter(ieta);
     etaFlatteningFactors.push_back((*f)(&eta, 1U));
   }
 }

◆ mixExtraGrid()

void FFTJetPileupProcessor::mixExtraGrid ( )

private

Definition at line 269 of file FFTJetPileupProcessor.cc.

References fftjetcms::add_Grid2d_data(), currentFileNum, fftjetcms::FFTJetInterface::energyFlow, Exception, externalGridFiles, externalGridMaxEnergy, g, gridStream, recoMuon::in, mkLumiAveragedPlots::nFiles, mergeAndRegister::ntries, fileinputsource_cfi::read, and mitigatedMETSequence_cff::U.

Referenced by produce().

                                          {
   const unsigned nFiles = externalGridFiles.size();
   if (currentFileNum > nFiles) {
     // This is the first time this function is called
     currentFileNum = 0;
     gridStream.open(externalGridFiles[currentFileNum].c_str(), std::ios_base::in | std::ios_base::binary);
     if (!gridStream.is_open())
       throw cms::Exception("FFTJetBadConfig") << "ERROR in FFTJetPileupProcessor::mixExtraGrid():"
                                                  " failed to open external grid file "
                                               << externalGridFiles[currentFileNum] << std::endl;
   }
 
   const fftjet::Grid2d<float>* g = nullptr;
   const unsigned maxFail = 100U;
   unsigned nEnergyRejected = 0;
 
   while (!g) {
     g = fftjet::Grid2d<float>::read(gridStream);
 
     // If we can't read the grid, we need to switch to another file
     for (unsigned ntries = 0; ntries < nFiles && g == nullptr; ++ntries) {
       gridStream.close();
       currentFileNum = (currentFileNum + 1U) % nFiles;
       gridStream.open(externalGridFiles[currentFileNum].c_str(), std::ios_base::in | std::ios_base::binary);
       if (!gridStream.is_open())
         throw cms::Exception("FFTJetBadConfig") << "ERROR in FFTJetPileupProcessor::mixExtraGrid():"
                                                    " failed to open external grid file "
                                                 << externalGridFiles[currentFileNum] << std::endl;
       g = fftjet::Grid2d<float>::read(gridStream);
     }
 
     if (g)
       if (g->sum() > externalGridMaxEnergy) {
         delete g;
         g = nullptr;
         if (++nEnergyRejected >= maxFail)
           throw cms::Exception("FFTJetBadConfig") << "ERROR in FFTJetPileupProcessor::mixExtraGrid():"
                                                      " too many grids in a row ("
                                                   << nEnergyRejected << ") failed the maximum energy cut" << std::endl;
       }
   }
 
   if (g) {
     add_Grid2d_data(energyFlow.get(), *g);
     delete g;
   } else {
     // Too bad, no useful file found
     throw cms::Exception("FFTJetBadConfig") << "ERROR in FFTJetPileupProcessor::mixExtraGrid():"
                                                " no valid grid records found"
                                             << std::endl;
   }
 }

◆ operator=()

FFTJetPileupProcessor& FFTJetPileupProcessor::operator= ( const FFTJetPileupProcessor & )

delete

◆ produce()

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

overrideprotected

Definition at line 204 of file FFTJetPileupProcessor.cc.

References convolvedFlow, convolver, convolverMaxBin, convolverMinBin, fftjetcms::FFTJetInterface::discretizeEnergyFlow(), fftjetcms::FFTJetInterface::energyFlow, etaFlatteningFactors, externalGridFiles, filterScales, g, iEvent, loadFlatteningFactors(), loadFlatteningFactorsFromDB, fftjetcms::FFTJetInterface::loadInputCollection(), mixExtraGrid(), nPercentiles, fftjetcommon_cfi::nScales, fftjetcms::FFTJetInterface::outputLabel, percentileData, pileupEtaPhiArea, submitPVResolutionJobs::q, l1tGTDoubleObjectCond_cfi::scales, jetUpdater_cfi::sort, and mitigatedMETSequence_cff::U.

                                                                                  {
   loadInputCollection(iEvent);
   discretizeEnergyFlow();
 
   // Determine the average Et density for this event.
   // Needs to be done here, before mixing in another grid.
   const fftjet::Grid2d<Real>& g(*energyFlow);
   const double densityBeforeMixing = g.sum() / pileupEtaPhiArea;
 
   // Mix an extra grid (if requested)
   double densityAfterMixing = -1.0;
   if (!externalGridFiles.empty()) {
     mixExtraGrid();
     densityAfterMixing = g.sum() / pileupEtaPhiArea;
   }
 
   // Various useful variables
   const unsigned nScales = filterScales->size();
   const double* scales = &(*filterScales)[0];
   Real* convData = const_cast<Real*>(convolvedFlow->data());
   Real* sortData = convData + convolverMinBin * convolvedFlow->nPhi();
   const unsigned dataLen = convolverMaxBin ? (convolverMaxBin - convolverMinBin) * convolvedFlow->nPhi()
                                            : convolvedFlow->nEta() * convolvedFlow->nPhi();
 
   // Load flattenning factors from DB (if requested)
   if (loadFlatteningFactorsFromDB)
     loadFlatteningFactors(iSetup);
 
   // Go over all scales and perform the convolutions
   convolver->setEventData(g.data(), g.nEta(), g.nPhi());
   for (unsigned iscale = 0; iscale < nScales; ++iscale) {
     // Perform the convolution
     convolver->convolveWithKernel(scales[iscale], convData, convolvedFlow->nEta(), convolvedFlow->nPhi());
 
     // Apply the flattening factors
     if (!etaFlatteningFactors.empty())
       convolvedFlow->scaleData(&etaFlatteningFactors[0], etaFlatteningFactors.size());
 
     // Sort the convolved data
     std::sort(sortData, sortData + dataLen);
 
     // Determine the percentile points
     for (unsigned iper = 0; iper < nPercentiles; ++iper) {
       // Map percentile 0 into point number 0,
       // 1 into point number dataLen-1
       const double q = (iper + 0.5) / nPercentiles;
       const double dindex = q * (dataLen - 1U);
       const unsigned ilow = static_cast<unsigned>(std::floor(dindex));
       const double percentile =
           fftjet::lin_interpolate_1d(ilow, ilow + 1U, sortData[ilow], sortData[ilow + 1U], dindex);
 
       // Store the calculated percentile
       percentileData[iscale * nPercentiles + iper] = percentile;
     }
   }
 
   // Convert percentile data into a more convenient storable object
   // and put it into the event record
   iEvent.put(std::make_unique<reco::DiscretizedEnergyFlow>(
                  &percentileData[0], "FFTJetPileupProcessor", -0.5, nScales - 0.5, 0.0, nScales, nPercentiles),
              outputLabel);
 
   iEvent.put(std::make_unique<std::pair<double, double>>(densityBeforeMixing, densityAfterMixing), outputLabel);
 }

Member Data Documentation

◆ convolvedFlow

std::unique_ptr<fftjet::Grid2d<fftjetcms::Real> > FFTJetPileupProcessor::convolvedFlow

private

Definition at line 80 of file FFTJetPileupProcessor.cc.

Referenced by FFTJetPileupProcessor(), and produce().

◆ convolver

std::unique_ptr<fftjet::AbsConvolverBase<Real> > FFTJetPileupProcessor::convolver

private

Definition at line 77 of file FFTJetPileupProcessor.cc.

Referenced by buildKernelConvolver(), and produce().

◆ convolverMaxBin

unsigned FFTJetPileupProcessor::convolverMaxBin

private

Definition at line 94 of file FFTJetPileupProcessor.cc.

Referenced by buildKernelConvolver(), and produce().

◆ convolverMinBin

unsigned FFTJetPileupProcessor::convolverMinBin

private

Definition at line 93 of file FFTJetPileupProcessor.cc.

Referenced by buildKernelConvolver(), and produce().

◆ currentFileNum

unsigned FFTJetPileupProcessor::currentFileNum

private

Definition at line 103 of file FFTJetPileupProcessor.cc.

Referenced by mixExtraGrid().

◆ engine

std::unique_ptr<MyFFTEngine> FFTJetPileupProcessor::engine

private

Definition at line 71 of file FFTJetPileupProcessor.cc.

Referenced by buildKernelConvolver().

◆ esLoader

FFTJetLookupTableSequenceLoader FFTJetPileupProcessor::esLoader

private

Definition at line 117 of file FFTJetPileupProcessor.cc.

Referenced by FFTJetPileupProcessor(), and loadFlatteningFactors().

◆ etaFlatteningFactors

std::vector<double> FFTJetPileupProcessor::etaFlatteningFactors

private

Definition at line 87 of file FFTJetPileupProcessor.cc.

Referenced by FFTJetPileupProcessor(), loadFlatteningFactors(), and produce().

◆ externalGridFiles

std::vector<std::string> FFTJetPileupProcessor::externalGridFiles

private

Definition at line 100 of file FFTJetPileupProcessor.cc.

Referenced by mixExtraGrid(), and produce().

◆ externalGridMaxEnergy

double FFTJetPileupProcessor::externalGridMaxEnergy

private

Definition at line 102 of file FFTJetPileupProcessor.cc.

Referenced by mixExtraGrid().

◆ filterScales

std::unique_ptr<fftjet::EquidistantInLogSpace> FFTJetPileupProcessor::filterScales

private

Definition at line 83 of file FFTJetPileupProcessor.cc.

Referenced by FFTJetPileupProcessor(), and produce().

◆ flatteningTableCategory

std::string FFTJetPileupProcessor::flatteningTableCategory

private

Definition at line 114 of file FFTJetPileupProcessor.cc.

Referenced by loadFlatteningFactors().

◆ flatteningTableName

std::string FFTJetPileupProcessor::flatteningTableName

private

Definition at line 113 of file FFTJetPileupProcessor.cc.

Referenced by loadFlatteningFactors().

◆ flatteningTableRecord

std::string FFTJetPileupProcessor::flatteningTableRecord

private

Definition at line 112 of file FFTJetPileupProcessor.cc.

Referenced by FFTJetPileupProcessor(), and loadFlatteningFactors().

◆ gridStream

std::ifstream FFTJetPileupProcessor::gridStream

private

Definition at line 101 of file FFTJetPileupProcessor.cc.

Referenced by mixExtraGrid().

◆ kernel2d

std::unique_ptr<fftjet::AbsFrequencyKernel> FFTJetPileupProcessor::kernel2d

private

Definition at line 74 of file FFTJetPileupProcessor.cc.

Referenced by buildKernelConvolver().

◆ loadFlatteningFactorsFromDB

bool FFTJetPileupProcessor::loadFlatteningFactorsFromDB

private

Definition at line 115 of file FFTJetPileupProcessor.cc.

Referenced by produce().

◆ nPercentiles

unsigned FFTJetPileupProcessor::nPercentiles

private

Definition at line 90 of file FFTJetPileupProcessor.cc.

Referenced by FFTJetPileupProcessor(), and produce().

◆ percentileData

std::vector<double> FFTJetPileupProcessor::percentileData

private

Definition at line 106 of file FFTJetPileupProcessor.cc.

Referenced by FFTJetPileupProcessor(), and produce().

◆ pileupEtaPhiArea

double FFTJetPileupProcessor::pileupEtaPhiArea

private

Definition at line 97 of file FFTJetPileupProcessor.cc.

Referenced by produce().

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FFTJetPileupProcessor() [1/3]

◆ FFTJetPileupProcessor() [2/3]

◆ FFTJetPileupProcessor() [3/3]

◆ ~FFTJetPileupProcessor()

Member Function Documentation

◆ buildKernelConvolver()

◆ loadFlatteningFactors()

◆ mixExtraGrid()

◆ operator=()

◆ produce()

Member Data Documentation

◆ convolvedFlow

◆ convolver

◆ convolverMaxBin

◆ convolverMinBin

◆ currentFileNum

◆ engine

◆ esLoader

◆ etaFlatteningFactors

◆ externalGridFiles

◆ externalGridMaxEnergy

◆ filterScales

◆ flatteningTableCategory

◆ flatteningTableName

◆ flatteningTableRecord

◆ gridStream

◆ kernel2d

◆ loadFlatteningFactorsFromDB

◆ nPercentiles

◆ percentileData

◆ pileupEtaPhiArea