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

Inheritance diagram for FFTJetPatRecoProducer:

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

	FFTJetPatRecoProducer ()=delete

	FFTJetPatRecoProducer (const FFTJetPatRecoProducer &)=delete

FFTJetPatRecoProducer &	operator= (const FFTJetPatRecoProducer &)=delete

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

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)

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

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

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)

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

static bool	wantsProcessBlocks ()

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 64 of file FFTJetPatRecoProducer.cc.

Member Typedef Documentation

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

protected

Definition at line 74 of file FFTJetPatRecoProducer.cc.

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

protected

Definition at line 76 of file FFTJetPatRecoProducer.cc.

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

protected

Definition at line 75 of file FFTJetPatRecoProducer.cc.

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

protected

Definition at line 77 of file FFTJetPatRecoProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 151 of file FFTJetPatRecoProducer.cc.

References buildKernelConvolver(), buildPeakFinder(), fftjetcms::FFTJetInterface::checkConfig(), clusteringTree, convolver, fwrapper::cs, distanceCalc, fftjetcms::FFTJetInterface::energyFlow, Exception, 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, submitPVResolutionJobs::out, fftjetcms::FFTJetInterface::outputLabel, peakSelector, sequencer, sparsifier, storeDiscretizationGrid, storeGridsExternally, fftjetcms::FFTJetInterface::storeInSinglePrecision(), and AlCaHLTBitMon_QueryRunRegistry::string.

     : 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::make_unique<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());
 }

FFTJetPatRecoProducer::FFTJetPatRecoProducer ( )

delete

FFTJetPatRecoProducer::FFTJetPatRecoProducer ( const FFTJetPatRecoProducer & )

delete

FFTJetPatRecoProducer::~FFTJetPatRecoProducer ( )

override

Definition at line 319 of file FFTJetPatRecoProducer.cc.

References clusteringTree, and extGrid.

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

Member Function Documentation

void FFTJetPatRecoProducer::beginJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDProducer.

Definition at line 428 of file FFTJetPatRecoProducer.cc.

428 {}

template<class Real >

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

protected

Definition at line 350 of file FFTJetPatRecoProducer.cc.

References trackerTree::check(), clusteringTree, fftjetcms::densePeakTreeFromStorable(), fftjetcms::densePeakTreeToStorable(), distanceCalc, Exception, fftjetcms::FFTJetInterface::getEventScale(), eostools::move(), fftjetcms::FFTJetInterface::outputLabel, edm::Event::put(), sequencer, fftjetcms::FFTJetInterface::storeInSinglePrecision(), MainPageGenerator::tree, and verifyDataConversion.

                                                                 {
   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);
 }

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

protected

Definition at line 238 of file FFTJetPatRecoProducer.cc.

References anotherEngine, convolver, fftjetcms::FFTJetInterface::energyFlow, engine, etaKernel, Exception, edm::ParameterSet::getParameter(), kernel2d, M_PI, and phiKernel.

Referenced by FFTJetPatRecoProducer().

                                                                           {
   // 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));
   }
 }

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

protected

Definition at line 305 of file FFTJetPatRecoProducer.cc.

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

Referenced by FFTJetPatRecoProducer().

                                                                                  {
   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);
 }

template<class Real >

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

protected

Definition at line 330 of file FFTJetPatRecoProducer.cc.

References trackerTree::check(), Exception, fftjetcms::FFTJetInterface::getEventScale(), eostools::move(), fftjetcms::FFTJetInterface::outputLabel, edm::Event::put(), sequencer, fftjetcms::sparsePeakTreeFromStorable(), fftjetcms::sparsePeakTreeToStorable(), sparseTree, fftjetcms::FFTJetInterface::storeInSinglePrecision(), MainPageGenerator::tree, and verifyDataConversion.

                                                                  {
   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);
 }

void FFTJetPatRecoProducer::endJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDProducer.

Definition at line 431 of file FFTJetPatRecoProducer.cc.

References externalGridStream, and storeGridsExternally.

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

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

delete

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

overrideprotectedvirtual

Implements edm::EDProducer.

Definition at line 370 of file FFTJetPatRecoProducer.cc.

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

                                                                                  {
   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;
     }
   }
 }