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

Inheritance diagram for FFTJetEFlowSmoother:

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

	FFTJetEFlowSmoother ()=delete

	FFTJetEFlowSmoother (const FFTJetEFlowSmoother &)=delete

FFTJetEFlowSmoother &	operator= (const FFTJetEFlowSmoother &)=delete

	~FFTJetEFlowSmoother () 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::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	beginJob () override

void	endJob () override

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

Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

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

Private Attributes
std::unique_ptr< MyFFTEngine >	anotherEngine

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

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

std::unique_ptr< MyFFTEngine >	engine

std::unique_ptr< fftjet::AbsFrequencyKernel1d >	etaKernel

double	etConversionFactor

std::unique_ptr< std::vector< double > >	iniScales

std::unique_ptr< fftjet::AbsFrequencyKernel >	kernel2d

std::unique_ptr< fftjet::AbsFrequencyKernel1d >	phiKernel

double	scalePower

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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 filtering code for multiple scales and saves the results

Implementation: [Notes on implementation]

Definition at line 51 of file FFTJetEFlowSmoother.cc.

Constructor & Destructor Documentation

◆ FFTJetEFlowSmoother() [1/3]

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

explicit

Definition at line 96 of file FFTJetEFlowSmoother.cc.

References buildKernelConvolver(), fftjetcms::FFTJetInterface::checkConfig(), convolvedFlow, fftjetcms::FFTJetInterface::energyFlow, fftjetcms::fftjet_Grid2d_parser(), fftjetcms::fftjet_ScaleSet_parser(), edm::ParameterSet::getParameter(), iniScales, and fftjetcms::FFTJetInterface::outputLabel.

     : FFTJetInterface(ps),
       scalePower(ps.getParameter<double>("scalePower")),
       etConversionFactor(ps.getParameter<double>("etConversionFactor")) {
   // 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);
 
   // Build the initial set of pattern recognition scales
   iniScales = fftjet_ScaleSet_parser(ps.getParameter<edm::ParameterSet>("InitialScales"));
   checkConfig(iniScales, "invalid set of scales");
 
   // Build the FFT engine(s), pattern recognition kernel(s),
   // and the kernel convolver
   buildKernelConvolver(ps);
 
   // Build the set of pattern recognition scales
   produces<TH3F>(outputLabel);
 }

◆ FFTJetEFlowSmoother() [2/3]

FFTJetEFlowSmoother::FFTJetEFlowSmoother ( )

delete

◆ FFTJetEFlowSmoother() [3/3]

FFTJetEFlowSmoother::FFTJetEFlowSmoother ( const FFTJetEFlowSmoother & )

delete

◆ ~FFTJetEFlowSmoother()

FFTJetEFlowSmoother::~FFTJetEFlowSmoother ( )

override

Definition at line 186 of file FFTJetEFlowSmoother.cc.

186 {}

Member Function Documentation

◆ beginJob()

void FFTJetEFlowSmoother::beginJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDProducer.

Definition at line 246 of file FFTJetEFlowSmoother.cc.

246 {}

◆ buildKernelConvolver()

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

private

Definition at line 119 of file FFTJetEFlowSmoother.cc.

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

Referenced by FFTJetEFlowSmoother().

                                                                         {
   // Check the parameter named "etaDependentScaleFactors". If the vector
   // of scales is empty we will use 2d kernel, otherwise use 1d kernels
   const std::vector<double> etaDependentScaleFactors(ps.getParameter<std::vector<double> >("etaDependentScaleFactors"));
 
   // Make sure that the number of scale factors provided is correct
   const bool use2dKernel = etaDependentScaleFactors.empty();
   if (!use2dKernel)
     if (etaDependentScaleFactors.size() != energyFlow->nEta())
       throw cms::Exception("FFTJetBadConfig") << "invalid number of eta-dependent scale factors" << std::endl;
 
   // 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 scale" << 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()));
 
   // Are we going to try to fix the efficiency near detector edges?
   const bool fixEfficiency = ps.getParameter<bool>("fixEfficiency");
 
   // Minimum and maximum eta bin for the convolver
   unsigned convolverMinBin = 0, convolverMaxBin = 0;
   if (fixEfficiency || !use2dKernel) {
     convolverMinBin = ps.getParameter<unsigned>("convolverMinBin");
     convolverMaxBin = ps.getParameter<unsigned>("convolverMaxBin");
   }
 
   if (use2dKernel) {
     // 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));
   } else {
     // Need separate FFT engines for eta and phi
     engine = std::make_unique<MyFFTEngine>(1, energyFlow->nEta());
     anotherEngine = std::make_unique<MyFFTEngine>(1, energyFlow->nPhi());
 
     // 1d kernels
     etaKernel =
         std::unique_ptr<fftjet::AbsFrequencyKernel1d>(new fftjet::DiscreteGauss1d(kernelEtaScale, energyFlow->nEta()));
 
     phiKernel =
         std::unique_ptr<fftjet::AbsFrequencyKernel1d>(new fftjet::DiscreteGauss1d(kernelPhiScale, energyFlow->nPhi()));
 
     // Sequential convolver
     convolver = std::unique_ptr<fftjet::AbsConvolverBase<Real> >(
         new fftjet::FrequencySequentialConvolver<Real, Complex>(engine.get(),
                                                                 anotherEngine.get(),
                                                                 etaKernel.get(),
                                                                 phiKernel.get(),
                                                                 etaDependentScaleFactors,
                                                                 convolverMinBin,
                                                                 convolverMaxBin,
                                                                 fixEfficiency));
   }
 }

◆ endJob()

void FFTJetEFlowSmoother::endJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDProducer.

Definition at line 249 of file FFTJetEFlowSmoother.cc.

249 {}

◆ operator=()

FFTJetEFlowSmoother& FFTJetEFlowSmoother::operator= ( const FFTJetEFlowSmoother & )

delete

◆ produce()

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

overrideprotectedvirtual

Implements edm::EDProducer.

Definition at line 189 of file FFTJetEFlowSmoother.cc.

References convolvedFlow, convolver, fftjetcms::FFTJetInterface::discretizeEnergyFlow(), fftjetcms::FFTJetInterface::energyFlow, etConversionFactor, DQMScaleToClient_cfi::factor, g, fftjetcms::FFTJetInterface::getEventScale(), h, LEDCalibrationChannels::ieta, iEvent, iniScales, LEDCalibrationChannels::iphi, fftjetcms::FFTJetInterface::loadInputCollection(), M_PI, eostools::move(), HLT_2022v12_cff::nEta, HLT_2022v12_cff::nPhi, fftjetcommon_cfi::nScales, fftjetcms::FFTJetInterface::outputLabel, funct::pow(), scalePower, and mitigatedMETSequence_cff::U.

                                                                                {
   loadInputCollection(iEvent);
   discretizeEnergyFlow();
 
   // Various useful variables
   const fftjet::Grid2d<Real>& g(*energyFlow);
   const unsigned nScales = iniScales->size();
   const double* scales = &(*iniScales)[0];
   Real* convData = const_cast<Real*>(convolvedFlow->data());
   const unsigned nEta = g.nEta();
   const unsigned nPhi = g.nPhi();
   const double bin0edge = g.phiBin0Edge();
 
   // We will fill the following histo
   auto pTable = std::make_unique<TH3F>("FFTJetEFlowSmoother",
                                        "FFTJetEFlowSmoother",
                                        nScales + 1U,
                                        -1.5,
                                        nScales - 0.5,
                                        nEta,
                                        g.etaMin(),
                                        g.etaMax(),
                                        nPhi,
                                        bin0edge,
                                        bin0edge + 2.0 * M_PI);
   TH3F* h = pTable.get();
   h->SetDirectory(nullptr);
   h->GetXaxis()->SetTitle("Scale");
   h->GetYaxis()->SetTitle("Eta");
   h->GetZaxis()->SetTitle("Phi");
 
   // Fill the original thing
   double factor = etConversionFactor * pow(getEventScale(), scalePower);
   for (unsigned ieta = 0; ieta < nEta; ++ieta)
     for (unsigned iphi = 0; iphi < nPhi; ++iphi)
       h->SetBinContent(1U, ieta + 1U, iphi + 1U, factor * g.binValue(ieta, iphi));
 
   // Go over all scales and perform the convolutions
   convolver->setEventData(g.data(), nEta, nPhi);
   for (unsigned iscale = 0; iscale < nScales; ++iscale) {
     factor = etConversionFactor * pow(scales[iscale], scalePower);
 
     // Perform the convolution
     convolver->convolveWithKernel(scales[iscale], convData, convolvedFlow->nEta(), convolvedFlow->nPhi());
 
     // Fill the output histo
     for (unsigned ieta = 0; ieta < nEta; ++ieta) {
       const Real* etaData = convData + ieta * nPhi;
       for (unsigned iphi = 0; iphi < nPhi; ++iphi)
         h->SetBinContent(iscale + 2U, ieta + 1U, iphi + 1U, factor * etaData[iphi]);
     }
   }
 
   iEvent.put(std::move(pTable), outputLabel);
 }

Member Data Documentation

◆ anotherEngine

std::unique_ptr<MyFFTEngine> FFTJetEFlowSmoother::anotherEngine

private

Definition at line 76 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver().

◆ convolvedFlow

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

private

Definition at line 69 of file FFTJetEFlowSmoother.cc.

Referenced by FFTJetEFlowSmoother(), and produce().

◆ convolver

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

private

Definition at line 84 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver(), and produce().

◆ engine

std::unique_ptr<MyFFTEngine> FFTJetEFlowSmoother::engine

private

Definition at line 75 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver().

◆ etaKernel

std::unique_ptr<fftjet::AbsFrequencyKernel1d> FFTJetEFlowSmoother::etaKernel

private

Definition at line 80 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver().

◆ etConversionFactor

double FFTJetEFlowSmoother::etConversionFactor

private

Definition at line 90 of file FFTJetEFlowSmoother.cc.

Referenced by produce().

◆ iniScales

std::unique_ptr<std::vector<double> > FFTJetEFlowSmoother::iniScales

private

Definition at line 72 of file FFTJetEFlowSmoother.cc.

Referenced by FFTJetEFlowSmoother(), and produce().

◆ kernel2d

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

private

Definition at line 79 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver().

◆ phiKernel

std::unique_ptr<fftjet::AbsFrequencyKernel1d> FFTJetEFlowSmoother::phiKernel

private

Definition at line 81 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver().

◆ scalePower

double FFTJetEFlowSmoother::scalePower

private

Definition at line 87 of file FFTJetEFlowSmoother.cc.

Referenced by produce().

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FFTJetEFlowSmoother() [1/3]

◆ FFTJetEFlowSmoother() [2/3]

◆ FFTJetEFlowSmoother() [3/3]

◆ ~FFTJetEFlowSmoother()

Member Function Documentation

◆ beginJob()

◆ buildKernelConvolver()

◆ endJob()

◆ operator=()

◆ produce()

Member Data Documentation

◆ anotherEngine

◆ convolvedFlow

◆ convolver

◆ engine

◆ etaKernel

◆ etConversionFactor

◆ iniScales

◆ kernel2d

◆ phiKernel

◆ scalePower