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

Inheritance diagram for FFTJetEFlowSmoother:

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

	~FFTJetEFlowSmoother ()

Public Member Functions inherited from fftjetcms::FFTJetInterface
virtual	~FFTJetInterface ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

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

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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 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)

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

	FFTJetEFlowSmoother ()

	FFTJetEFlowSmoother (const FFTJetEFlowSmoother &)

FFTJetEFlowSmoother &	operator= (const FFTJetEFlowSmoother &)

Private Attributes
std::auto_ptr< MyFFTEngine >	anotherEngine

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

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

std::auto_ptr< MyFFTEngine >	engine

std::auto_ptr < fftjet::AbsFrequencyKernel1d >	etaKernel

double	etConversionFactor

std::auto_ptr< std::vector < double > >	iniScales

std::auto_ptr < fftjet::AbsFrequencyKernel >	kernel2d

std::auto_ptr < fftjet::AbsFrequencyKernel1d >	phiKernel

double	scalePower

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

Public Types inherited from edm::ProducerBase
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)

Protected Attributes inherited from fftjetcms::FFTJetInterface
const AnomalousTower	anomalous

std::vector< unsigned >	candidateIndex

const bool	doPVCorrection

std::auto_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 50 of file FFTJetEFlowSmoother.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 97 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::auto_ptr<fftjet::Grid2d<fftjetcms::Real> >(
         new 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::~FFTJetEFlowSmoother ( )

Definition at line 206 of file FFTJetEFlowSmoother.cc.

207 {

208 }

FFTJetEFlowSmoother::FFTJetEFlowSmoother ( )

private

FFTJetEFlowSmoother::FFTJetEFlowSmoother ( const FFTJetEFlowSmoother & )

private

Member Function Documentation

void FFTJetEFlowSmoother::beginJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDProducer.

Definition at line 272 of file FFTJetEFlowSmoother.cc.

273 {

274 }

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

private

Definition at line 125 of file FFTJetEFlowSmoother.cc.

References anotherEngine, convolver, fftjetcms::FFTJetInterface::energyFlow, engine, etaKernel, Exception, edm::ParameterSet::getParameter(), kernel2d, 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::auto_ptr<MyFFTEngine>(
             new MyFFTEngine(energyFlow->nEta(), energyFlow->nPhi()));
 
         // 2d kernel
         kernel2d = std::auto_ptr<fftjet::AbsFrequencyKernel>(
             new fftjet::DiscreteGauss2d(
                 kernelEtaScale, kernelPhiScale,
                 energyFlow->nEta(), energyFlow->nPhi()));
 
         // 2d convolver
         convolver = std::auto_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::auto_ptr<MyFFTEngine>(
             new MyFFTEngine(1, energyFlow->nEta()));
         anotherEngine = std::auto_ptr<MyFFTEngine>(
             new MyFFTEngine(1, energyFlow->nPhi()));
 
         // 1d kernels
         etaKernel = std::auto_ptr<fftjet::AbsFrequencyKernel1d>(
             new fftjet::DiscreteGauss1d(kernelEtaScale, energyFlow->nEta()));
 
         phiKernel = std::auto_ptr<fftjet::AbsFrequencyKernel1d>(
             new fftjet::DiscreteGauss1d(kernelPhiScale, energyFlow->nPhi()));
 
         // Sequential convolver
         convolver = std::auto_ptr<fftjet::AbsConvolverBase<Real> >(
             new fftjet::FrequencySequentialConvolver<Real,Complex>(
                 engine.get(), anotherEngine.get(),
                 etaKernel.get(), phiKernel.get(),
                 etaDependentScaleFactors, convolverMinBin,
                 convolverMaxBin, fixEfficiency));
     }
 }

void FFTJetEFlowSmoother::endJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDProducer.

Definition at line 278 of file FFTJetEFlowSmoother.cc.

279 {

280 }

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

private

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

overrideprotectedvirtual

Implements edm::EDProducer.

Definition at line 212 of file FFTJetEFlowSmoother.cc.

References convolvedFlow, convolver, fftjetcms::FFTJetInterface::discretizeEnergyFlow(), fftjetcms::FFTJetInterface::energyFlow, etConversionFactor, g, fftjetcms::FFTJetInterface::getEventScale(), h, iniScales, fftjetcms::FFTJetInterface::loadInputCollection(), M_PI, HLT_25ns14e33_v1_cff::nEta, HLT_25ns14e33_v1_cff::nPhi, fftjetcms::FFTJetInterface::outputLabel, funct::pow(), edm::Event::put(), and scalePower.

 {
     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
     std::auto_ptr<TH3F> pTable(
         new 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(0);
     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(pTable, outputLabel);
 }