#include <RecoJets/FFTJetProducer/plugins/FFTJetPatRecoProducer.cc>

Inheritance diagram for FFTJetPatRecoProducer:

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

	~FFTJetPatRecoProducer () override

Public Member Functions inherited from fftjetcms::FFTJetInterface
	~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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (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::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Protected Types
typedef fftjet::ProximityClusteringTree< fftjet::Peak, long >	ClusteringTree

typedef fftjet::ClusteringSequencer< Real >	Sequencer

typedef fftjet::SparseClusteringTree< fftjet::Peak, long >	SparseTree

typedef fftjet::ClusteringTreeSparsifier< fftjet::Peak, long >	Sparsifier

Protected Member Functions
void	beginJob () override

template<class Real >
void	buildDenseProduct (edm::Event &) const

void	buildKernelConvolver (const edm::ParameterSet &)

fftjet::PeakFinder	buildPeakFinder (const edm::ParameterSet &)

template<class Real >
void	buildSparseProduct (edm::Event &) const

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<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

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

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

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)

template<Transition B>
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 (std::string instanceName)

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

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (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)

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

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

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

Protected Attributes
std::unique_ptr< MyFFTEngine >	anotherEngine

ClusteringTree *	clusteringTree

const double	completeEventDataCutoff

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

std::unique_ptr< fftjet::AbsDistanceCalculator< fftjet::Peak > >	distanceCalc

std::unique_ptr< MyFFTEngine >	engine

std::unique_ptr< fftjet::AbsFrequencyKernel1d >	etaKernel

std::unique_ptr< fftjet::AbsFrequencyKernel >	kernel2d

const bool	makeClusteringTree

std::unique_ptr< fftjet::Functor1< bool, fftjet::Peak > >	peakSelector

std::unique_ptr< fftjet::AbsFrequencyKernel1d >	phiKernel

std::unique_ptr< Sequencer >	sequencer

SparseTree	sparseTree

std::unique_ptr< Sparsifier >	sparsifier

const bool	sparsify

const bool	storeDiscretizationGrid

const bool	verifyDataConversion

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

Private Member Functions
	FFTJetPatRecoProducer ()=delete

	FFTJetPatRecoProducer (const FFTJetPatRecoProducer &)=delete

FFTJetPatRecoProducer &	operator= (const FFTJetPatRecoProducer &)=delete

Private Attributes
std::ofstream	externalGridStream

fftjet::Grid2d< float > *	extGrid

bool	storeGridsExternally

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

static bool	wantsStreamRuns ()

Detailed Description

Description: Runs FFTJet pattern recognition stage and saves the results

Implementation: [Notes on implementation]

Definition at line 63 of file FFTJetPatRecoProducer.cc.

Member Typedef Documentation

◆ ClusteringTree

typedef fftjet::ProximityClusteringTree<fftjet::Peak, long> FFTJetPatRecoProducer::ClusteringTree

protected

Definition at line 70 of file FFTJetPatRecoProducer.cc.

◆ Sequencer

typedef fftjet::ClusteringSequencer<Real> FFTJetPatRecoProducer::Sequencer

protected

Definition at line 72 of file FFTJetPatRecoProducer.cc.

◆ SparseTree

typedef fftjet::SparseClusteringTree<fftjet::Peak, long> FFTJetPatRecoProducer::SparseTree

protected

Definition at line 71 of file FFTJetPatRecoProducer.cc.

◆ Sparsifier

typedef fftjet::ClusteringTreeSparsifier<fftjet::Peak, long> FFTJetPatRecoProducer::Sparsifier

protected

Definition at line 73 of file FFTJetPatRecoProducer.cc.

Constructor & Destructor Documentation

◆ FFTJetPatRecoProducer() [1/3]

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

explicit

Definition at line 151 of file FFTJetPatRecoProducer.cc.

     : FFTJetInterface(ps),
       clusteringTree(nullptr),
       completeEventDataCutoff(ps.getParameter<double>("completeEventDataCutoff")),
       makeClusteringTree(ps.getParameter<bool>("makeClusteringTree")),
       verifyDataConversion(ps.getUntrackedParameter<bool>("verifyDataConversion", false)),
       storeDiscretizationGrid(ps.getParameter<bool>("storeDiscretizationGrid")),
       sparsify(ps.getParameter<bool>("sparsify")),
       extGrid(nullptr) {
   // register your products
   if (makeClusteringTree) {
     if (storeInSinglePrecision())
       produces<reco::PattRecoTree<float, reco::PattRecoPeak<float> > >(outputLabel);
     else
       produces<reco::PattRecoTree<double, reco::PattRecoPeak<double> > >(outputLabel);
   }
   if (storeDiscretizationGrid)
     produces<reco::DiscretizedEnergyFlow>(outputLabel);
  
   // Check if we want to write the grids into an external file
   const std::string externalGridFile(ps.getParameter<std::string>("externalGridFile"));
   storeGridsExternally = !externalGridFile.empty();
   if (storeGridsExternally) {
     externalGridStream.open(externalGridFile.c_str(), std::ios_base::out | std::ios_base::binary);
     if (!externalGridStream.is_open())
       throw cms::Exception("FFTJetBadConfig")
           << "FFTJetPatRecoProducer failed to open file " << externalGridFile << std::endl;
   }
  
   if (!makeClusteringTree && !storeDiscretizationGrid && !storeGridsExternally) {
     throw cms::Exception("FFTJetBadConfig")
         << "FFTJetPatRecoProducer is not configured to produce anything" << std::endl;
   }
  
   // now do whatever other initialization is needed
  
   // Build the discretization grid
   energyFlow = fftjet_Grid2d_parser(ps.getParameter<edm::ParameterSet>("GridConfiguration"));
   checkConfig(energyFlow, "invalid discretization grid");
  
   // Build the FFT engine(s), pattern recognition kernel(s),
   // and the kernel convolver
   buildKernelConvolver(ps);
  
   // Build the peak selector
   peakSelector = fftjet_PeakSelector_parser(ps.getParameter<edm::ParameterSet>("PeakSelectorConfiguration"));
   checkConfig(peakSelector, "invalid peak selector");
  
   // Build the initial set of pattern recognition scales
   std::unique_ptr<std::vector<double> > iniScales =
       fftjet_ScaleSet_parser(ps.getParameter<edm::ParameterSet>("InitialScales"));
   checkConfig(iniScales, "invalid set of scales");
  
   // Do we want to use the adaptive clustering tree algorithm?
   const unsigned maxAdaptiveScales = ps.getParameter<unsigned>("maxAdaptiveScales");
   const double minAdaptiveRatioLog = ps.getParameter<double>("minAdaptiveRatioLog");
   if (minAdaptiveRatioLog <= 0.0)
     throw cms::Exception("FFTJetBadConfig") << "bad adaptive ratio logarithm limit" << std::endl;
  
   // Make sure that all standard scales are larger than the
   // complete event scale
   if (getEventScale() > 0.0) {
     const double cs = getEventScale();
     const unsigned nscales = iniScales->size();
     for (unsigned i = 0; i < nscales; ++i)
       if (cs >= (*iniScales)[i])
         throw cms::Exception("FFTJetBadConfig") << "incompatible scale for complete event" << std::endl;
   }
  
   // At this point we are ready to build the clustering sequencer
   sequencer = std::unique_ptr<Sequencer>(new Sequencer(
       convolver.get(), peakSelector.get(), buildPeakFinder(ps), *iniScales, maxAdaptiveScales, minAdaptiveRatioLog));
  
   // Build the clustering tree sparsifier
   const edm::ParameterSet& SparsifierConfiguration(ps.getParameter<edm::ParameterSet>("SparsifierConfiguration"));
   sparsifier = fftjet_ClusteringTreeSparsifier_parser(SparsifierConfiguration);
   checkConfig(sparsifier, "invalid sparsifier parameters");
  
   // Build the distance calculator for the clustering tree
   const edm::ParameterSet& TreeDistanceCalculator(ps.getParameter<edm::ParameterSet>("TreeDistanceCalculator"));
   distanceCalc = fftjet_DistanceCalculator_parser(TreeDistanceCalculator);
   checkConfig(distanceCalc, "invalid tree distance calculator");
  
   // Build the clustering tree itself
   clusteringTree = new ClusteringTree(distanceCalc.get());
 }

References buildKernelConvolver(), buildPeakFinder(), fftjetcms::FFTJetInterface::checkConfig(), clusteringTree, convolver, fwrapper::cs, distanceCalc, fftjetcms::FFTJetInterface::energyFlow, Exception, fftjetpatrecoproducer_cfi::externalGridFile, externalGridStream, fftjetcms::fftjet_ClusteringTreeSparsifier_parser(), fftjetcms::fftjet_DistanceCalculator_parser(), fftjetcms::fftjet_Grid2d_parser(), fftjetcms::fftjet_PeakSelector_parser(), fftjetcms::fftjet_ScaleSet_parser(), fftjetcms::FFTJetInterface::getEventScale(), edm::ParameterSet::getParameter(), mps_fire::i, makeClusteringTree, fftjetpatrecoproducer_cfi::maxAdaptiveScales, fftjetpatrecoproducer_cfi::minAdaptiveRatioLog, MillePedeFileConverter_cfg::out, fftjetcms::FFTJetInterface::outputLabel, peakSelector, sequencer, sparsifier, fftjetpatrecoproducer_cfi::SparsifierConfiguration, storeDiscretizationGrid, storeGridsExternally, fftjetcms::FFTJetInterface::storeInSinglePrecision(), AlCaHLTBitMon_QueryRunRegistry::string, and fftjetdijetfilter_cfi::TreeDistanceCalculator.

◆ ~FFTJetPatRecoProducer()

FFTJetPatRecoProducer::~FFTJetPatRecoProducer ( )

override

Definition at line 319 of file FFTJetPatRecoProducer.cc.

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

References clusteringTree, and extGrid.

◆ FFTJetPatRecoProducer() [2/3]

FFTJetPatRecoProducer::FFTJetPatRecoProducer ( )

privatedelete

◆ FFTJetPatRecoProducer() [3/3]

FFTJetPatRecoProducer::FFTJetPatRecoProducer ( const FFTJetPatRecoProducer & )

privatedelete

Member Function Documentation

◆ beginJob()

void FFTJetPatRecoProducer::beginJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDProducer.

Definition at line 428 of file FFTJetPatRecoProducer.cc.

428 {}

◆ buildDenseProduct()

template<class Real >

void FFTJetPatRecoProducer::buildDenseProduct ( edm::Event & ev ) const

protected

Definition at line 350 of file FFTJetPatRecoProducer.cc.

                                                                 {
   typedef reco::PattRecoTree<Real, reco::PattRecoPeak<Real> > StoredTree;
  
   auto tree = std::make_unique<StoredTree>();
  
   densePeakTreeToStorable(*clusteringTree, sequencer->maxAdaptiveScales(), tree.get());
  
   // Check that we can restore the tree
   if (verifyDataConversion && !storeInSinglePrecision()) {
     ClusteringTree check(distanceCalc.get());
     const std::vector<double>& scalesUsed(sequencer->getInitialScales());
     densePeakTreeFromStorable(*tree, &scalesUsed, getEventScale(), &check);
     if (*clusteringTree != check)
       throw cms::Exception("FFTJetInterface") << "Data conversion failed for dense clustering tree" << std::endl;
   }
  
   ev.put(std::move(tree), outputLabel);
 }

References RPCNoise_example::check, clusteringTree, fftjetcms::densePeakTreeFromStorable(), fftjetcms::densePeakTreeToStorable(), distanceCalc, ev, Exception, fftjetcms::FFTJetInterface::getEventScale(), eostools::move(), fftjetcms::FFTJetInterface::outputLabel, sequencer, fftjetcms::FFTJetInterface::storeInSinglePrecision(), and verifyDataConversion.

◆ buildKernelConvolver()

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

protected

Definition at line 238 of file FFTJetPatRecoProducer.cc.

                                                                           {
   // 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::unique_ptr<MyFFTEngine>(new 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::unique_ptr<MyFFTEngine>(new MyFFTEngine(1, energyFlow->nEta()));
     anotherEngine = std::unique_ptr<MyFFTEngine>(new 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));
   }
 }

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 FFTJetPatRecoProducer().

◆ buildPeakFinder()

fftjet::PeakFinder FFTJetPatRecoProducer::buildPeakFinder ( const edm::ParameterSet & ps )

protected

Definition at line 305 of file FFTJetPatRecoProducer.cc.

                                                                                  {
   const double peakFinderMaxEta = ps.getParameter<double>("peakFinderMaxEta");
   if (peakFinderMaxEta <= 0.0)
     throw cms::Exception("FFTJetBadConfig") << "invalid peak finder eta cut" << std::endl;
   const double maxMagnitude = ps.getParameter<double>("peakFinderMaxMagnitude");
   int minBin = energyFlow->getEtaBin(-peakFinderMaxEta);
   if (minBin < 0)
     minBin = 0;
   int maxBin = energyFlow->getEtaBin(peakFinderMaxEta) + 1;
   if (maxBin < 0)
     maxBin = 0;
   return fftjet::PeakFinder(maxMagnitude, true, minBin, maxBin);
 }

References fftjetcms::FFTJetInterface::energyFlow, Exception, edm::ParameterSet::getParameter(), cms::cuda::allocator::maxBin, cms::cuda::allocator::minBin, and fftjetpatrecoproducer_cfi::peakFinderMaxEta.

Referenced by FFTJetPatRecoProducer().

◆ buildSparseProduct()

template<class Real >

void FFTJetPatRecoProducer::buildSparseProduct ( edm::Event & ev ) const

protected

Definition at line 330 of file FFTJetPatRecoProducer.cc.

                                                                  {
   typedef reco::PattRecoTree<Real, reco::PattRecoPeak<Real> > StoredTree;
  
   auto tree = std::make_unique<StoredTree>();
  
   sparsePeakTreeToStorable(sparseTree, sequencer->maxAdaptiveScales(), tree.get());
  
   // Check that we can restore the tree
   if (verifyDataConversion && !storeInSinglePrecision()) {
     SparseTree check;
     const std::vector<double>& scalesUsed(sequencer->getInitialScales());
     sparsePeakTreeFromStorable(*tree, &scalesUsed, getEventScale(), &check);
     if (sparseTree != check)
       throw cms::Exception("FFTJetInterface") << "Data conversion failed for sparse clustering tree" << std::endl;
   }
  
   ev.put(std::move(tree), outputLabel);
 }

References RPCNoise_example::check, ev, Exception, fftjetcms::FFTJetInterface::getEventScale(), eostools::move(), fftjetcms::FFTJetInterface::outputLabel, sequencer, fftjetcms::sparsePeakTreeFromStorable(), fftjetcms::sparsePeakTreeToStorable(), sparseTree, fftjetcms::FFTJetInterface::storeInSinglePrecision(), and verifyDataConversion.

◆ endJob()

void FFTJetPatRecoProducer::endJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDProducer.

Definition at line 431 of file FFTJetPatRecoProducer.cc.

                                    {
   if (storeGridsExternally)
     externalGridStream.close();
 }

References externalGridStream, and storeGridsExternally.

◆ operator=()

FFTJetPatRecoProducer& FFTJetPatRecoProducer::operator= ( const FFTJetPatRecoProducer & )

privatedelete

◆ produce()

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

overrideprotectedvirtual

Implements edm::EDProducer.

Definition at line 370 of file FFTJetPatRecoProducer.cc.

                                                                                  {
   loadInputCollection(iEvent);
   discretizeEnergyFlow();
  
   if (makeClusteringTree) {
     sequencer->run(*energyFlow, clusteringTree);
     if (getEventScale() > 0.0)
       sequencer->insertCompleteEvent(getEventScale(), *energyFlow, clusteringTree, completeEventDataCutoff);
  
     if (sparsify) {
       sparsifier->sparsify(*clusteringTree, &sparseTree);
  
       // Do not call the "sortNodes" method of the sparse tree here.
       // Currently, the nodes are sorted by daughter number.
       // This is the way we want it in storage because the stored
       // tree does not include daughter ordering info explicitly.
  
       if (storeInSinglePrecision())
         buildSparseProduct<float>(iEvent);
       else
         buildSparseProduct<double>(iEvent);
     } else {
       if (storeInSinglePrecision())
         buildDenseProduct<float>(iEvent);
       else
         buildDenseProduct<double>(iEvent);
     }
   }
  
   if (storeDiscretizationGrid) {
     const fftjet::Grid2d<Real>& g(*energyFlow);
  
     auto flow = std::make_unique<reco::DiscretizedEnergyFlow>(
         g.data(), g.title(), g.etaMin(), g.etaMax(), g.phiBin0Edge(), g.nEta(), g.nPhi());
  
     if (verifyDataConversion) {
       fftjet::Grid2d<Real> check(
           flow->nEtaBins(), flow->etaMin(), flow->etaMax(), flow->nPhiBins(), flow->phiBin0Edge(), flow->title());
       check.blockSet(flow->data(), flow->nEtaBins(), flow->nPhiBins());
       assert(g == check);
     }
  
     iEvent.put(std::move(flow), outputLabel);
   }
  
   if (storeGridsExternally) {
     if (extGrid)
       copy_Grid2d_data(extGrid, *energyFlow);
     else
       extGrid = convert_Grid2d_to_float(*energyFlow);
     if (!extGrid->write(externalGridStream)) {
       throw cms::Exception("FFTJetPatRecoProducer::produce")
           << "Failed to write grid data into an external file" << std::endl;
     }
   }
 }

References cms::cuda::assert(), RPCNoise_example::check, clusteringTree, completeEventDataCutoff, fftjetcms::convert_Grid2d_to_float(), fftjetcms::copy_Grid2d_data(), fftjetcms::FFTJetInterface::discretizeEnergyFlow(), fftjetcms::FFTJetInterface::energyFlow, Exception, externalGridStream, extGrid, fftjetcommon_cfi::flow, g, fftjetcms::FFTJetInterface::getEventScale(), iEvent, fftjetcms::FFTJetInterface::loadInputCollection(), makeClusteringTree, eostools::move(), fftjetcms::FFTJetInterface::outputLabel, sequencer, sparseTree, sparsifier, sparsify, storeDiscretizationGrid, storeGridsExternally, fftjetcms::FFTJetInterface::storeInSinglePrecision(), and verifyDataConversion.

Member Data Documentation

◆ anotherEngine

std::unique_ptr<MyFFTEngine> FFTJetPatRecoProducer::anotherEngine

protected

Definition at line 100 of file FFTJetPatRecoProducer.cc.

Referenced by buildKernelConvolver().

◆ clusteringTree

ClusteringTree* FFTJetPatRecoProducer::clusteringTree

protected

Definition at line 90 of file FFTJetPatRecoProducer.cc.

Referenced by buildDenseProduct(), FFTJetPatRecoProducer(), produce(), and ~FFTJetPatRecoProducer().

◆ completeEventDataCutoff

const double FFTJetPatRecoProducer::completeEventDataCutoff

protected

Definition at line 122 of file FFTJetPatRecoProducer.cc.

Referenced by produce().

◆ convolver

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

protected

Definition at line 108 of file FFTJetPatRecoProducer.cc.

Referenced by buildKernelConvolver(), and FFTJetPatRecoProducer().

◆ distanceCalc

std::unique_ptr<fftjet::AbsDistanceCalculator<fftjet::Peak> > FFTJetPatRecoProducer::distanceCalc

protected

Definition at line 114 of file FFTJetPatRecoProducer.cc.

Referenced by buildDenseProduct(), and FFTJetPatRecoProducer().

◆ engine

std::unique_ptr<MyFFTEngine> FFTJetPatRecoProducer::engine

protected

Definition at line 99 of file FFTJetPatRecoProducer.cc.

Referenced by buildKernelConvolver().

◆ etaKernel

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

protected

Definition at line 104 of file FFTJetPatRecoProducer.cc.

Referenced by buildKernelConvolver().

◆ externalGridStream

std::ofstream FFTJetPatRecoProducer::externalGridStream

private

Definition at line 143 of file FFTJetPatRecoProducer.cc.

Referenced by endJob(), FFTJetPatRecoProducer(), and produce().

◆ extGrid

fftjet::Grid2d<float>* FFTJetPatRecoProducer::extGrid

private

Definition at line 145 of file FFTJetPatRecoProducer.cc.

Referenced by produce(), and ~FFTJetPatRecoProducer().

◆ kernel2d

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

protected

Definition at line 103 of file FFTJetPatRecoProducer.cc.

Referenced by buildKernelConvolver().

◆ makeClusteringTree

const bool FFTJetPatRecoProducer::makeClusteringTree

protected

Definition at line 125 of file FFTJetPatRecoProducer.cc.

Referenced by FFTJetPatRecoProducer(), and produce().

◆ peakSelector

std::unique_ptr<fftjet::Functor1<bool, fftjet::Peak> > FFTJetPatRecoProducer::peakSelector

protected

Definition at line 111 of file FFTJetPatRecoProducer.cc.

Referenced by FFTJetPatRecoProducer().

◆ phiKernel

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

protected

Definition at line 105 of file FFTJetPatRecoProducer.cc.

Referenced by buildKernelConvolver().

◆ sequencer

std::unique_ptr<Sequencer> FFTJetPatRecoProducer::sequencer

protected

Definition at line 95 of file FFTJetPatRecoProducer.cc.

Referenced by buildDenseProduct(), buildSparseProduct(), FFTJetPatRecoProducer(), and produce().

◆ sparseTree

SparseTree FFTJetPatRecoProducer::sparseTree

protected

Definition at line 117 of file FFTJetPatRecoProducer.cc.

Referenced by buildSparseProduct(), and produce().

◆ sparsifier

std::unique_ptr<Sparsifier> FFTJetPatRecoProducer::sparsifier

protected

Definition at line 96 of file FFTJetPatRecoProducer.cc.

Referenced by FFTJetPatRecoProducer(), and produce().

◆ sparsify

const bool FFTJetPatRecoProducer::sparsify

protected

Definition at line 135 of file FFTJetPatRecoProducer.cc.

Referenced by produce().

◆ storeDiscretizationGrid

const bool FFTJetPatRecoProducer::storeDiscretizationGrid

protected

Definition at line 132 of file FFTJetPatRecoProducer.cc.

Referenced by FFTJetPatRecoProducer(), and produce().

◆ storeGridsExternally

bool FFTJetPatRecoProducer::storeGridsExternally

private

Definition at line 144 of file FFTJetPatRecoProducer.cc.

Referenced by endJob(), FFTJetPatRecoProducer(), and produce().

◆ verifyDataConversion

const bool FFTJetPatRecoProducer::verifyDataConversion

protected

Definition at line 129 of file FFTJetPatRecoProducer.cc.

Referenced by buildDenseProduct(), buildSparseProduct(), and produce().

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ClusteringTree

◆ Sequencer

◆ SparseTree

◆ Sparsifier

Constructor & Destructor Documentation

◆ FFTJetPatRecoProducer() [1/3]

◆ ~FFTJetPatRecoProducer()

◆ FFTJetPatRecoProducer() [2/3]

◆ FFTJetPatRecoProducer() [3/3]

Member Function Documentation

◆ beginJob()

◆ buildDenseProduct()

◆ buildKernelConvolver()

◆ buildPeakFinder()

◆ buildSparseProduct()

◆ endJob()

◆ operator=()

◆ produce()

Member Data Documentation

◆ anotherEngine

◆ clusteringTree

◆ completeEventDataCutoff

◆ convolver

◆ distanceCalc

◆ engine

◆ etaKernel

◆ externalGridStream

◆ extGrid

◆ kernel2d

◆ makeClusteringTree

◆ peakSelector

◆ phiKernel

◆ sequencer

◆ sparseTree

◆ sparsifier

◆ sparsify

◆ storeDiscretizationGrid

◆ storeGridsExternally

◆ verifyDataConversion