FFTJetEFlowSmoother Class Reference

#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::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 &)

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::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 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 94 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 184 of file FFTJetEFlowSmoother.cc.

{}

Member Function Documentation

buildKernelConvolver()

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

private

Definition at line 117 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));
  }
}

operator=()

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

delete

produce()

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

overrideprotected

Definition at line 187 of file FFTJetEFlowSmoother.cc.

References convolvedFlow, convolver, fftjetcms::FFTJetInterface::discretizeEnergyFlow(), fftjetcms::FFTJetInterface::energyFlow, etConversionFactor, g, fftjetcms::FFTJetInterface::getEventScale(), h, LEDCalibrationChannels::ieta, iEvent, iniScales, LEDCalibrationChannels::iphi, fftjetcms::FFTJetInterface::loadInputCollection(), M_PI, eostools::move(), HLT_2023v12_cff::nEta, HLT_2023v12_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 74 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver().

convolvedFlow

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

private

Definition at line 67 of file FFTJetEFlowSmoother.cc.

Referenced by FFTJetEFlowSmoother(), and produce().

convolver

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

private

Definition at line 82 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver(), and produce().

engine

std::unique_ptr<MyFFTEngine> FFTJetEFlowSmoother::engine

private

Definition at line 73 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver().

etaKernel

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

private

Definition at line 78 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver().

etConversionFactor

double FFTJetEFlowSmoother::etConversionFactor

private

Definition at line 88 of file FFTJetEFlowSmoother.cc.

Referenced by produce().

iniScales

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

private

Definition at line 70 of file FFTJetEFlowSmoother.cc.

Referenced by FFTJetEFlowSmoother(), and produce().

kernel2d

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

private

Definition at line 77 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver().

phiKernel

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

private

Definition at line 79 of file FFTJetEFlowSmoother.cc.

Referenced by buildKernelConvolver().

scalePower

double FFTJetEFlowSmoother::scalePower

private

Definition at line 85 of file FFTJetEFlowSmoother.cc.

Referenced by produce().