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

Inheritance diagram for FFTJetCorrectionProducer:

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

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

Private Member Functions
template<typename Jet >
void	applyCorrections (edm::Event &iEvent, const edm::EventSetup &iSetup, std::unique_ptr< typename FFTJetCorrectorSequenceTypemap< reco::FFTAnyJet< Jet >>::loader > &ptr)

template<typename Jet >
void	makeProduces (const std::string &alias, const std::string &tag, std::unique_ptr< typename FFTJetCorrectorSequenceTypemap< reco::FFTAnyJet< Jet >>::loader > &ptr)

template<typename Jet >
void	performPileupSubtraction (Jet &)

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

Private Attributes
std::unique_ptr< FFTBasicJetCorrectorSequenceLoader >	esLoaderBasic

std::unique_ptr< FFTCaloJetCorrectorSequenceLoader >	esLoaderCalo

std::unique_ptr< FFTGenJetCorrectorSequenceLoader >	esLoaderGen

std::unique_ptr< FFTJPTJetCorrectorSequenceLoader >	esLoaderJPT

std::unique_ptr< FFTPFJetCorrectorSequenceLoader >	esLoaderPF

std::unique_ptr< FFTTrackJetCorrectorSequenceLoader >	esLoaderTrack

unsigned long	eventCount

edm::EDGetTokenT< std::vector< reco::FFTAnyJet< reco::Jet > > >	input_jets_token_

const edm::InputTag	inputLabel

const JetType	jetType

const std::string	outputLabel

const std::vector< std::string >	records

std::vector< int >	sequenceMasks

const bool	subtractPileup

const bool	subtractPileupAs4Vec

const bool	verbose

const bool	writeUncertainties

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Description: producer for correcting jets created by FFTJetProducer

Implementation: [Notes on implementation]

Definition at line 87 of file FFTJetCorrectionProducer.cc.

Constructor & Destructor Documentation

◆ FFTJetCorrectionProducer()

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

explicit

Definition at line 345 of file FFTJetCorrectionProducer.cc.

References isoTrack_cff::alias, edm::ParameterSet::getUntrackedParameter(), input_jets_token_, inputLabel, jet_type_switch, makeProduces(), outputLabel, AlCaHLTBitMon_QueryRunRegistry::string, and writeUncertainties.

     : inputLabel(ps.getParameter<edm::InputTag>("src")),
       outputLabel(ps.getParameter<std::string>("outputLabel")),
       jetType(parseJetType(ps.getParameter<std::string>("jetType"))),
       records(ps.getParameter<std::vector<std::string>>("records")),
       writeUncertainties(ps.getParameter<bool>("writeUncertainties")),
       subtractPileup(ps.getParameter<bool>("subtractPileup")),
       subtractPileupAs4Vec(ps.getParameter<bool>("subtractPileupAs4Vec")),
       verbose(ps.getUntrackedParameter<bool>("verbose", false)),
       eventCount(0UL) {
   const std::string alias(ps.getUntrackedParameter<std::string>("alias", outputLabel));
   jet_type_switch(makeProduces, alias, outputLabel);
 
   if (writeUncertainties)
     produces<std::vector<float>>(outputLabel).setBranchAlias(alias);
 
   input_jets_token_ = consumes<std::vector<reco::FFTAnyJet<reco::Jet>>>(inputLabel);
 }

◆ ~FFTJetCorrectionProducer()

FFTJetCorrectionProducer::~FFTJetCorrectionProducer ( )

override

Definition at line 364 of file FFTJetCorrectionProducer.cc.

364 {}

Member Function Documentation

◆ applyCorrections()

template<typename Jet >

void FFTJetCorrectionProducer::applyCorrections	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		std::unique_ptr< typename FFTJetCorrectorSequenceTypemap< reco::FFTAnyJet< Jet >>::loader > &	ptr
	)

private

Definition at line 181 of file FFTJetCorrectionProducer.cc.

References alignCSCRings::corr, gather_cfg::cout, TauDecayModes::dec, Exception, f, reco::FFTJet< Real >::f_recoScale(), reco::FFTJet< Real >::f_status(), reco::FFTJet< Real >::f_vec(), mps_fire::i, iEvent, DiMuonV_cfg::isMC, dqmiolumiharvest::j, PDWG_EXODelayedJetMET_cff::jets, gammaJetAnalysis_CHSJECs_cff::level, web.browse_db::loader, GCPpyPlots::Loader, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, eostools::move(), nJets, recoTrackAccumulator_cfi::outputLabel, PILEUP_CALCULATION_MASK, PILEUP_SUBTRACTION_MASK_ANY, DiDispStaMuonMonitor_cfi::pt, alignCSCRings::s, jetUpdater_cfi::sort, mathSSE::sqrt(), fftjetproducer_cfi::subtractPileup, and verbose.

Referenced by produce().

                                                                                               {
   using reco::FFTJet;
   typedef reco::FFTAnyJet<Jet> MyJet;
   typedef std::vector<MyJet> MyCollection;
   typedef typename FFTJetCorrectorSequenceTypemap<MyJet>::loader Loader;
   typedef typename Loader::data_type CorrectorSequence;
   typedef typename CorrectorSequence::result_type CorrectorResult;
 
   // Load the jet corrector sequences
   const unsigned nRecords = records.size();
   std::vector<edm::ESHandle<CorrectorSequence>> handles(nRecords);
   for (unsigned irec = 0; irec < nRecords; ++irec)
     handles[irec] = loader->load(records[irec], iSetup);
 
   // Figure out which correction levels we are applying
   // and create masks which will indicate this
   sequenceMasks.clear();
   sequenceMasks.reserve(nRecords);
 
   int totalMask = 0;
   for (unsigned irec = 0; irec < nRecords; ++irec) {
     int levelMask = 0;
     const unsigned nLevels = handles[irec]->nLevels();
     for (unsigned i = 0; i < nLevels; ++i) {
       const unsigned lev = (*handles[irec])[i].level();
 
       // Not tracking "level 0" corrections in the status word.
       // Level 0 is basically reserved for uncertainty calculations.
       if (lev) {
         const int mask = (1 << lev);
         if (totalMask & mask)
           throw cms::Exception("FFTJetBadConfig")
               << "Error in FFTJetCorrectionProducer::applyCorrections:"
               << " jet correction at level " << lev << " is applied more than once\n";
         totalMask |= mask;
         levelMask |= mask;
       }
     }
     sequenceMasks.push_back(levelMask << 12);
   }
   totalMask = (totalMask << 12);
 
   // Is this data or MC?
   const bool isMC = !iEvent.isRealData();
 
   // Load the jet collection
   edm::Handle<MyCollection> jets;
   iEvent.getByToken(input_jets_token_, jets);
 
   // Create the output collection
   const unsigned nJets = jets->size();
   auto coll = std::make_unique<MyCollection>();
   coll->reserve(nJets);
 
   // Cycle over jets and apply the corrector sequences
   bool sorted = true;
   double previousPt = DBL_MAX;
   for (unsigned ijet = 0; ijet < nJets; ++ijet) {
     const MyJet& j((*jets)[ijet]);
 
     // Check that this jet has not been corrected yet
     const int initialStatus = j.getFFTSpecific().f_status();
     if (initialStatus & totalMask)
       throw cms::Exception("FFTJetBadConfig") << "Error in FFTJetCorrectionProducer::applyCorrections: "
                                               << "this jet collection is already corrected for some or all "
                                               << "of the specified levels\n";
 
     MyJet corJ(j);
 
     if (verbose) {
       const reco::FFTJet<float>& fj = corJ.getFFTSpecific();
       std::cout << "++++ Evt " << eventCount << " jet " << ijet << ": pt = " << corJ.pt()
                 << ", eta = " << fj.f_vec().eta() << ", R = " << fj.f_recoScale() << ", s = 0x" << std::hex
                 << fj.f_status() << std::dec << std::endl;
     }
 
     // Check if we need to subtract pileup first.
     // Pileup subtraction is not part of the corrector sequence
     // itself because 4-vector subtraction does not map well
     // into multiplication of 4-vectors by a scale factor.
     if (subtractPileup) {
       if (initialStatus & PILEUP_SUBTRACTION_MASK_ANY)
         throw cms::Exception("FFTJetBadConfig") << "Error in FFTJetCorrectionProducer::applyCorrections: "
                                                 << "this jet collection is already pileup-subtracted\n";
       if (!(initialStatus & PILEUP_CALCULATION_MASK))
         throw cms::Exception("FFTJetBadConfig") << "Error in FFTJetCorrectionProducer::applyCorrections: "
                                                 << "pileup was not calculated for this jet collection\n";
       performPileupSubtraction(corJ);
 
       if (verbose) {
         const reco::FFTJet<float>& fj = corJ.getFFTSpecific();
         std::cout << "     Pileup subtract"
                   << ": pt = " << corJ.pt() << ", eta = " << fj.f_vec().eta() << ", R = " << fj.f_recoScale()
                   << ", s = 0x" << std::hex << fj.f_status() << std::dec << std::endl;
       }
     }
 
     // Apply all jet correction sequences
     double sigmaSquared = 0.0;
     for (unsigned irec = 0; irec < nRecords; ++irec) {
       const CorrectorResult& corr = handles[irec]->correct(corJ, isMC);
 
       // Update the 4-vector
       FFTJet<float>& fftJet(const_cast<FFTJet<float>&>(corJ.getFFTSpecific()));
       corJ.setP4(corr.vec());
       fftJet.setFourVec(corr.vec());
 
       // Update the jet correction status
       fftJet.setStatus(fftJet.f_status() | sequenceMasks[irec]);
 
       // Update the (systematic) uncertainty
       const double s = corr.sigma();
       sigmaSquared += s * s;
     }
 
     // There is no place for uncertainty in the jet structure.
     // However, there is the unused pileup field (FFTJet maintains
     // the pileup separately as a 4-vector). Use this unused field
     // to store the uncertainty. This hack is needed because
     // subsequent sequence sorting by Pt can change the jet ordering.
     if (writeUncertainties)
       corJ.setPileup(sqrt(sigmaSquared));
 
     coll->push_back(corJ);
 
     // Check whether the sequence remains sorted by pt
     const double pt = corJ.pt();
     if (pt > previousPt)
       sorted = false;
     previousPt = pt;
 
     if (verbose) {
       const reco::FFTJet<float>& fj = corJ.getFFTSpecific();
       std::cout << "     Fully corrected"
                 << ": pt = " << corJ.pt() << ", eta = " << fj.f_vec().eta() << ", R = " << fj.f_recoScale()
                 << ", s = 0x" << std::hex << fj.f_status() << std::dec << std::endl;
     }
   }
 
   if (!sorted)
     std::sort(coll->begin(), coll->end(), LocalSortByPt());
 
   // Create the uncertainty sequence
   if (writeUncertainties) {
     auto unc = std::make_unique<std::vector<float>>();
     unc->reserve(nJets);
     for (unsigned ijet = 0; ijet < nJets; ++ijet) {
       MyJet& j((*coll)[ijet]);
       unc->push_back(j.pileup());
       j.setPileup(0.f);
     }
     iEvent.put(std::move(unc), outputLabel);
   }
 
   iEvent.put(std::move(coll), outputLabel);
   ++eventCount;
 }

◆ makeProduces()

template<typename Jet >

void FFTJetCorrectionProducer::makeProduces	(	const std::string &	alias,
		const std::string &	tag,
		std::unique_ptr< typename FFTJetCorrectorSequenceTypemap< reco::FFTAnyJet< Jet >>::loader > &	ptr
	)

private

Definition at line 149 of file FFTJetCorrectionProducer.cc.

References isoTrack_cff::alias, GCPpyPlots::Loader, and makeGlobalPositionRcd_cfg::tag.

Referenced by FFTJetCorrectionProducer().

                                                                                            {
   typedef reco::FFTAnyJet<Jet> MyJet;
   typedef typename FFTJetCorrectorSequenceTypemap<MyJet>::loader Loader;
 
   produces<std::vector<MyJet>>(tag).setBranchAlias(alias);
 
   ptr = std::make_unique<Loader>();
   const unsigned nRecords = records.size();
   for (unsigned irec = 0; irec < nRecords; ++irec)
     ptr->acquireToken(records[irec], consumesCollector());
 }

◆ performPileupSubtraction()

template<typename Jet >

void FFTJetCorrectionProducer::performPileupSubtraction ( Jet & jet )

private

Definition at line 165 of file FFTJetCorrectionProducer.cc.

References fftjetcms::adjustForPileup(), metsig::jet, PILEUP_SUBTRACTION_MASK_4VEC, PILEUP_SUBTRACTION_MASK_PT, mps_update::status, and fftjetproducer_cfi::subtractPileupAs4Vec.

                                                                 {
   using reco::FFTJet;
 
   FFTJet<float>& fftJet(const_cast<FFTJet<float>&>(jet.getFFTSpecific()));
   const math::XYZTLorentzVector& new4vec = adjustForPileup(fftJet.f_vec(), fftJet.f_pileup(), subtractPileupAs4Vec);
   fftJet.setFourVec(new4vec);
   int status = fftJet.f_status();
   if (subtractPileupAs4Vec)
     status |= PILEUP_SUBTRACTION_MASK_4VEC;
   else
     status |= PILEUP_SUBTRACTION_MASK_PT;
   fftJet.setStatus(status);
   jet.setP4(new4vec);
 }

◆ produce()

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

overrideprivate

Definition at line 367 of file FFTJetCorrectionProducer.cc.

References applyCorrections(), iEvent, and jet_type_switch.

                                                                                     {
   jet_type_switch(applyCorrections, iEvent, iSetup);
 }

Member Data Documentation

◆ esLoaderBasic

std::unique_ptr<FFTBasicJetCorrectorSequenceLoader> FFTJetCorrectionProducer::esLoaderBasic

private

Definition at line 140 of file FFTJetCorrectionProducer.cc.

◆ esLoaderCalo

std::unique_ptr<FFTCaloJetCorrectorSequenceLoader> FFTJetCorrectionProducer::esLoaderCalo

private

Definition at line 141 of file FFTJetCorrectionProducer.cc.

◆ esLoaderGen

std::unique_ptr<FFTGenJetCorrectorSequenceLoader> FFTJetCorrectionProducer::esLoaderGen

private

Definition at line 142 of file FFTJetCorrectionProducer.cc.

◆ esLoaderJPT

std::unique_ptr<FFTJPTJetCorrectorSequenceLoader> FFTJetCorrectionProducer::esLoaderJPT

private

Definition at line 145 of file FFTJetCorrectionProducer.cc.

◆ esLoaderPF

std::unique_ptr<FFTPFJetCorrectorSequenceLoader> FFTJetCorrectionProducer::esLoaderPF

private

Definition at line 143 of file FFTJetCorrectionProducer.cc.

◆ esLoaderTrack

std::unique_ptr<FFTTrackJetCorrectorSequenceLoader> FFTJetCorrectionProducer::esLoaderTrack

private

Definition at line 144 of file FFTJetCorrectionProducer.cc.

◆ eventCount

unsigned long FFTJetCorrectionProducer::eventCount

private

Definition at line 134 of file FFTJetCorrectionProducer.cc.

◆ input_jets_token_

edm::EDGetTokenT<std::vector<reco::FFTAnyJet<reco::Jet> > > FFTJetCorrectionProducer::input_jets_token_

private

Definition at line 137 of file FFTJetCorrectionProducer.cc.

Referenced by FFTJetCorrectionProducer().

◆ inputLabel

const edm::InputTag FFTJetCorrectionProducer::inputLabel

private

Definition at line 109 of file FFTJetCorrectionProducer.cc.

Referenced by FFTJetCorrectionProducer().

◆ jetType

const JetType FFTJetCorrectionProducer::jetType

private

Definition at line 115 of file FFTJetCorrectionProducer.cc.

◆ outputLabel

const std::string FFTJetCorrectionProducer::outputLabel

private

Definition at line 112 of file FFTJetCorrectionProducer.cc.

Referenced by FFTJetCorrectionProducer().

◆ records

const std::vector<std::string> FFTJetCorrectionProducer::records

private

Definition at line 118 of file FFTJetCorrectionProducer.cc.

◆ sequenceMasks

std::vector<int> FFTJetCorrectionProducer::sequenceMasks

private

Definition at line 131 of file FFTJetCorrectionProducer.cc.

◆ subtractPileup

const bool FFTJetCorrectionProducer::subtractPileup

private

Definition at line 124 of file FFTJetCorrectionProducer.cc.

◆ subtractPileupAs4Vec

const bool FFTJetCorrectionProducer::subtractPileupAs4Vec

private

Definition at line 125 of file FFTJetCorrectionProducer.cc.

◆ verbose

const bool FFTJetCorrectionProducer::verbose

private

Definition at line 128 of file FFTJetCorrectionProducer.cc.

◆ writeUncertainties

const bool FFTJetCorrectionProducer::writeUncertainties

private

Definition at line 121 of file FFTJetCorrectionProducer.cc.

Referenced by FFTJetCorrectionProducer().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FFTJetCorrectionProducer()

◆ ~FFTJetCorrectionProducer()

Member Function Documentation

◆ applyCorrections()

◆ makeProduces()

◆ performPileupSubtraction()

◆ produce()

Member Data Documentation

◆ esLoaderBasic

◆ esLoaderCalo

◆ esLoaderGen

◆ esLoaderJPT

◆ esLoaderPF

◆ esLoaderTrack

◆ eventCount

◆ input_jets_token_

◆ inputLabel

◆ jetType

◆ outputLabel

◆ records

◆ sequenceMasks

◆ subtractPileup

◆ subtractPileupAs4Vec

◆ verbose

◆ writeUncertainties