#include <RecoJets/FFTJetProducers/plugins/FFTJetProducer.h>

Inheritance diagram for FFTJetProducer:

Public Types
typedef fftjet::RecombinedJet< fftjetcms::VectorLike >	RecoFFTJet

enum	Resolution { FIXED = 0, MAXIMALLY_STABLE, GLOBALLY_ADAPTIVE, LOCALLY_ADAPTIVE, FROM_GENJETS }

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

enum	StatusBits { RESOLUTION = 0xff, CONSTITUENTS_RESUMMED = 0x100, PILEUP_CALCULATED = 0x200, PILEUP_SUBTRACTED_4VEC = 0x400, PILEUP_SUBTRACTED_PT = 0x800 }

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

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

	FFTJetProducer ()=delete

	FFTJetProducer (const FFTJetProducer &)=delete

template<class Real >
void	loadSparseTreeData (const edm::Event &iEvent, const edm::EDGetTokenT< reco::PattRecoTree< Real, reco::PattRecoPeak< Real > > > &tok)

FFTJetProducer &	operator= (const FFTJetProducer &)=delete

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

Static Public Member Functions
static Resolution	parse_resolution (const std::string &name)

Protected Member Functions
virtual void	assignMembershipFunctions (std::vector< fftjet::Peak > *preclusters)

void	beginStream (edm::StreamID) override

virtual void	genJetPreclusters (const SparseTree &tree, edm::Event &, const edm::EventSetup &, const fftjet::Functor1< bool, fftjet::Peak > &peakSelector, std::vector< fftjet::Peak > *preclusters)

virtual std::unique_ptr< fftjetcms::AbsBgFunctor >	parse_bgMembershipFunction (const edm::ParameterSet &)

virtual std::unique_ptr< fftjet::Functor2< double, RecoFFTJet, RecoFFTJet > >	parse_jetDistanceCalc (const edm::ParameterSet &)

virtual std::unique_ptr< fftjet::ScaleSpaceKernel >	parse_jetMembershipFunction (const edm::ParameterSet &)

virtual std::unique_ptr< fftjet::Functor1< double, RecoFFTJet > >	parse_memberFactorCalcJet (const edm::ParameterSet &)

virtual std::unique_ptr< fftjet::Functor1< double, fftjet::Peak > >	parse_memberFactorCalcPeak (const edm::ParameterSet &)

virtual std::unique_ptr< fftjet::Functor1< bool, fftjet::Peak > >	parse_peakSelector (const edm::ParameterSet &)

virtual std::unique_ptr< fftjetcms::AbsPileupCalculator >	parse_pileupDensityCalc (const edm::ParameterSet &ps)

virtual std::unique_ptr< fftjet::Functor1< double, RecoFFTJet > >	parse_recoScaleCalcJet (const edm::ParameterSet &)

virtual std::unique_ptr< fftjet::Functor1< double, fftjet::Peak > >	parse_recoScaleCalcPeak (const edm::ParameterSet &)

virtual std::unique_ptr< fftjet::Functor1< double, RecoFFTJet > >	parse_recoScaleRatioCalcJet (const edm::ParameterSet &)

virtual std::unique_ptr< fftjet::Functor1< double, fftjet::Peak > >	parse_recoScaleRatioCalcPeak (const edm::ParameterSet &)

void	produce (edm::Event &, const edm::EventSetup &) override

virtual void	selectPreclusters (const SparseTree &tree, const fftjet::Functor1< bool, fftjet::Peak > &peakSelector, std::vector< fftjet::Peak > *preclusters)

void	selectTreeNodes (const SparseTree &tree, const fftjet::Functor1< bool, fftjet::Peak > &peakSelect, std::vector< SparseTree::NodeId > *nodes)

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 Types
typedef fftjet::AbsRecombinationAlg< fftjetcms::Real, fftjetcms::VectorLike, fftjetcms::BgData >	GridAlg

typedef fftjet::AbsVectorRecombinationAlg< fftjetcms::VectorLike, fftjetcms::BgData >	RecoAlg

Private Member Functions
void	buildGridAlg ()

bool	checkConvergence (const std::vector< RecoFFTJet > &previousIterResult, std::vector< RecoFFTJet > &thisIterResult)

void	determineGriddedConstituents ()

void	determinePileup ()

virtual void	determinePileupDensityFromConfig (const edm::Event &iEvent, std::unique_ptr< fftjet::Grid2d< fftjetcms::Real > > &density)

virtual void	determinePileupDensityFromDB (const edm::Event &iEvent, const edm::EventSetup &iSetup, std::unique_ptr< fftjet::Grid2d< fftjetcms::Real > > &density)

void	determineVectorConstituents ()

unsigned	iterateJetReconstruction ()

bool	loadEnergyFlow (const edm::Event &iEvent, std::unique_ptr< fftjet::Grid2d< fftjetcms::Real > > &flow)

template<class Real >
void	loadSparseTreeData (const edm::Event &, const edm::EDGetTokenT< reco::PattRecoTree< Real, reco::PattRecoPeak< Real > > > &tok)

template<typename Jet >
void	makeProduces (const std::string &alias, const std::string &tag)

void	prepareRecombinationScales ()

void	removeFakePreclusters ()

void	saveResults (edm::Event &iEvent, const edm::EventSetup &, unsigned nPreclustersFound)

template<typename Jet >
void	writeJets (edm::Event &iEvent, const edm::EventSetup &)

Static Private Member Functions
static void	setJetStatusBit (RecoFFTJet *jet, int mask, bool value)

Private Attributes
const bool	assignConstituents

std::unique_ptr< fftjetcms::AbsBgFunctor >	bgMembershipFunction

const bool	calculatePileup

std::vector< unsigned >	cellCountsVec

std::vector< std::vector< reco::CandidatePtr > >	constituents

const double	convergenceDistance

std::vector< double >	doubleBuf

FFTJetLookupTableSequenceLoader	esLoader_

const double	fixedScale

const edm::InputTag	genJetsLabel

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geometry_token_

std::unique_ptr< GridAlg >	gridAlg

const double	gridScanMaxEta

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

edm::EDGetTokenT< reco::DiscretizedEnergyFlow >	input_energyflow_token_

edm::EDGetTokenT< std::vector< reco::FFTAnyJet< reco::GenJet > > >	input_genjet_token_

edm::EDGetTokenT< reco::FFTJetPileupSummary >	input_pusummary_token_

edm::EDGetTokenT< reco::PattRecoTree< double, reco::PattRecoPeak< double > > >	input_recotree_token_d_

edm::EDGetTokenT< reco::PattRecoTree< float, reco::PattRecoPeak< float > > >	input_recotree_token_f_

const bool	isCrisp

unsigned	iterationsPerformed

std::vector< RecoFFTJet >	iterJets

std::vector< fftjet::Peak >	iterPreclusters

std::unique_ptr< fftjet::Functor2< double, RecoFFTJet, RecoFFTJet > >	jetDistanceCalc

std::unique_ptr< fftjet::ScaleSpaceKernel >	jetMembershipFunction

bool	loadPileupFromDB

const unsigned	maxInitialPreclusters

const unsigned	maxIterations

unsigned	maxLevel

const double	maxStableScale

std::unique_ptr< fftjet::Functor1< double, RecoFFTJet > >	memberFactorCalcJet

std::unique_ptr< fftjet::Functor1< double, fftjet::Peak > >	memberFactorCalcPeak

std::vector< fftjet::AbsKernel2d * >	memFcns2dVec

unsigned	minLevel

const double	minStableScale

const edm::ParameterSet	myConfiguration

const unsigned	nClustersRequested

const unsigned	nJetsRequiredToConverge

std::vector< SparseTree::NodeId >	nodes

const double	noiseLevel

std::vector< unsigned >	occupancy

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

std::vector< fftjetcms::VectorLike >	pileup

std::unique_ptr< fftjetcms::AbsPileupCalculator >	pileupDensityCalc

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

const edm::InputTag	pileupLabel

std::string	pileupTableCategory

std::string	pileupTableName

std::string	pileupTableRecord

std::vector< fftjet::Peak >	preclusters

std::unique_ptr< RecoAlg >	recoAlg

std::vector< RecoFFTJet >	recoJets

const std::string	recombinationAlgorithm

const double	recombinationDataCutoff

std::unique_ptr< fftjet::Functor1< double, RecoFFTJet > >	recoScaleCalcJet

std::unique_ptr< fftjet::Functor1< double, fftjet::Peak > >	recoScaleCalcPeak

std::unique_ptr< fftjet::Functor1< double, RecoFFTJet > >	recoScaleRatioCalcJet

std::unique_ptr< fftjet::Functor1< double, fftjet::Peak > >	recoScaleRatioCalcPeak

Resolution	resolution

const bool	resumConstituents

const bool	reuseExistingGrid

SparseTree	sparseTree

const double	stabilityAlpha

const bool	subtractPileup

const bool	subtractPileupAs4Vec

std::vector< double >	thresholds

edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	topology_token_

const edm::InputTag	treeLabel

fftjetcms::VectorLike	unclustered

const double	unlikelyBgWeight

double	unused

unsigned	usedLevel

const bool	useGriddedAlgorithm

Additional Inherited Members
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: makes jets using FFTJet clustering tree

Implementation: [Notes on implementation]

Description: makes jets using FFTJet clustering tree

Implementation: If you want to change the jet algorithm functionality (for example, by providing your own jet membership function), derive from this class and override the appropriate parser method (for example, parse_jetMembershipFunction). At the end of your own parser, don't forget to call the parser of the base class in order to get the default behavior when your special configuration is not provided (this is known as the "chain-of-responsibility" design pattern). If you also need to override "beginJob" and/or "produce" methods, the first thing to do in your method is to call the corresponding method of this base.

Definition at line 84 of file FFTJetProducer.h.

Member Typedef Documentation

◆ GridAlg

typedef fftjet::AbsRecombinationAlg<fftjetcms::Real, fftjetcms::VectorLike, fftjetcms::BgData> FFTJetProducer::GridAlg

private

Definition at line 183 of file FFTJetProducer.h.

◆ RecoAlg

typedef fftjet::AbsVectorRecombinationAlg<fftjetcms::VectorLike, fftjetcms::BgData> FFTJetProducer::RecoAlg

private

Definition at line 182 of file FFTJetProducer.h.

◆ RecoFFTJet

typedef fftjet::RecombinedJet<fftjetcms::VectorLike> FFTJetProducer::RecoFFTJet

Definition at line 86 of file FFTJetProducer.h.

◆ SparseTree

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

Definition at line 87 of file FFTJetProducer.h.

Member Enumeration Documentation

◆ Resolution

enum FFTJetProducer::Resolution

Enumerator
FIXED
MAXIMALLY_STABLE
GLOBALLY_ADAPTIVE
LOCALLY_ADAPTIVE
FROM_GENJETS

Definition at line 100 of file FFTJetProducer.h.

100 { FIXED = 0, MAXIMALLY_STABLE, GLOBALLY_ADAPTIVE, LOCALLY_ADAPTIVE, FROM_GENJETS };

FFTJetProducer::GLOBALLY_ADAPTIVE

Definition: FFTJetProducer.h:100

FFTJetProducer::FIXED

Definition: FFTJetProducer.h:100

FFTJetProducer::LOCALLY_ADAPTIVE

Definition: FFTJetProducer.h:100

FFTJetProducer::MAXIMALLY_STABLE

Definition: FFTJetProducer.h:100

FFTJetProducer::FROM_GENJETS

Definition: FFTJetProducer.h:100

◆ StatusBits

enum FFTJetProducer::StatusBits

Enumerator
RESOLUTION
CONSTITUENTS_RESUMMED
PILEUP_CALCULATED
PILEUP_SUBTRACTED_4VEC
PILEUP_SUBTRACTED_PT

Definition at line 92 of file FFTJetProducer.h.

                   {
     RESOLUTION = 0xff,
     CONSTITUENTS_RESUMMED = 0x100,
     PILEUP_CALCULATED = 0x200,
     PILEUP_SUBTRACTED_4VEC = 0x400,
     PILEUP_SUBTRACTED_PT = 0x800
   };

Constructor & Destructor Documentation

◆ FFTJetProducer() [1/3]

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

explicit

Definition at line 116 of file FFTJetProducer.cc.

References DefaultFFTJetRcdMapper< DataType >::acquireToken(), SiStripOfflineCRack_cfg::alias, assignConstituents, fftjetcms::CALOJET, fftjetcms::FFTJetInterface::checkConfig(), deDxTools::esConsumes(), esLoader_, Exception, fftjetcms::fftjet_ScaleSet_parser(), genJetsLabel, geometry_token_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), iniScales, input_energyflow_token_, input_genjet_token_, input_pusummary_token_, input_recotree_token_d_, input_recotree_token_f_, jet_type_switch, fftjetcms::FFTJetInterface::jetType, makeProduces(), fftjetcms::FFTJetInterface::outputLabel, pileupLabel, pileupTableRecord, resumConstituents, jetUpdater_cfi::sort, fftjetcms::FFTJetInterface::storeInSinglePrecision(), AlCaHLTBitMon_QueryRunRegistry::string, topology_token_, and treeLabel.

     : FFTJetInterface(ps),
       myConfiguration(ps),
       init_param(edm::InputTag, treeLabel),
       init_param(bool, useGriddedAlgorithm),
       init_param(bool, reuseExistingGrid),
       init_param(unsigned, maxIterations),
       init_param(unsigned, nJetsRequiredToConverge),
       init_param(double, convergenceDistance),
       init_param(bool, assignConstituents),
       init_param(bool, resumConstituents),
       init_param(bool, calculatePileup),
       init_param(bool, subtractPileup),
       init_param(bool, subtractPileupAs4Vec),
       init_param(edm::InputTag, pileupLabel),
       init_param(double, fixedScale),
       init_param(double, minStableScale),
       init_param(double, maxStableScale),
       init_param(double, stabilityAlpha),
       init_param(double, noiseLevel),
       init_param(unsigned, nClustersRequested),
       init_param(double, gridScanMaxEta),
       init_param(std::string, recombinationAlgorithm),
       init_param(bool, isCrisp),
       init_param(double, unlikelyBgWeight),
       init_param(double, recombinationDataCutoff),
       init_param(edm::InputTag, genJetsLabel),
       init_param(unsigned, maxInitialPreclusters),
       resolution(parse_resolution(ps.getParameter<std::string>("resolution"))),
       init_param(std::string, pileupTableRecord),
       init_param(std::string, pileupTableName),
       init_param(std::string, pileupTableCategory),
       init_param(bool, loadPileupFromDB),
 
       minLevel(0),
       maxLevel(0),
       usedLevel(0),
       unused(0.0),
       iterationsPerformed(1U),
       constituents(200) {
   // Check that the settings make sense
   if (resumConstituents && !assignConstituents)
     throw cms::Exception("FFTJetBadConfig") << "Can't resum constituents if they are not assigned" << std::endl;
 
   produces<reco::FFTJetProducerSummary>(outputLabel);
   const std::string alias(ps.getUntrackedParameter<std::string>("alias", outputLabel));
   jet_type_switch(makeProduces, alias, outputLabel);
 
   if (jetType == CALOJET) {
     geometry_token_ = esConsumes();
     topology_token_ = esConsumes();
   }
 
   // Build the set of pattern recognition scales.
   // This is needed in order to read the clustering tree
   // from the event record.
   iniScales = fftjet_ScaleSet_parser(ps.getParameter<edm::ParameterSet>("InitialScales"));
   checkConfig(iniScales, "invalid set of scales");
   std::sort(iniScales->begin(), iniScales->end(), std::greater<double>());
 
   if (storeInSinglePrecision())
     input_recotree_token_f_ = consumes<reco::PattRecoTree<float, reco::PattRecoPeak<float> > >(treeLabel);
   else
     input_recotree_token_d_ = consumes<reco::PattRecoTree<double, reco::PattRecoPeak<double> > >(treeLabel);
   input_genjet_token_ = consumes<std::vector<reco::FFTAnyJet<reco::GenJet> > >(genJetsLabel);
   input_energyflow_token_ = consumes<reco::DiscretizedEnergyFlow>(treeLabel);
   input_pusummary_token_ = consumes<reco::FFTJetPileupSummary>(pileupLabel);
 
   esLoader_.acquireToken(pileupTableRecord, consumesCollector());
 
   // Most of the configuration has to be performed inside
   // the "beginStream" method. This is because chaining of the
   // parsers between this base class and the derived classes
   // can not work from the constructor of the base class.
 }

◆ FFTJetProducer() [2/3]

FFTJetProducer::FFTJetProducer ( )

delete

◆ FFTJetProducer() [3/3]

FFTJetProducer::FFTJetProducer ( const FFTJetProducer & )

delete

◆ ~FFTJetProducer()

FFTJetProducer::~FFTJetProducer ( )

override

Definition at line 192 of file FFTJetProducer.cc.

192 {}

Member Function Documentation

◆ assignMembershipFunctions()

void FFTJetProducer::assignMembershipFunctions ( std::vector< fftjet::Peak > * preclusters )

protectedvirtual

Definition at line 815 of file FFTJetProducer.cc.

Referenced by produce().

815 {}

◆ beginStream()

void FFTJetProducer::beginStream ( edm::StreamID )

overrideprotected

Definition at line 818 of file FFTJetProducer.cc.

References assignConstituents, bgMembershipFunction, buildGridAlg(), calculatePileup, fftjetcms::FFTJetInterface::checkConfig(), fftjetcms::FFTJetInterface::energyFlow, Exception, fftjetcms::fftjet_Grid2d_parser(), edm::ParameterSet::getParameter(), isCrisp, jetDistanceCalc, jetMembershipFunction, loadPileupFromDB, maxIterations, memberFactorCalcJet, memberFactorCalcPeak, myConfiguration, parse_bgMembershipFunction(), parse_jetDistanceCalc(), parse_jetMembershipFunction(), parse_memberFactorCalcJet(), parse_memberFactorCalcPeak(), parse_peakSelector(), parse_pileupDensityCalc(), parse_recoScaleCalcJet(), parse_recoScaleCalcPeak(), parse_recoScaleRatioCalcJet(), parse_recoScaleRatioCalcPeak(), peakSelector, VtxSmearedParameters_cfi::Phi, pileupDensityCalc, pileupEnergyFlow, recoAlg, recombinationAlgorithm, recoScaleCalcJet, recoScaleCalcPeak, recoScaleRatioCalcJet, recoScaleRatioCalcPeak, reuseExistingGrid, unlikelyBgWeight, and useGriddedAlgorithm.

                                             {
   const edm::ParameterSet& ps(myConfiguration);
 
   // Parse the peak selector definition
   peakSelector = parse_peakSelector(ps);
   checkConfig(peakSelector, "invalid peak selector");
 
   jetMembershipFunction = parse_jetMembershipFunction(ps);
   checkConfig(jetMembershipFunction, "invalid jet membership function");
 
   bgMembershipFunction = parse_bgMembershipFunction(ps);
   checkConfig(bgMembershipFunction, "invalid noise membership function");
 
   // Build the energy recombination algorithm
   if (!useGriddedAlgorithm) {
     fftjet::DefaultVectorRecombinationAlgFactory<VectorLike, BgData, VBuilder> factory;
     if (factory[recombinationAlgorithm] == nullptr)
       throw cms::Exception("FFTJetBadConfig")
           << "Invalid vector recombination algorithm \"" << recombinationAlgorithm << "\"" << std::endl;
     recoAlg = std::unique_ptr<RecoAlg>(factory[recombinationAlgorithm]->create(jetMembershipFunction.get(),
                                                                                &VectorLike::Et,
                                                                                &VectorLike::Eta,
                                                                                &VectorLike::Phi,
                                                                                bgMembershipFunction.get(),
                                                                                unlikelyBgWeight,
                                                                                isCrisp,
                                                                                false,
                                                                                assignConstituents));
   } else if (!reuseExistingGrid) {
     energyFlow = fftjet_Grid2d_parser(ps.getParameter<edm::ParameterSet>("GridConfiguration"));
     checkConfig(energyFlow, "invalid discretization grid");
     buildGridAlg();
   }
 
   // Create the grid subsequently used for pile-up subtraction
   if (calculatePileup) {
     pileupEnergyFlow = fftjet_Grid2d_parser(ps.getParameter<edm::ParameterSet>("PileupGridConfiguration"));
     checkConfig(pileupEnergyFlow, "invalid pileup density grid");
 
     if (!loadPileupFromDB) {
       pileupDensityCalc = parse_pileupDensityCalc(ps);
       checkConfig(pileupDensityCalc, "invalid pile-up density calculator");
     }
   }
 
   // Parse the calculator of the recombination scale
   recoScaleCalcPeak = parse_recoScaleCalcPeak(ps);
   checkConfig(recoScaleCalcPeak,
               "invalid spec for the "
               "reconstruction scale calculator from peaks");
 
   // Parse the calculator of the recombination scale ratio
   recoScaleRatioCalcPeak = parse_recoScaleRatioCalcPeak(ps);
   checkConfig(recoScaleRatioCalcPeak,
               "invalid spec for the "
               "reconstruction scale ratio calculator from peaks");
 
   // Calculator for the membership function factor
   memberFactorCalcPeak = parse_memberFactorCalcPeak(ps);
   checkConfig(memberFactorCalcPeak,
               "invalid spec for the "
               "membership function factor calculator from peaks");
 
   if (maxIterations > 1) {
     // We are going to run iteratively. Make required objects.
     recoScaleCalcJet = parse_recoScaleCalcJet(ps);
     checkConfig(recoScaleCalcJet,
                 "invalid spec for the "
                 "reconstruction scale calculator from jets");
 
     recoScaleRatioCalcJet = parse_recoScaleRatioCalcJet(ps);
     checkConfig(recoScaleRatioCalcJet,
                 "invalid spec for the "
                 "reconstruction scale ratio calculator from jets");
 
     memberFactorCalcJet = parse_memberFactorCalcJet(ps);
     checkConfig(memberFactorCalcJet,
                 "invalid spec for the "
                 "membership function factor calculator from jets");
 
     jetDistanceCalc = parse_jetDistanceCalc(ps);
     checkConfig(memberFactorCalcJet,
                 "invalid spec for the "
                 "jet distance calculator");
   }
 }

◆ buildGridAlg()

void FFTJetProducer::buildGridAlg ( )

private

Definition at line 357 of file FFTJetProducer.cc.

References assignConstituents, bgMembershipFunction, fftjetcms::FFTJetInterface::energyFlow, Exception, gridAlg, gridScanMaxEta, isCrisp, jetMembershipFunction, cms::cuda::allocator::maxBin, cms::cuda::allocator::minBin, recombinationAlgorithm, recombinationDataCutoff, and unlikelyBgWeight.

Referenced by beginStream(), and produce().

                                   {
   int minBin = energyFlow->getEtaBin(-gridScanMaxEta);
   if (minBin < 0)
     minBin = 0;
   int maxBin = energyFlow->getEtaBin(gridScanMaxEta) + 1;
   if (maxBin < 0)
     maxBin = 0;
 
   fftjet::DefaultRecombinationAlgFactory<Real, VectorLike, BgData, VBuilder> factory;
   if (factory[recombinationAlgorithm] == nullptr)
     throw cms::Exception("FFTJetBadConfig")
         << "Invalid grid recombination algorithm \"" << recombinationAlgorithm << "\"" << std::endl;
   gridAlg = std::unique_ptr<GridAlg>(factory[recombinationAlgorithm]->create(jetMembershipFunction.get(),
                                                                              bgMembershipFunction.get(),
                                                                              unlikelyBgWeight,
                                                                              recombinationDataCutoff,
                                                                              isCrisp,
                                                                              false,
                                                                              assignConstituents,
                                                                              minBin,
                                                                              maxBin));
 }

◆ checkConvergence()

bool FFTJetProducer::checkConvergence	(	const std::vector< RecoFFTJet > &	previousIterResult,
		std::vector< RecoFFTJet > &	thisIterResult
	)

private

Definition at line 399 of file FFTJetProducer.cc.

References convergenceDistance, ztail::d, mps_fire::i, jetDistanceCalc, GetRecoTauVFromDQM_MC_cff::next, nJets, and callgraph::previous.

Referenced by iterateJetReconstruction().

                                                                                                            {
   fftjet::Functor2<double, RecoFFTJet, RecoFFTJet>& distanceCalc(*jetDistanceCalc);
 
   const unsigned nJets = previous.size();
   if (nJets != nextSet.size())
     return false;
 
   const RecoFFTJet* prev = &previous[0];
   RecoFFTJet* next = &nextSet[0];
 
   // Calculate convergence distances for all jets
   bool converged = true;
   for (unsigned i = 0; i < nJets; ++i) {
     const double d = distanceCalc(prev[i], next[i]);
     next[i].setConvergenceDistance(d);
     if (i < nJetsRequiredToConverge && d > convergenceDistance)
       converged = false;
   }
 
   return converged;
 }

◆ determineGriddedConstituents()

void FFTJetProducer::determineGriddedConstituents ( )

private

Definition at line 488 of file FFTJetProducer.cc.

References cms::cuda::assert(), fftjetcms::FFTJetInterface::candidateIndex, constituents, fftjetcms::FFTJetInterface::energyFlow, fftjetcms::FFTJetInterface::eventData, g, gridAlg, mps_fire::i, l1tPhase2CaloJetEmulator_cfi::iEta, fftjetcms::FFTJetInterface::inputCollection, B2GTnPMonitor_cfi::item, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, HLT_2024v13_cff::nEta, nJets, HLT_2024v13_cff::nPhi, and recoJets.

Referenced by produce().

                                                   {
   const unsigned nJets = recoJets.size();
   const unsigned* clusterMask = gridAlg->getClusterMask();
   const int nEta = gridAlg->getLastNEta();
   const int nPhi = gridAlg->getLastNPhi();
   const fftjet::Grid2d<Real>& g(*energyFlow);
 
   const unsigned nInputs = eventData.size();
   const VectorLike* inp = nInputs ? &eventData[0] : nullptr;
   const unsigned* candIdx = nInputs ? &candidateIndex[0] : nullptr;
   for (unsigned i = 0; i < nInputs; ++i) {
     const VectorLike& item(inp[i]);
     const int iPhi = g.getPhiBin(item.Phi());
     const int iEta = g.getEtaBin(item.Eta());
     const unsigned mask = iEta >= 0 && iEta < nEta ? clusterMask[iEta * nPhi + iPhi] : 0;
     assert(mask <= nJets);
     constituents[mask].push_back(inputCollection->ptrAt(candIdx[i]));
   }
 }

◆ determinePileup()

void FFTJetProducer::determinePileup ( )

private

Definition at line 1005 of file FFTJetProducer.cc.

References cms::cuda::assert(), cellCountsVec, HLT_2024v13_cff::dEta, doubleBuf, HLT_2024v13_cff::dPhi, PVValHelper::eta, f, g, mps_fire::i, hcalRecHitTable_cff::ieta, hcalRecHitTable_cff::iphi, isCrisp, metsig::jet, jetMembershipFunction, reco::btau::jetPhi, M_PI, memberFactorCalcJet, memFcns2dVec, HLT_2024v13_cff::nEta, nJets, HLT_2024v13_cff::nPhi, pileup, pileupEnergyFlow, recoJets, recoScaleCalcJet, recoScaleRatioCalcJet, mitigatedMETSequence_cff::U, and SiPixelPI::zero.

Referenced by produce().

                                      {
   // This function works with crisp clustering only
   if (!isCrisp)
     assert(!"Pile-up subtraction for fuzzy clustering "
                "is not implemented yet");
 
   // Clear the pileup vector
   const unsigned nJets = recoJets.size();
   pileup.resize(nJets);
   if (nJets == 0)
     return;
   const VectorLike zero;
   for (unsigned i = 0; i < nJets; ++i)
     pileup[i] = zero;
 
   // Pileup energy flow grid
   const fftjet::Grid2d<Real>& g(*pileupEnergyFlow);
   const unsigned nEta = g.nEta();
   const unsigned nPhi = g.nPhi();
   const double cellArea = g.etaBinWidth() * g.phiBinWidth();
 
   // Various calculators
   fftjet::Functor1<double, RecoFFTJet>& scaleCalc(*recoScaleCalcJet);
   fftjet::Functor1<double, RecoFFTJet>& ratioCalc(*recoScaleRatioCalcJet);
   fftjet::Functor1<double, RecoFFTJet>& factorCalc(*memberFactorCalcJet);
 
   // Make sure we have enough memory
   memFcns2dVec.resize(nJets);
   fftjet::AbsKernel2d** memFcns2d = &memFcns2dVec[0];
 
   doubleBuf.resize(nJets * 4U + nJets * nPhi);
   double* recoScales = &doubleBuf[0];
   double* recoScaleRatios = recoScales + nJets;
   double* memFactors = recoScaleRatios + nJets;
   double* dEta = memFactors + nJets;
   double* dPhiBuf = dEta + nJets;
 
   cellCountsVec.resize(nJets);
   unsigned* cellCounts = &cellCountsVec[0];
 
   // Go over jets and collect the necessary info
   for (unsigned ijet = 0; ijet < nJets; ++ijet) {
     const RecoFFTJet& jet(recoJets[ijet]);
     const fftjet::Peak& peak(jet.precluster());
 
     // Make sure we are using 2-d membership functions.
     // Pile-up subtraction scheme for 3-d functions should be different.
     fftjet::AbsMembershipFunction* m3d = dynamic_cast<fftjet::AbsMembershipFunction*>(peak.membershipFunction());
     if (m3d == nullptr)
       m3d = dynamic_cast<fftjet::AbsMembershipFunction*>(jetMembershipFunction.get());
     if (m3d) {
       assert(!"Pile-up subtraction for 3-d membership functions "
                    "is not implemented yet");
     } else {
       fftjet::AbsKernel2d* m2d = dynamic_cast<fftjet::AbsKernel2d*>(peak.membershipFunction());
       if (m2d == nullptr)
         m2d = dynamic_cast<fftjet::AbsKernel2d*>(jetMembershipFunction.get());
       assert(m2d);
       memFcns2d[ijet] = m2d;
     }
     recoScales[ijet] = scaleCalc(jet);
     recoScaleRatios[ijet] = ratioCalc(jet);
     memFactors[ijet] = factorCalc(jet);
     cellCounts[ijet] = 0U;
 
     const double jetPhi = jet.vec().Phi();
     for (unsigned iphi = 0; iphi < nPhi; ++iphi) {
       double dphi = g.phiBinCenter(iphi) - jetPhi;
       while (dphi > M_PI)
         dphi -= (2.0 * M_PI);
       while (dphi < -M_PI)
         dphi += (2.0 * M_PI);
       dPhiBuf[iphi * nJets + ijet] = dphi;
     }
   }
 
   // Go over all grid points and integrate
   // the pile-up energy density
   VBuilder vMaker;
   for (unsigned ieta = 0; ieta < nEta; ++ieta) {
     const double eta(g.etaBinCenter(ieta));
     const Real* databuf = g.data() + ieta * nPhi;
 
     // Figure out dEta for each jet
     for (unsigned ijet = 0; ijet < nJets; ++ijet)
       dEta[ijet] = eta - recoJets[ijet].vec().Eta();
 
     for (unsigned iphi = 0; iphi < nPhi; ++iphi) {
       double maxW(0.0);
       unsigned maxWJet(nJets);
       const double* dPhi = dPhiBuf + iphi * nJets;
 
       for (unsigned ijet = 0; ijet < nJets; ++ijet) {
         if (recoScaleRatios[ijet] > 0.0)
           memFcns2d[ijet]->setScaleRatio(recoScaleRatios[ijet]);
         const double f = memFactors[ijet] * (*memFcns2d[ijet])(dEta[ijet], dPhi[ijet], recoScales[ijet]);
         if (f > maxW) {
           maxW = f;
           maxWJet = ijet;
         }
       }
 
       if (maxWJet < nJets) {
         pileup[maxWJet] += vMaker(cellArea * databuf[iphi], eta, g.phiBinCenter(iphi));
         cellCounts[maxWJet]++;
       }
     }
   }
 }

◆ determinePileupDensityFromConfig()

void FFTJetProducer::determinePileupDensityFromConfig	(	const edm::Event &	iEvent,
		std::unique_ptr< fftjet::Grid2d< fftjetcms::Real > > &	density
	)

privatevirtual

Definition at line 937 of file FFTJetProducer.cc.

References fastSimProducer_cff::density, PVValHelper::eta, g, hcalRecHitTable_cff::ieta, iEvent, input_pusummary_token_, hcalRecHitTable_cff::iphi, fftjetcms::AbsPileupCalculator::isPhiDependent(), HLT_2024v13_cff::nEta, HLT_2024v13_cff::nPhi, phi, pileupDensityCalc, alignCSCRings::s, and edmLumisInFiles::summary.

Referenced by produce().

                                                                                                             {
   edm::Handle<reco::FFTJetPileupSummary> summary;
   iEvent.getByToken(input_pusummary_token_, summary);
 
   const reco::FFTJetPileupSummary& s(*summary);
   const AbsPileupCalculator& calc(*pileupDensityCalc);
   const bool phiDependent = calc.isPhiDependent();
 
   fftjet::Grid2d<Real>& g(*density);
   const unsigned nEta = g.nEta();
   const unsigned nPhi = g.nPhi();
 
   for (unsigned ieta = 0; ieta < nEta; ++ieta) {
     const double eta(g.etaBinCenter(ieta));
 
     if (phiDependent) {
       for (unsigned iphi = 0; iphi < nPhi; ++iphi) {
         const double phi(g.phiBinCenter(iphi));
         g.uncheckedSetBin(ieta, iphi, calc(eta, phi, s));
       }
     } else {
       const double pil = calc(eta, 0.0, s);
       for (unsigned iphi = 0; iphi < nPhi; ++iphi)
         g.uncheckedSetBin(ieta, iphi, pil);
     }
   }
 }

◆ determinePileupDensityFromDB()

void FFTJetProducer::determinePileupDensityFromDB	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		std::unique_ptr< fftjet::Grid2d< fftjetcms::Real > > &	density
	)

privatevirtual

Definition at line 966 of file FFTJetProducer.cc.

References fastSimProducer_cff::density, esLoader_, PVValHelper::eta, f, g, h, hcalRecHitTable_cff::ieta, iEvent, input_pusummary_token_, hcalRecHitTable_cff::iphi, DefaultFFTJetRcdMapper< DataType >::load(), HLT_2024v13_cff::nEta, HLT_2024v13_cff::nPhi, pileupTableCategory, pileupTableName, pileupTableRecord, rho, edmLumisInFiles::summary, and mitigatedMETSequence_cff::U.

Referenced by produce().

                                                                                                         {
   edm::ESHandle<FFTJetLookupTableSequence> h = esLoader_.load(pileupTableRecord, iSetup);
   std::shared_ptr<npstat::StorableMultivariateFunctor> f = (*h)[pileupTableCategory][pileupTableName];
 
   edm::Handle<reco::FFTJetPileupSummary> summary;
   iEvent.getByToken(input_pusummary_token_, summary);
 
   const float rho = summary->pileupRho();
   const bool phiDependent = f->minDim() == 3U;
 
   fftjet::Grid2d<Real>& g(*density);
   const unsigned nEta = g.nEta();
   const unsigned nPhi = g.nPhi();
 
   double functorArg[3] = {0.0, 0.0, 0.0};
   if (phiDependent)
     functorArg[2] = rho;
   else
     functorArg[1] = rho;
 
   for (unsigned ieta = 0; ieta < nEta; ++ieta) {
     const double eta(g.etaBinCenter(ieta));
     functorArg[0] = eta;
 
     if (phiDependent) {
       for (unsigned iphi = 0; iphi < nPhi; ++iphi) {
         functorArg[1] = g.phiBinCenter(iphi);
         g.uncheckedSetBin(ieta, iphi, (*f)(functorArg, 3U));
       }
     } else {
       const double pil = (*f)(functorArg, 2U);
       for (unsigned iphi = 0; iphi < nPhi; ++iphi)
         g.uncheckedSetBin(ieta, iphi, pil);
     }
   }
 }

◆ determineVectorConstituents()

void FFTJetProducer::determineVectorConstituents ( )

private

Definition at line 508 of file FFTJetProducer.cc.

References cms::cuda::assert(), fftjetcms::FFTJetInterface::candidateIndex, constituents, fftjetcms::FFTJetInterface::eventData, mps_fire::i, fftjetcms::FFTJetInterface::inputCollection, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, nJets, recoAlg, and recoJets.

Referenced by produce().

                                                  {
   const unsigned nJets = recoJets.size();
   const unsigned* clusterMask = recoAlg->getClusterMask();
   const unsigned maskLength = recoAlg->getLastNData();
   assert(maskLength == eventData.size());
 
   const unsigned* candIdx = maskLength ? &candidateIndex[0] : nullptr;
   for (unsigned i = 0; i < maskLength; ++i) {
     // In FFTJet, the mask value of 0 corresponds to unclustered
     // energy. We will do the same here. Jet numbers are therefore
     // shifted by 1 wrt constituents vector, and constituents[1]
     // corresponds to jet number 0.
     const unsigned mask = clusterMask[i];
     assert(mask <= nJets);
     constituents[mask].push_back(inputCollection->ptrAt(candIdx[i]));
   }
 }

◆ genJetPreclusters()

void FFTJetProducer::genJetPreclusters	(	const SparseTree &	tree,
		edm::Event &	iEvent,
		const edm::EventSetup &	,
		const fftjet::Functor1< bool, fftjet::Peak > &	peakSelector,
		std::vector< fftjet::Peak > *	preclusters
	)

protectedvirtual

Definition at line 214 of file FFTJetProducer.cc.

References mps_fire::i, iEvent, input, input_genjet_token_, SimL1EmulatorRepack_Full_cff::InputCollection, metsig::jet, fftjetcms::jetFromStorable(), AlCaHLTBitMon_ParallelJobs::p, preclusters, resolution, and l1tEGammaCrystalsEmulatorProducer_cfi::scale.

Referenced by produce().

                                                                            {
   typedef reco::FFTAnyJet<reco::GenJet> InputJet;
   typedef std::vector<InputJet> InputCollection;
 
   edm::Handle<InputCollection> input;
   iEvent.getByToken(input_genjet_token_, input);
 
   const unsigned sz = input->size();
   preclusters->reserve(sz);
   for (unsigned i = 0; i < sz; ++i) {
     const RecoFFTJet& jet(jetFromStorable((*input)[i].getFFTSpecific()));
     fftjet::Peak p(jet.precluster());
     const double scale(p.scale());
     p.setEtaPhi(jet.vec().Eta(), jet.vec().Phi());
     p.setMagnitude(jet.vec().Pt() / scale / scale);
     p.setStatus(resolution);
     if (peakSelect(p))
       preclusters->push_back(p);
   }
 }

◆ iterateJetReconstruction()

unsigned FFTJetProducer::iterateJetReconstruction ( )

private

Definition at line 421 of file FFTJetProducer.cc.

References cms::cuda::assert(), checkConvergence(), fftjetcms::FFTJetInterface::energyFlow, fftjetcms::FFTJetInterface::eventData, Exception, gridAlg, mps_fire::i, iterJets, iterPreclusters, metsig::jet, PDWG_EXODelayedJetMET_cff::jets, maxIterations, memberFactorCalcJet, nJets, noiseLevel, AlCaHLTBitMon_ParallelJobs::p, preclusters, recoAlg, recoJets, recoScaleCalcJet, recoScaleRatioCalcJet, removeFakePreclusters(), mps_update::status, mitigatedMETSequence_cff::U, unclustered, unused, and useGriddedAlgorithm.

Referenced by produce().

                                                   {
   fftjet::Functor1<double, RecoFFTJet>& scaleCalc(*recoScaleCalcJet);
   fftjet::Functor1<double, RecoFFTJet>& ratioCalc(*recoScaleRatioCalcJet);
   fftjet::Functor1<double, RecoFFTJet>& factorCalc(*memberFactorCalcJet);
 
   unsigned nJets = recoJets.size();
   unsigned iterNum = 1U;
   bool converged = false;
   for (; iterNum < maxIterations && !converged; ++iterNum) {
     // Recreate the vector of preclusters using the jets
     const RecoFFTJet* jets = &recoJets[0];
     iterPreclusters.clear();
     iterPreclusters.reserve(nJets);
     for (unsigned i = 0; i < nJets; ++i) {
       const RecoFFTJet& jet(jets[i]);
       fftjet::Peak p(jet.precluster());
       p.setEtaPhi(jet.vec().Eta(), jet.vec().Phi());
       p.setRecoScale(scaleCalc(jet));
       p.setRecoScaleRatio(ratioCalc(jet));
       p.setMembershipFactor(factorCalc(jet));
       iterPreclusters.push_back(p);
     }
 
     // Run the algorithm
     int status = 0;
     if (useGriddedAlgorithm)
       status = gridAlg->run(iterPreclusters, *energyFlow, &noiseLevel, 1U, 1U, &iterJets, &unclustered, &unused);
     else
       status = recoAlg->run(iterPreclusters, eventData, &noiseLevel, 1U, &iterJets, &unclustered, &unused);
     if (status)
       throw cms::Exception("FFTJetInterface") << "FFTJet algorithm failed" << std::endl;
 
     // As it turns out, it is possible, in very rare cases,
     // to have iterJets.size() != nJets at this point
 
     // Figure out if the iterations have converged
     converged = checkConvergence(recoJets, iterJets);
 
     // Prepare for the next cycle
     iterJets.swap(recoJets);
     nJets = recoJets.size();
   }
 
   // Check that we have the correct number of preclusters
   if (preclusters.size() != nJets) {
     assert(nJets < preclusters.size());
     removeFakePreclusters();
     assert(preclusters.size() == nJets);
   }
 
   // Plug in the original precluster coordinates into the result
   RecoFFTJet* jets = &recoJets[0];
   for (unsigned i = 0; i < nJets; ++i) {
     const fftjet::Peak& oldp(preclusters[i]);
     jets[i].setPeakEtaPhi(oldp.eta(), oldp.phi());
   }
 
   // If we have converged on the last cycle, the result
   // would be indistinguishable from no convergence.
   // Because of this, raise the counter by one to indicate
   // the case when the convergence is not achieved.
   if (!converged)
     ++iterNum;
 
   return iterNum;
 }

◆ loadEnergyFlow()

bool FFTJetProducer::loadEnergyFlow	(	const edm::Event &	iEvent,
		std::unique_ptr< fftjet::Grid2d< fftjetcms::Real > > &	flow
	)

private

Definition at line 380 of file FFTJetProducer.cc.

References fftjetcommon_cfi::flow, iEvent, input, and input_energyflow_token_.

Referenced by produce().

                                                                                                              {
   edm::Handle<reco::DiscretizedEnergyFlow> input;
   iEvent.getByToken(input_energyflow_token_, input);
 
   // Make sure that the grid is compatible with the stored one
   bool rebuildGrid = flow.get() == nullptr;
   if (!rebuildGrid)
     rebuildGrid =
         !(flow->nEta() == input->nEtaBins() && flow->nPhi() == input->nPhiBins() && flow->etaMin() == input->etaMin() &&
           flow->etaMax() == input->etaMax() && flow->phiBin0Edge() == input->phiBin0Edge());
   if (rebuildGrid) {
     // We should not get here very often...
     flow = std::make_unique<fftjet::Grid2d<Real> >(
         input->nEtaBins(), input->etaMin(), input->etaMax(), input->nPhiBins(), input->phiBin0Edge(), input->title());
   }
   flow->blockSet(input->data(), input->nEtaBins(), input->nPhiBins());
   return rebuildGrid;
 }

◆ loadSparseTreeData() [1/2]

template<class Real >

void FFTJetProducer::loadSparseTreeData	(	const edm::Event &	,
		const edm::EDGetTokenT< reco::PattRecoTree< Real, reco::PattRecoPeak< Real > > > &	tok
	)

private

◆ loadSparseTreeData() [2/2]

template<class Real >

void FFTJetProducer::loadSparseTreeData	(	const edm::Event &	iEvent,
		const edm::EDGetTokenT< reco::PattRecoTree< Real, reco::PattRecoPeak< Real > > > &	tok
	)

Definition at line 198 of file FFTJetProducer.cc.

References fftjetcms::FFTJetInterface::getEventScale(), iEvent, iniScales, input, fftjetcms::sparsePeakTreeFromStorable(), and sparseTree.

                                                                                                          {
   typedef reco::PattRecoTree<Real, reco::PattRecoPeak<Real> > StoredTree;
 
   // Get the input
   edm::Handle<StoredTree> input;
   iEvent.getByToken(tok, input);
 
   if (!input->isSparse())
     throw cms::Exception("FFTJetBadConfig") << "The stored clustering tree is not sparse" << std::endl;
 
   sparsePeakTreeFromStorable(*input, iniScales.get(), getEventScale(), &sparseTree);
   sparseTree.sortNodes();
   fftjet::updateSplitMergeTimes(sparseTree, sparseTree.minScale(), sparseTree.maxScale());
 }

◆ makeProduces()

template<typename T >

void FFTJetProducer::makeProduces	(	const std::string &	alias,
		const std::string &	tag
	)

private

Definition at line 109 of file FFTJetProducer.cc.

References SiStripOfflineCRack_cfg::alias, and makeGlobalPositionRcd_cfg::tag.

Referenced by FFTJetProducer().

                                                                               {
   produces<std::vector<reco::FFTAnyJet<T> > >(tag).setBranchAlias(alias);
 }

◆ operator=()

FFTJetProducer& FFTJetProducer::operator= ( const FFTJetProducer & )

delete

◆ parse_bgMembershipFunction()

std::unique_ptr< AbsBgFunctor > FFTJetProducer::parse_bgMembershipFunction ( const edm::ParameterSet & ps )

protectedvirtual

Definition at line 768 of file FFTJetProducer.cc.

References fftjetcms::fftjet_BgFunctor_parser(), and edm::ParameterSet::getParameter().

Referenced by beginStream().

                                                                                                 {
   return fftjet_BgFunctor_parser(ps.getParameter<edm::ParameterSet>("bgMembershipFunction"));
 }

◆ parse_jetDistanceCalc()

std::unique_ptr< fftjet::Functor2< double, FFTJetProducer::RecoFFTJet, FFTJetProducer::RecoFFTJet > > FFTJetProducer::parse_jetDistanceCalc ( const edm::ParameterSet & ps )

protectedvirtual

Definition at line 811 of file FFTJetProducer.cc.

References fftjetcms::fftjet_JetDistance_parser(), and edm::ParameterSet::getParameter().

Referenced by beginStream().

                                                                {
   return fftjet_JetDistance_parser(ps.getParameter<edm::ParameterSet>("jetDistanceCalc"));
 }

◆ parse_jetMembershipFunction()

std::unique_ptr< fftjet::ScaleSpaceKernel > FFTJetProducer::parse_jetMembershipFunction ( const edm::ParameterSet & ps )

protectedvirtual

Definition at line 763 of file FFTJetProducer.cc.

References fftjetcms::fftjet_MembershipFunction_parser(), and edm::ParameterSet::getParameter().

Referenced by beginStream().

                                                                                                            {
   return fftjet_MembershipFunction_parser(ps.getParameter<edm::ParameterSet>("jetMembershipFunction"));
 }

◆ parse_memberFactorCalcJet()

std::unique_ptr< fftjet::Functor1< double, FFTJetProducer::RecoFFTJet > > FFTJetProducer::parse_memberFactorCalcJet ( const edm::ParameterSet & ps )

protectedvirtual

Definition at line 805 of file FFTJetProducer.cc.

References fftjetcms::fftjet_JetFunctor_parser(), and edm::ParameterSet::getParameter().

Referenced by beginStream().

                                {
   return fftjet_JetFunctor_parser(ps.getParameter<edm::ParameterSet>("memberFactorCalcJet"));
 }

◆ parse_memberFactorCalcPeak()

std::unique_ptr< fftjet::Functor1< double, fftjet::Peak > > FFTJetProducer::parse_memberFactorCalcPeak ( const edm::ParameterSet & ps )

protectedvirtual

Definition at line 790 of file FFTJetProducer.cc.

References fftjetcms::fftjet_PeakFunctor_parser(), and edm::ParameterSet::getParameter().

Referenced by beginStream().

                                {
   return fftjet_PeakFunctor_parser(ps.getParameter<edm::ParameterSet>("memberFactorCalcPeak"));
 }

◆ parse_peakSelector()

std::unique_ptr< fftjet::Functor1< bool, fftjet::Peak > > FFTJetProducer::parse_peakSelector ( const edm::ParameterSet & ps )

protectedvirtual

Definition at line 758 of file FFTJetProducer.cc.

References fftjetcms::fftjet_PeakSelector_parser(), and edm::ParameterSet::getParameter().

Referenced by beginStream().

                                                                                                              {
   return fftjet_PeakSelector_parser(ps.getParameter<edm::ParameterSet>("PeakSelectorConfiguration"));
 }

◆ parse_pileupDensityCalc()

std::unique_ptr< fftjetcms::AbsPileupCalculator > FFTJetProducer::parse_pileupDensityCalc ( const edm::ParameterSet & ps )

protectedvirtual

Definition at line 779 of file FFTJetProducer.cc.

References fftjetcms::fftjet_PileupCalculator_parser(), and edm::ParameterSet::getParameter().

Referenced by beginStream().

                                                                                                              {
   return fftjet_PileupCalculator_parser(ps.getParameter<edm::ParameterSet>("pileupDensityCalc"));
 }

◆ parse_recoScaleCalcJet()

std::unique_ptr< fftjet::Functor1< double, FFTJetProducer::RecoFFTJet > > FFTJetProducer::parse_recoScaleCalcJet ( const edm::ParameterSet & ps )

protectedvirtual

Definition at line 795 of file FFTJetProducer.cc.

References fftjetcms::fftjet_JetFunctor_parser(), and edm::ParameterSet::getParameter().

Referenced by beginStream().

                                {
   return fftjet_JetFunctor_parser(ps.getParameter<edm::ParameterSet>("recoScaleCalcJet"));
 }

◆ parse_recoScaleCalcPeak()

std::unique_ptr< fftjet::Functor1< double, fftjet::Peak > > FFTJetProducer::parse_recoScaleCalcPeak ( const edm::ParameterSet & ps )

protectedvirtual

Definition at line 773 of file FFTJetProducer.cc.

References fftjetcms::fftjet_PeakFunctor_parser(), and edm::ParameterSet::getParameter().

Referenced by beginStream().

                                {
   return fftjet_PeakFunctor_parser(ps.getParameter<edm::ParameterSet>("recoScaleCalcPeak"));
 }

◆ parse_recoScaleRatioCalcJet()

std::unique_ptr< fftjet::Functor1< double, FFTJetProducer::RecoFFTJet > > FFTJetProducer::parse_recoScaleRatioCalcJet ( const edm::ParameterSet & ps )

protectedvirtual

Definition at line 800 of file FFTJetProducer.cc.

References fftjetcms::fftjet_JetFunctor_parser(), and edm::ParameterSet::getParameter().

Referenced by beginStream().

                                {
   return fftjet_JetFunctor_parser(ps.getParameter<edm::ParameterSet>("recoScaleRatioCalcJet"));
 }

◆ parse_recoScaleRatioCalcPeak()

std::unique_ptr< fftjet::Functor1< double, fftjet::Peak > > FFTJetProducer::parse_recoScaleRatioCalcPeak ( const edm::ParameterSet & ps )

protectedvirtual

Definition at line 784 of file FFTJetProducer.cc.

References fftjetcms::fftjet_PeakFunctor_parser(), and edm::ParameterSet::getParameter().

Referenced by beginStream().

                                {
   return fftjet_PeakFunctor_parser(ps.getParameter<edm::ParameterSet>("recoScaleRatioCalcPeak"));
 }

◆ parse_resolution()

FFTJetProducer::Resolution FFTJetProducer::parse_resolution ( const std::string & name )

static

Definition at line 93 of file FFTJetProducer.cc.

References Exception, and Skims_PA_cff::name.

                                                                                {
   if (!name.compare("fixed"))
     return FIXED;
   else if (!name.compare("maximallyStable"))
     return MAXIMALLY_STABLE;
   else if (!name.compare("globallyAdaptive"))
     return GLOBALLY_ADAPTIVE;
   else if (!name.compare("locallyAdaptive"))
     return LOCALLY_ADAPTIVE;
   else if (!name.compare("fromGenJets"))
     return FROM_GENJETS;
   else
     throw cms::Exception("FFTJetBadConfig") << "Invalid resolution specification \"" << name << "\"" << std::endl;
 }

◆ prepareRecombinationScales()

void FFTJetProducer::prepareRecombinationScales ( )

private

Definition at line 341 of file FFTJetProducer.cc.

References mps_fire::i, memberFactorCalcPeak, preclusters, recoScaleCalcPeak, and recoScaleRatioCalcPeak.

Referenced by produce().

                                                 {
   const unsigned nClus = preclusters.size();
   if (nClus) {
     fftjet::Peak* clus = &preclusters[0];
     fftjet::Functor1<double, fftjet::Peak>& scaleCalc(*recoScaleCalcPeak);
     fftjet::Functor1<double, fftjet::Peak>& ratioCalc(*recoScaleRatioCalcPeak);
     fftjet::Functor1<double, fftjet::Peak>& factorCalc(*memberFactorCalcPeak);
 
     for (unsigned i = 0; i < nClus; ++i) {
       clus[i].setRecoScale(scaleCalc(clus[i]));
       clus[i].setRecoScaleRatio(ratioCalc(clus[i]));
       clus[i].setMembershipFactor(factorCalc(clus[i]));
     }
   }
 }

◆ produce()

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

overrideprotected

Definition at line 656 of file FFTJetProducer.cc.

References cms::cuda::assert(), assignConstituents, assignMembershipFunctions(), buildGridAlg(), calculatePileup, l1ct::clear(), constituents, determineGriddedConstituents(), determinePileup(), determinePileupDensityFromConfig(), determinePileupDensityFromDB(), determineVectorConstituents(), fftjetcms::FFTJetInterface::discretizeEnergyFlow(), fftjetcms::FFTJetInterface::energyFlow, fftjetcms::FFTJetInterface::eventData, Exception, FROM_GENJETS, genJetPreclusters(), gridAlg, mps_fire::i, iEvent, input_recotree_token_d_, input_recotree_token_f_, iterateJetReconstruction(), iterationsPerformed, loadEnergyFlow(), fftjetcms::FFTJetInterface::loadInputCollection(), loadPileupFromDB, maxInitialPreclusters, maxIterations, nJets, noiseLevel, occupancy, peakSelector, pileup, pileupEnergyFlow, preclusters, prepareRecombinationScales(), recoAlg, recoJets, removeFakePreclusters(), resolution, reuseExistingGrid, saveResults(), selectPreclusters(), jetUpdater_cfi::sort, sparseTree, mps_update::status, fftjetcms::FFTJetInterface::storeInSinglePrecision(), mitigatedMETSequence_cff::U, unclustered, unused, and useGriddedAlgorithm.

                                                                           {
   // Load the clustering tree made by FFTJetPatRecoProducer
   if (storeInSinglePrecision())
     loadSparseTreeData<float>(iEvent, input_recotree_token_f_);
   else
     loadSparseTreeData<double>(iEvent, input_recotree_token_d_);
 
   // Do we need to load the candidate collection?
   if (assignConstituents || !(useGriddedAlgorithm && reuseExistingGrid))
     loadInputCollection(iEvent);
 
   // Do we need to have discretized energy flow?
   if (useGriddedAlgorithm) {
     if (reuseExistingGrid) {
       if (loadEnergyFlow(iEvent, energyFlow))
         buildGridAlg();
     } else
       discretizeEnergyFlow();
   }
 
   // Calculate cluster occupancy as a function of level number
   sparseTree.occupancyInScaleSpace(*peakSelector, &occupancy);
 
   // Select the preclusters using the requested resolution scheme
   preclusters.clear();
   if (resolution == FROM_GENJETS)
     genJetPreclusters(sparseTree, iEvent, iSetup, *peakSelector, &preclusters);
   else
     selectPreclusters(sparseTree, *peakSelector, &preclusters);
   if (preclusters.size() > maxInitialPreclusters) {
     std::sort(preclusters.begin(), preclusters.end(), std::greater<fftjet::Peak>());
     preclusters.erase(preclusters.begin() + maxInitialPreclusters, preclusters.end());
   }
 
   // Prepare to run the jet recombination procedure
   prepareRecombinationScales();
 
   // Assign membership functions to preclusters. If this function
   // is not overriden in a derived class, default algorithm membership
   // function will be used for every cluster.
   assignMembershipFunctions(&preclusters);
 
   // Count the preclusters going in
   unsigned nPreclustersFound = 0U;
   const unsigned npre = preclusters.size();
   for (unsigned i = 0; i < npre; ++i)
     if (preclusters[i].membershipFactor() > 0.0)
       ++nPreclustersFound;
 
   // Run the recombination algorithm once
   int status = 0;
   if (useGriddedAlgorithm)
     status = gridAlg->run(preclusters, *energyFlow, &noiseLevel, 1U, 1U, &recoJets, &unclustered, &unused);
   else
     status = recoAlg->run(preclusters, eventData, &noiseLevel, 1U, &recoJets, &unclustered, &unused);
   if (status)
     throw cms::Exception("FFTJetInterface") << "FFTJet algorithm failed (first iteration)" << std::endl;
 
   // If requested, iterate the jet recombination procedure
   if (maxIterations > 1U && !recoJets.empty()) {
     // It is possible to have a smaller number of jets than we had
     // preclusters. Fake preclusters are possible, but for a good
     // choice of pattern recognition kernel their presence should
     // be infrequent. However, any fake preclusters will throw the
     // iterative reconstruction off balance. Deal with the problem now.
     const unsigned nJets = recoJets.size();
     if (preclusters.size() != nJets) {
       assert(nJets < preclusters.size());
       removeFakePreclusters();
     }
     iterationsPerformed = iterateJetReconstruction();
   } else
     iterationsPerformed = 1U;
 
   // Determine jet constituents. FFTJet returns a map
   // of constituents which is inverse to what we need here.
   const unsigned nJets = recoJets.size();
   if (constituents.size() <= nJets)
     constituents.resize(nJets + 1U);
   if (assignConstituents) {
     for (unsigned i = 0; i <= nJets; ++i)
       constituents[i].clear();
     if (useGriddedAlgorithm)
       determineGriddedConstituents();
     else
       determineVectorConstituents();
   }
 
   // Figure out the pile-up
   if (calculatePileup) {
     if (loadPileupFromDB)
       determinePileupDensityFromDB(iEvent, iSetup, pileupEnergyFlow);
     else
       determinePileupDensityFromConfig(iEvent, pileupEnergyFlow);
     determinePileup();
     assert(pileup.size() == recoJets.size());
   }
 
   // Write out the results
   saveResults(iEvent, iSetup, nPreclustersFound);
 }

◆ removeFakePreclusters()

void FFTJetProducer::removeFakePreclusters ( )

private

Definition at line 905 of file FFTJetProducer.cc.

References cms::cuda::assert(), mps_fire::i, iterPreclusters, fftjetcms::matchOneToOne(), preclusters, and recoJets.

Referenced by iterateJetReconstruction(), and produce().

                                            {
   // There are two possible reasons for fake preclusters:
   // 1. Membership factor was set to 0
   // 2. Genuine problem with pattern recognition
   //
   // Anyway, we need to match jets to preclusters and keep
   // only those preclusters that have been matched
   //
   std::vector<int> matchTable;
   const unsigned nmatched = matchOneToOne(recoJets, preclusters, JetToPeakDistance(), &matchTable);
 
   // Ensure that all jets have been matched.
   // If not, we must have a bug somewhere.
   assert(nmatched == recoJets.size());
 
   // Collect all matched preclusters
   iterPreclusters.clear();
   iterPreclusters.reserve(nmatched);
   for (unsigned i = 0; i < nmatched; ++i)
     iterPreclusters.push_back(preclusters[matchTable[i]]);
   iterPreclusters.swap(preclusters);
 }

◆ saveResults()

void FFTJetProducer::saveResults	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		unsigned	nPreclustersFound
	)

private

Definition at line 620 of file FFTJetProducer.cc.

References constituents, makeMEIFBenchmarkPlots::ev, mps_fire::i, iterationsPerformed, jet_type_switch, maxIterations, maxLevel, fftjetcommon_cfi::maxScale, minLevel, fftjetcommon_cfi::minScale, occupancy, fftjetcms::FFTJetInterface::outputLabel, resumConstituents, sparseTree, thresholds, mitigatedMETSequence_cff::U, unclustered, unused, usedLevel, and writeJets().

Referenced by produce().

                                                                                                             {
   // Write recombined jets
   jet_type_switch(writeJets, ev, iSetup);
 
   // Check if we should resum unclustered energy constituents
   VectorLike unclusE(unclustered);
   if (resumConstituents) {
     VectorLike sum(0.0, 0.0, 0.0, 0.0);
     const unsigned nCon = constituents[0].size();
     const reco::CandidatePtr* cn = nCon ? &constituents[0][0] : nullptr;
     for (unsigned i = 0; i < nCon; ++i)
       sum += cn[i]->p4();
     unclusE = sum;
   }
 
   // Write the jet reconstruction summary
   const double minScale = minLevel ? sparseTree.getScale(minLevel) : 0.0;
   const double maxScale = maxLevel ? sparseTree.getScale(maxLevel) : 0.0;
   const double scaleUsed = usedLevel ? sparseTree.getScale(usedLevel) : 0.0;
 
   ev.put(
       std::make_unique<reco::FFTJetProducerSummary>(thresholds,
                                                     occupancy,
                                                     unclusE,
                                                     constituents[0],
                                                     unused,
                                                     minScale,
                                                     maxScale,
                                                     scaleUsed,
                                                     nPreclustersFound,
                                                     iterationsPerformed,
                                                     iterationsPerformed == 1U || iterationsPerformed <= maxIterations),
       outputLabel);
 }

◆ selectPreclusters()

void FFTJetProducer::selectPreclusters	(	const SparseTree &	tree,
		const fftjet::Functor1< bool, fftjet::Peak > &	peakSelector,
		std::vector< fftjet::Peak > *	preclusters
	)

protectedvirtual

Definition at line 239 of file FFTJetProducer.cc.

References bsc_activity_cfg::clusters, mps_fire::i, nodes, preclusters, resolution, selectTreeNodes(), and sparseTree.

Referenced by produce().

                                                                            {
   nodes.clear();
   selectTreeNodes(tree, peakSelect, &nodes);
 
   // Fill out the vector of preclusters using the tree node ids
   const unsigned nNodes = nodes.size();
   const SparseTree::NodeId* pnodes = nNodes ? &nodes[0] : nullptr;
   preclusters->reserve(nNodes);
   for (unsigned i = 0; i < nNodes; ++i)
     preclusters->push_back(sparseTree.uncheckedNode(pnodes[i]).getCluster());
 
   // Remember the node id in the precluster and set
   // the status word to indicate the resolution scheme used
   fftjet::Peak* clusters = nNodes ? &(*preclusters)[0] : nullptr;
   for (unsigned i = 0; i < nNodes; ++i) {
     clusters[i].setCode(pnodes[i]);
     clusters[i].setStatus(resolution);
   }
 }

◆ selectTreeNodes()

void FFTJetProducer::selectTreeNodes	(	const SparseTree &	tree,
		const fftjet::Functor1< bool, fftjet::Peak > &	peakSelect,
		std::vector< SparseTree::NodeId > *	nodes
	)

protected

Definition at line 261 of file FFTJetProducer.cc.

References cms::cuda::assert(), ztail::d, dumpMFGeometry_cfg::delta, FIXED, fixedScale, GLOBALLY_ADAPTIVE, personalPlayback::level, LOCALLY_ADAPTIVE, MAXIMALLY_STABLE, maxLevel, maxStableScale, minLevel, minStableScale, dqmiodumpmetadata::n, nClustersRequested, occupancy, resolution, stabilityAlpha, TopDecayID::stable, thresholds, and usedLevel.

Referenced by selectPreclusters().

                                                                            {
   minLevel = maxLevel = usedLevel = 0;
 
   // Get the tree nodes which pass the cuts
   // (according to the selected resolution strategy)
   switch (resolution) {
     case FIXED: {
       usedLevel = tree.getLevel(fixedScale);
       tree.getPassingNodes(usedLevel, peakSelect, mynodes);
     } break;
 
     case MAXIMALLY_STABLE: {
       const unsigned minStartingLevel = maxStableScale > 0.0 ? tree.getLevel(maxStableScale) : 0;
       const unsigned maxStartingLevel = minStableScale > 0.0 ? tree.getLevel(minStableScale) : UINT_MAX;
 
       if (tree.stableClusterCount(
               peakSelect, &minLevel, &maxLevel, stabilityAlpha, minStartingLevel, maxStartingLevel)) {
         usedLevel = (minLevel + maxLevel) / 2;
         tree.getPassingNodes(usedLevel, peakSelect, mynodes);
       }
     } break;
 
     case GLOBALLY_ADAPTIVE: {
       const bool stable = tree.clusterCountLevels(nClustersRequested, peakSelect, &minLevel, &maxLevel);
       if (minLevel || maxLevel) {
         usedLevel = (minLevel + maxLevel) / 2;
         if (!stable) {
           const int maxlev = tree.maxStoredLevel();
           bool levelFound = false;
           for (int delta = 0; delta <= maxlev && !levelFound; ++delta)
             for (int ifac = 1; ifac > -2 && !levelFound; ifac -= 2) {
               const int level = usedLevel + ifac * delta;
               if (level > 0 && level <= maxlev)
                 if (occupancy[level] == nClustersRequested) {
                   usedLevel = level;
                   levelFound = true;
                 }
             }
           assert(levelFound);
         }
       } else {
         // Can't find that exact number of preclusters.
         // Try to get the next best thing.
         usedLevel = 1;
         const unsigned occ1 = occupancy[1];
         if (nClustersRequested >= occ1) {
           const unsigned maxlev = tree.maxStoredLevel();
           if (nClustersRequested > occupancy[maxlev])
             usedLevel = maxlev;
           else {
             // It would be nice to use "lower_bound" here,
             // but the occupancy is not necessarily monotonous.
             unsigned bestDelta = nClustersRequested > occ1 ? nClustersRequested - occ1 : occ1 - nClustersRequested;
             for (unsigned level = 2; level <= maxlev; ++level) {
               const unsigned n = occupancy[level];
               const unsigned d = nClustersRequested > n ? nClustersRequested - n : n - nClustersRequested;
               if (d < bestDelta) {
                 bestDelta = d;
                 usedLevel = level;
               }
             }
           }
         }
       }
       tree.getPassingNodes(usedLevel, peakSelect, mynodes);
     } break;
 
     case LOCALLY_ADAPTIVE: {
       usedLevel = tree.getLevel(fixedScale);
       tree.getMagS2OptimalNodes(peakSelect, nClustersRequested, usedLevel, mynodes, &thresholds);
     } break;
 
     default:
       assert(!"ERROR in FFTJetProducer::selectTreeNodes : "
                "should never get here! This is a bug. Please report.");
   }
 }

◆ setJetStatusBit()

void FFTJetProducer::setJetStatusBit	(	RecoFFTJet *	jet,
		int	mask,
		bool	value
	)

staticprivate

Definition at line 928 of file FFTJetProducer.cc.

References metsig::jet, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, and mps_update::status.

Referenced by writeJets().

                                                                                       {
   int status = jet->status();
   if (value)
     status |= mask;
   else
     status &= ~mask;
   jet->setStatus(status);
 }

◆ writeJets()

template<typename T >

void FFTJetProducer::writeJets	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

private

Definition at line 529 of file FFTJetProducer.cc.

References fftjetcms::adjustForPileup(), calculatePileup, cellCountsVec, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), constituents, CONSTITUENTS_RESUMMED, fftjetcms::FFTJetInterface::energyFlow, geometry_token_, edm::EventSetup::getData(), mps_fire::i, iEvent, metsig::jet, PDWG_EXODelayedJetMET_cff::jets, eostools::move(), nJets, HLTTauReferences_cfi::OutputCollection, fftjetcms::FFTJetInterface::outputLabel, pileup, PILEUP_CALCULATED, PILEUP_SUBTRACTED_4VEC, PILEUP_SUBTRACTED_PT, pileupEnergyFlow, DiDispStaMuonMonitor_cfi::pt, recoJets, recombinationDataCutoff, resumConstituents, reco::FFTJet< Real >::setFourVec(), setJetStatusBit(), reco::FFTJet< Real >::setNCells(), reco::FFTJet< Real >::setPileup(), jetUpdater_cfi::sort, subtractPileup, subtractPileupAs4Vec, HLT_2024v13_cff::topology, topology_token_, useGriddedAlgorithm, fftjetcms::FFTJetInterface::vertexUsed(), and reco::writeSpecific().

Referenced by saveResults().

                                                                             {
   using namespace reco;
 
   typedef FFTAnyJet<T> OutputJet;
   typedef std::vector<OutputJet> OutputCollection;
 
   // Area of a single eta-phi cell for jet area calculations.
   // Set it to 0 in case the module configuration does not allow
   // us to calculate jet areas reliably.
   double cellArea = useGriddedAlgorithm && recombinationDataCutoff < 0.0
                         ? energyFlow->etaBinWidth() * energyFlow->phiBinWidth()
                         : 0.0;
 
   if (calculatePileup)
     cellArea = pileupEnergyFlow->etaBinWidth() * pileupEnergyFlow->phiBinWidth();
 
   // allocate output jet collection
   auto jets = std::make_unique<OutputCollection>();
   const unsigned nJets = recoJets.size();
   jets->reserve(nJets);
 
   bool sorted = true;
   double previousPt = DBL_MAX;
   for (unsigned ijet = 0; ijet < nJets; ++ijet) {
     RecoFFTJet& myjet(recoJets[ijet]);
 
     // Check if we should resum jet constituents
     VectorLike jet4vec(myjet.vec());
     if (resumConstituents) {
       VectorLike sum(0.0, 0.0, 0.0, 0.0);
       const unsigned nCon = constituents[ijet + 1].size();
       const reco::CandidatePtr* cn = nCon ? &constituents[ijet + 1][0] : nullptr;
       for (unsigned i = 0; i < nCon; ++i)
         sum += cn[i]->p4();
       jet4vec = sum;
       setJetStatusBit(&myjet, CONSTITUENTS_RESUMMED, true);
     }
 
     // Subtract the pile-up
     if (calculatePileup && subtractPileup) {
       jet4vec = adjustForPileup(jet4vec, pileup[ijet], subtractPileupAs4Vec);
       if (subtractPileupAs4Vec)
         setJetStatusBit(&myjet, PILEUP_SUBTRACTED_4VEC, true);
       else
         setJetStatusBit(&myjet, PILEUP_SUBTRACTED_PT, true);
     }
 
     // Write the specifics to the jet (simultaneously sets 4-vector,
     // vertex, constituents). These are overridden functions that will
     // call the appropriate specific code.
     T jet;
     if constexpr (std::is_same_v<T, reco::CaloJet>) {
       const CaloGeometry& geometry = iSetup.getData(geometry_token_);
       const HcalTopology& topology = iSetup.getData(topology_token_);
       writeSpecific(jet, jet4vec, vertexUsed(), constituents[ijet + 1], geometry, topology);
     } else {
       writeSpecific(jet, jet4vec, vertexUsed(), constituents[ijet + 1]);
     }
 
     // calcuate the jet area
     double ncells = myjet.ncells();
     if (calculatePileup) {
       ncells = cellCountsVec[ijet];
       setJetStatusBit(&myjet, PILEUP_CALCULATED, true);
     }
     jet.setJetArea(cellArea * ncells);
 
     // add jet to the list
     FFTJet<float> fj(jetToStorable<float>(myjet));
     fj.setFourVec(jet4vec);
     if (calculatePileup) {
       fj.setPileup(pileup[ijet]);
       fj.setNCells(ncells);
     }
     jets->push_back(OutputJet(jet, fj));
 
     // Check whether the sequence remains sorted by pt
     const double pt = jet.pt();
     if (pt > previousPt)
       sorted = false;
     previousPt = pt;
   }
 
   // Sort the collection
   if (!sorted)
     std::sort(jets->begin(), jets->end(), LocalSortByPt());
 
   // put the collection into the event
   iEvent.put(std::move(jets), outputLabel);
 }

Member Data Documentation

◆ assignConstituents

const bool FFTJetProducer::assignConstituents

private

Definition at line 260 of file FFTJetProducer.h.

Referenced by beginStream(), buildGridAlg(), FFTJetProducer(), and produce().

◆ bgMembershipFunction

std::unique_ptr<fftjetcms::AbsBgFunctor> FFTJetProducer::bgMembershipFunction

private

Definition at line 336 of file FFTJetProducer.h.

Referenced by beginStream(), and buildGridAlg().

◆ calculatePileup

const bool FFTJetProducer::calculatePileup

private

Definition at line 269 of file FFTJetProducer.h.

Referenced by beginStream(), produce(), and writeJets().

◆ cellCountsVec

std::vector<unsigned> FFTJetProducer::cellCountsVec

private

Definition at line 401 of file FFTJetProducer.h.

Referenced by determinePileup(), and writeJets().

◆ constituents

std::vector<std::vector<reco::CandidatePtr> > FFTJetProducer::constituents

private

Definition at line 384 of file FFTJetProducer.h.

Referenced by determineGriddedConstituents(), determineVectorConstituents(), produce(), saveResults(), and writeJets().

◆ convergenceDistance

const double FFTJetProducer::convergenceDistance

private

Definition at line 257 of file FFTJetProducer.h.

Referenced by checkConvergence().

◆ doubleBuf

std::vector<double> FFTJetProducer::doubleBuf

private

Definition at line 400 of file FFTJetProducer.h.

Referenced by determinePileup().

◆ esLoader_

FFTJetLookupTableSequenceLoader FFTJetProducer::esLoader_

private

Definition at line 413 of file FFTJetProducer.h.

Referenced by determinePileupDensityFromDB(), and FFTJetProducer().

◆ fixedScale

const double FFTJetProducer::fixedScale

private

Definition at line 278 of file FFTJetProducer.h.

Referenced by selectTreeNodes().

◆ genJetsLabel

const edm::InputTag FFTJetProducer::genJetsLabel

private

Definition at line 304 of file FFTJetProducer.h.

Referenced by FFTJetProducer().

◆ geometry_token_

edm::ESGetToken<CaloGeometry, CaloGeometryRecord> FFTJetProducer::geometry_token_

private

Definition at line 410 of file FFTJetProducer.h.

Referenced by FFTJetProducer(), and writeJets().

◆ gridAlg

std::unique_ptr<GridAlg> FFTJetProducer::gridAlg

private

Definition at line 334 of file FFTJetProducer.h.

Referenced by buildGridAlg(), determineGriddedConstituents(), iterateJetReconstruction(), and produce().

◆ gridScanMaxEta

const double FFTJetProducer::gridScanMaxEta

private

Definition at line 295 of file FFTJetProducer.h.

Referenced by buildGridAlg().

◆ iniScales

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

private

Definition at line 324 of file FFTJetProducer.h.

Referenced by FFTJetProducer(), and loadSparseTreeData().

◆ input_energyflow_token_

edm::EDGetTokenT<reco::DiscretizedEnergyFlow> FFTJetProducer::input_energyflow_token_

private

Definition at line 407 of file FFTJetProducer.h.

Referenced by FFTJetProducer(), and loadEnergyFlow().

◆ input_genjet_token_

edm::EDGetTokenT<std::vector<reco::FFTAnyJet<reco::GenJet> > > FFTJetProducer::input_genjet_token_

private

Definition at line 406 of file FFTJetProducer.h.

Referenced by FFTJetProducer(), and genJetPreclusters().

◆ input_pusummary_token_

edm::EDGetTokenT<reco::FFTJetPileupSummary> FFTJetProducer::input_pusummary_token_

private

Definition at line 408 of file FFTJetProducer.h.

Referenced by determinePileupDensityFromConfig(), determinePileupDensityFromDB(), and FFTJetProducer().

◆ input_recotree_token_d_

edm::EDGetTokenT<reco::PattRecoTree<double, reco::PattRecoPeak<double> > > FFTJetProducer::input_recotree_token_d_

private

Definition at line 404 of file FFTJetProducer.h.

Referenced by FFTJetProducer(), and produce().

◆ input_recotree_token_f_

edm::EDGetTokenT<reco::PattRecoTree<float, reco::PattRecoPeak<float> > > FFTJetProducer::input_recotree_token_f_

private

Definition at line 405 of file FFTJetProducer.h.

Referenced by FFTJetProducer(), and produce().

◆ isCrisp

const bool FFTJetProducer::isCrisp

private

Definition at line 299 of file FFTJetProducer.h.

Referenced by beginStream(), buildGridAlg(), and determinePileup().

◆ iterationsPerformed

unsigned FFTJetProducer::iterationsPerformed

private

Definition at line 381 of file FFTJetProducer.h.

Referenced by produce(), and saveResults().

◆ iterJets

std::vector<RecoFFTJet> FFTJetProducer::iterJets

private

Definition at line 380 of file FFTJetProducer.h.

Referenced by iterateJetReconstruction().

◆ iterPreclusters

std::vector<fftjet::Peak> FFTJetProducer::iterPreclusters

private

Definition at line 379 of file FFTJetProducer.h.

Referenced by iterateJetReconstruction(), and removeFakePreclusters().

◆ jetDistanceCalc

std::unique_ptr<fftjet::Functor2<double, RecoFFTJet, RecoFFTJet> > FFTJetProducer::jetDistanceCalc

private

Definition at line 354 of file FFTJetProducer.h.

Referenced by beginStream(), and checkConvergence().

◆ jetMembershipFunction

std::unique_ptr<fftjet::ScaleSpaceKernel> FFTJetProducer::jetMembershipFunction

private

Definition at line 335 of file FFTJetProducer.h.

Referenced by beginStream(), buildGridAlg(), and determinePileup().

◆ loadPileupFromDB

bool FFTJetProducer::loadPileupFromDB

private

Definition at line 321 of file FFTJetProducer.h.

Referenced by beginStream(), and produce().

◆ maxInitialPreclusters

const unsigned FFTJetProducer::maxInitialPreclusters

private

Definition at line 309 of file FFTJetProducer.h.

Referenced by produce().

◆ maxIterations

const unsigned FFTJetProducer::maxIterations

private

Definition at line 253 of file FFTJetProducer.h.

Referenced by beginStream(), iterateJetReconstruction(), produce(), and saveResults().

◆ maxLevel

unsigned FFTJetProducer::maxLevel

private

Definition at line 372 of file FFTJetProducer.h.

Referenced by saveResults(), and selectTreeNodes().

◆ maxStableScale

const double FFTJetProducer::maxStableScale

private

Definition at line 282 of file FFTJetProducer.h.

Referenced by selectTreeNodes().

◆ memberFactorCalcJet

std::unique_ptr<fftjet::Functor1<double, RecoFFTJet> > FFTJetProducer::memberFactorCalcJet

private

Definition at line 350 of file FFTJetProducer.h.

Referenced by beginStream(), determinePileup(), and iterateJetReconstruction().

◆ memberFactorCalcPeak

std::unique_ptr<fftjet::Functor1<double, fftjet::Peak> > FFTJetProducer::memberFactorCalcPeak

private

Definition at line 345 of file FFTJetProducer.h.

Referenced by beginStream(), and prepareRecombinationScales().

◆ memFcns2dVec

std::vector<fftjet::AbsKernel2d*> FFTJetProducer::memFcns2dVec

private

Definition at line 399 of file FFTJetProducer.h.

Referenced by determinePileup().

◆ minLevel

unsigned FFTJetProducer::minLevel

private

Definition at line 372 of file FFTJetProducer.h.

Referenced by saveResults(), and selectTreeNodes().

◆ minStableScale

const double FFTJetProducer::minStableScale

private

Definition at line 281 of file FFTJetProducer.h.

Referenced by selectTreeNodes().

◆ myConfiguration

const edm::ParameterSet FFTJetProducer::myConfiguration

private

Definition at line 239 of file FFTJetProducer.h.

Referenced by beginStream().

◆ nClustersRequested

const unsigned FFTJetProducer::nClustersRequested

private

Definition at line 292 of file FFTJetProducer.h.

Referenced by selectTreeNodes().

◆ nJetsRequiredToConverge

const unsigned FFTJetProducer::nJetsRequiredToConverge

private

Definition at line 256 of file FFTJetProducer.h.

◆ nodes

std::vector<SparseTree::NodeId> FFTJetProducer::nodes

private

Definition at line 357 of file FFTJetProducer.h.

Referenced by selectPreclusters().

◆ noiseLevel

const double FFTJetProducer::noiseLevel

private

Definition at line 289 of file FFTJetProducer.h.

Referenced by iterateJetReconstruction(), and produce().

◆ occupancy

std::vector<unsigned> FFTJetProducer::occupancy

private

Definition at line 366 of file FFTJetProducer.h.

Referenced by produce(), saveResults(), and selectTreeNodes().

◆ peakSelector

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

private

Definition at line 330 of file FFTJetProducer.h.

Referenced by beginStream(), and produce().

◆ pileup

std::vector<fftjetcms::VectorLike> FFTJetProducer::pileup

private

Definition at line 388 of file FFTJetProducer.h.

Referenced by determinePileup(), produce(), and writeJets().

◆ pileupDensityCalc

std::unique_ptr<fftjetcms::AbsPileupCalculator> FFTJetProducer::pileupDensityCalc

private

Definition at line 396 of file FFTJetProducer.h.

Referenced by beginStream(), and determinePileupDensityFromConfig().

◆ pileupEnergyFlow

std::unique_ptr<fftjet::Grid2d<fftjetcms::Real> > FFTJetProducer::pileupEnergyFlow

private

Definition at line 393 of file FFTJetProducer.h.

Referenced by beginStream(), determinePileup(), produce(), and writeJets().

◆ pileupLabel

const edm::InputTag FFTJetProducer::pileupLabel

private

Definition at line 275 of file FFTJetProducer.h.

Referenced by FFTJetProducer().

◆ pileupTableCategory

std::string FFTJetProducer::pileupTableCategory

private

Definition at line 320 of file FFTJetProducer.h.

Referenced by determinePileupDensityFromDB().

◆ pileupTableName

std::string FFTJetProducer::pileupTableName

private

Definition at line 319 of file FFTJetProducer.h.

Referenced by determinePileupDensityFromDB().

◆ pileupTableRecord

std::string FFTJetProducer::pileupTableRecord

private

Definition at line 318 of file FFTJetProducer.h.

Referenced by determinePileupDensityFromDB(), and FFTJetProducer().

◆ preclusters

std::vector<fftjet::Peak> FFTJetProducer::preclusters

private

Definition at line 360 of file FFTJetProducer.h.

Referenced by genJetPreclusters(), iterateJetReconstruction(), prepareRecombinationScales(), produce(), removeFakePreclusters(), and selectPreclusters().

◆ recoAlg

std::unique_ptr<RecoAlg> FFTJetProducer::recoAlg

private

Definition at line 333 of file FFTJetProducer.h.

Referenced by beginStream(), determineVectorConstituents(), iterateJetReconstruction(), and produce().

◆ recoJets

std::vector<RecoFFTJet> FFTJetProducer::recoJets

private

Definition at line 363 of file FFTJetProducer.h.

Referenced by determineGriddedConstituents(), determinePileup(), determineVectorConstituents(), iterateJetReconstruction(), produce(), removeFakePreclusters(), and writeJets().

◆ recombinationAlgorithm

const std::string FFTJetProducer::recombinationAlgorithm

private

Definition at line 298 of file FFTJetProducer.h.

Referenced by beginStream(), and buildGridAlg().

◆ recombinationDataCutoff

const double FFTJetProducer::recombinationDataCutoff

private

Definition at line 301 of file FFTJetProducer.h.

Referenced by buildGridAlg(), and writeJets().

◆ recoScaleCalcJet

std::unique_ptr<fftjet::Functor1<double, RecoFFTJet> > FFTJetProducer::recoScaleCalcJet

private

Definition at line 348 of file FFTJetProducer.h.

Referenced by beginStream(), determinePileup(), and iterateJetReconstruction().

◆ recoScaleCalcPeak

std::unique_ptr<fftjet::Functor1<double, fftjet::Peak> > FFTJetProducer::recoScaleCalcPeak

private

Definition at line 339 of file FFTJetProducer.h.

Referenced by beginStream(), and prepareRecombinationScales().

◆ recoScaleRatioCalcJet

std::unique_ptr<fftjet::Functor1<double, RecoFFTJet> > FFTJetProducer::recoScaleRatioCalcJet

private

Definition at line 349 of file FFTJetProducer.h.

Referenced by beginStream(), determinePileup(), and iterateJetReconstruction().

◆ recoScaleRatioCalcPeak

std::unique_ptr<fftjet::Functor1<double, fftjet::Peak> > FFTJetProducer::recoScaleRatioCalcPeak

private

Definition at line 342 of file FFTJetProducer.h.

Referenced by beginStream(), and prepareRecombinationScales().

◆ resolution

Resolution FFTJetProducer::resolution

private

Definition at line 314 of file FFTJetProducer.h.

Referenced by genJetPreclusters(), produce(), selectPreclusters(), and selectTreeNodes().

◆ resumConstituents

const bool FFTJetProducer::resumConstituents

private

Definition at line 265 of file FFTJetProducer.h.

Referenced by FFTJetProducer(), saveResults(), and writeJets().

◆ reuseExistingGrid

const bool FFTJetProducer::reuseExistingGrid

private

Definition at line 250 of file FFTJetProducer.h.

Referenced by beginStream(), and produce().

◆ sparseTree

SparseTree FFTJetProducer::sparseTree

private

Definition at line 327 of file FFTJetProducer.h.

Referenced by loadSparseTreeData(), produce(), saveResults(), and selectPreclusters().

◆ stabilityAlpha

const double FFTJetProducer::stabilityAlpha

private

Definition at line 285 of file FFTJetProducer.h.

Referenced by selectTreeNodes().

◆ subtractPileup

const bool FFTJetProducer::subtractPileup

private

Definition at line 270 of file FFTJetProducer.h.

Referenced by writeJets().

◆ subtractPileupAs4Vec

const bool FFTJetProducer::subtractPileupAs4Vec

private

Definition at line 271 of file FFTJetProducer.h.

Referenced by writeJets().

◆ thresholds

std::vector<double> FFTJetProducer::thresholds

private

Definition at line 369 of file FFTJetProducer.h.

Referenced by saveResults(), and selectTreeNodes().

◆ topology_token_

edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> FFTJetProducer::topology_token_

private

Definition at line 411 of file FFTJetProducer.h.

Referenced by FFTJetProducer(), and writeJets().

◆ treeLabel

const edm::InputTag FFTJetProducer::treeLabel

private

Definition at line 242 of file FFTJetProducer.h.

Referenced by FFTJetProducer().

◆ unclustered

fftjetcms::VectorLike FFTJetProducer::unclustered

private

Definition at line 375 of file FFTJetProducer.h.

Referenced by iterateJetReconstruction(), produce(), and saveResults().

◆ unlikelyBgWeight

const double FFTJetProducer::unlikelyBgWeight

private

Definition at line 300 of file FFTJetProducer.h.

Referenced by beginStream(), and buildGridAlg().

◆ unused

double FFTJetProducer::unused

private

Definition at line 376 of file FFTJetProducer.h.

Referenced by iterateJetReconstruction(), produce(), and saveResults().

◆ usedLevel

unsigned FFTJetProducer::usedLevel

private

Definition at line 372 of file FFTJetProducer.h.

Referenced by saveResults(), and selectTreeNodes().

◆ useGriddedAlgorithm

const bool FFTJetProducer::useGriddedAlgorithm

private

Definition at line 246 of file FFTJetProducer.h.

Referenced by beginStream(), iterateJetReconstruction(), produce(), and writeJets().

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ GridAlg

◆ RecoAlg

◆ RecoFFTJet

◆ SparseTree

Member Enumeration Documentation

◆ Resolution

◆ StatusBits

Constructor & Destructor Documentation

◆ FFTJetProducer() [1/3]

◆ FFTJetProducer() [2/3]

◆ FFTJetProducer() [3/3]

◆ ~FFTJetProducer()

Member Function Documentation

◆ assignMembershipFunctions()

◆ beginStream()

◆ buildGridAlg()

◆ checkConvergence()

◆ determineGriddedConstituents()

◆ determinePileup()

◆ determinePileupDensityFromConfig()

◆ determinePileupDensityFromDB()

◆ determineVectorConstituents()

◆ genJetPreclusters()

◆ iterateJetReconstruction()

◆ loadEnergyFlow()

◆ loadSparseTreeData() [1/2]

◆ loadSparseTreeData() [2/2]

◆ makeProduces()

◆ operator=()

◆ parse_bgMembershipFunction()

◆ parse_jetDistanceCalc()

◆ parse_jetMembershipFunction()

◆ parse_memberFactorCalcJet()

◆ parse_memberFactorCalcPeak()

◆ parse_peakSelector()

◆ parse_pileupDensityCalc()

◆ parse_recoScaleCalcJet()

◆ parse_recoScaleCalcPeak()

◆ parse_recoScaleRatioCalcJet()

◆ parse_recoScaleRatioCalcPeak()

◆ parse_resolution()

◆ prepareRecombinationScales()

◆ produce()

◆ removeFakePreclusters()

◆ saveResults()

◆ selectPreclusters()

◆ selectTreeNodes()

◆ setJetStatusBit()

◆ writeJets()

Member Data Documentation

◆ assignConstituents

◆ bgMembershipFunction

◆ calculatePileup

◆ cellCountsVec

◆ constituents

◆ convergenceDistance

◆ doubleBuf

◆ esLoader_

◆ fixedScale

◆ genJetsLabel

◆ geometry_token_

◆ gridAlg

◆ gridScanMaxEta

◆ iniScales

◆ input_energyflow_token_

◆ input_genjet_token_

◆ input_pusummary_token_

◆ input_recotree_token_d_

◆ input_recotree_token_f_