#include <CMGTools/PileupJetIdProducer/src/PileupJetIdProducer.cc>

Inheritance diagram for PileupJetIdProducer:

Public Member Functions
	PileupJetIdProducer (const edm::ParameterSet &, GBRForestsAndConstants const *)

	~PileupJetIdProducer () override

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< GBRForestsAndConstants > >
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

static void	globalEndJob (GBRForestsAndConstants *)

static std::unique_ptr< GBRForestsAndConstants >	initializeGlobalCache (edm::ParameterSet const &pset)

Private Member Functions
void	initJetEnergyCorrector (const edm::EventSetup &iSetup, bool isData)

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

Private Attributes
std::vector< std::pair< std::string, std::unique_ptr< PileupJetIdAlgo > > >	algos_

edm::EDGetTokenT< edm::View< reco::Jet > >	input_jet_token_

edm::EDGetTokenT< double >	input_rho_token_

edm::EDGetTokenT< reco::VertexCollection >	input_vertex_token_

edm::EDGetTokenT< edm::ValueMap< StoredPileupJetIdentifier > >	input_vm_pujetid_token_

std::unique_ptr< FactorizedJetCorrector >	jecCor_

std::vector< JetCorrectorParameters >	jetCorPars_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< GBRForestsAndConstants > >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Description: Produces a value map of jet --> pileup jet ID

Implementation: [Notes on implementation]

Definition at line 79 of file PileupJetIdProducer.h.

Constructor & Destructor Documentation

◆ PileupJetIdProducer()

PileupJetIdProducer::PileupJetIdProducer	(	const edm::ParameterSet &	iConfig,
		GBRForestsAndConstants const *	globalCache
	)

explicit

Definition at line 46 of file PileupJetIdProducer.cc.

                                                                                                                   {
   if (globalCache->produceJetIds()) {
     produces<edm::ValueMap<StoredPileupJetIdentifier>>("");
   }
   for (auto const& algoGBRForestsAndConstants : globalCache->vAlgoGBRForestsAndConstants()) {
     std::string const& label = algoGBRForestsAndConstants.label();
     algos_.emplace_back(label, std::make_unique<PileupJetIdAlgo>(&algoGBRForestsAndConstants));
     if (globalCache->runMvas()) {
       produces<edm::ValueMap<float>>(label + "Discriminant");
       produces<edm::ValueMap<int>>(label + "Id");
     }
   }
  
   input_jet_token_ = consumes<edm::View<reco::Jet>>(iConfig.getParameter<edm::InputTag>("jets"));
   input_vertex_token_ = consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertexes"));
   input_vm_pujetid_token_ =
       consumes<edm::ValueMap<StoredPileupJetIdentifier>>(iConfig.getParameter<edm::InputTag>("jetids"));
   input_rho_token_ = consumes<double>(iConfig.getParameter<edm::InputTag>("rho"));
 }

References algos_, edm::ParameterSet::getParameter(), input_jet_token_, input_rho_token_, input_vertex_token_, input_vm_pujetid_token_, label, GBRForestsAndConstants::produceJetIds(), GBRForestsAndConstants::runMvas(), AlCaHLTBitMon_QueryRunRegistry::string, and GBRForestsAndConstants::vAlgoGBRForestsAndConstants().

◆ ~PileupJetIdProducer()

PileupJetIdProducer::~PileupJetIdProducer ( )

override

Definition at line 67 of file PileupJetIdProducer.cc.

67 {}

Member Function Documentation

◆ fillDescriptions()

void PileupJetIdProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 227 of file PileupJetIdProducer.cc.

                                                                                      {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

References edm::ConfigurationDescriptions::addDefault(), and submitPVResolutionJobs::desc.

◆ globalEndJob()

static void PileupJetIdProducer::globalEndJob ( GBRForestsAndConstants * )

inlinestatic

Definition at line 90 of file PileupJetIdProducer.h.

90 {}

◆ initializeGlobalCache()

static std::unique_ptr<GBRForestsAndConstants> PileupJetIdProducer::initializeGlobalCache ( edm::ParameterSet const & pset )

inlinestatic

Definition at line 86 of file PileupJetIdProducer.h.

                                                                                                   {
     return std::make_unique<GBRForestsAndConstants>(pset);
   }

References muonDTDigis_cfi::pset.

◆ initJetEnergyCorrector()

void PileupJetIdProducer::initJetEnergyCorrector	(	const edm::EventSetup &	iSetup,
		bool	isData
	)

private

Definition at line 236 of file PileupJetIdProducer.cc.

                                                                                          {
   GBRForestsAndConstants const* gc = globalCache();
  
   //jet energy correction levels to apply on raw jet
   std::vector<std::string> jecLevels;
   jecLevels.push_back("L1FastJet");
   jecLevels.push_back("L2Relative");
   jecLevels.push_back("L3Absolute");
   if (isData && !gc->residualsFromTxt())
     jecLevels.push_back("L2L3Residual");
  
   //check the corrector parameters needed according to the correction levels
   edm::ESHandle<JetCorrectorParametersCollection> parameters;
   iSetup.get<JetCorrectionsRecord>().get(gc->jec(), parameters);
   for (std::vector<std::string>::const_iterator ll = jecLevels.begin(); ll != jecLevels.end(); ++ll) {
     const JetCorrectorParameters& ip = (*parameters)[*ll];
     jetCorPars_.push_back(ip);
   }
   if (isData && gc->residualsFromTxt()) {
     jetCorPars_.push_back(JetCorrectorParameters(gc->residualsTxt().fullPath()));
   }
  
   //instantiate the jet corrector
   jecCor_ = std::make_unique<FactorizedJetCorrector>(jetCorPars_);
 }

References edm::FileInPath::fullPath(), edm::EventSetup::get(), get, HLTBitAnalyser_cfi::isData, GBRForestsAndConstants::jec(), jecCor_, jetCorPars_, GBRForestsAndConstants::residualsFromTxt(), and GBRForestsAndConstants::residualsTxt().

Referenced by produce().

◆ produce()

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

overrideprivate

Definition at line 70 of file PileupJetIdProducer.cc.

                                                                                {
   GBRForestsAndConstants const* gc = globalCache();
  
   using namespace edm;
   using namespace std;
   using namespace reco;
  
   // Input jets
   Handle<View<Jet>> jetHandle;
   iEvent.getByToken(input_jet_token_, jetHandle);
   const View<Jet>& jets = *jetHandle;
  
   // input variables
   Handle<ValueMap<StoredPileupJetIdentifier>> vmap;
   if (!gc->produceJetIds()) {
     iEvent.getByToken(input_vm_pujetid_token_, vmap);
   }
   // rho
   edm::Handle<double> rhoH;
   double rho = 0.;
  
   // products
   vector<StoredPileupJetIdentifier> ids;
   map<string, vector<float>> mvas;
   map<string, vector<int>> idflags;
  
   const VertexCollection* vertexes = nullptr;
   VertexCollection::const_iterator vtx;
   if (gc->produceJetIds()) {
     // vertexes
     Handle<VertexCollection> vertexHandle;
     iEvent.getByToken(input_vertex_token_, vertexHandle);
  
     vertexes = vertexHandle.product();
  
     // require basic quality cuts on the vertexes
     vtx = vertexes->begin();
     while (vtx != vertexes->end() && (vtx->isFake() || vtx->ndof() < 4)) {
       ++vtx;
     }
     if (vtx == vertexes->end()) {
       vtx = vertexes->begin();
     }
   }
  
   // Loop over input jets
   bool ispat = true;
   for (unsigned int i = 0; i < jets.size(); ++i) {
     // Pick the first algo to compute the input variables
     auto algoi = algos_.begin();
     PileupJetIdAlgo* ialgo = algoi->second.get();
  
     const Jet& jet = jets.at(i);
     const pat::Jet* patjet = nullptr;
     if (ispat) {
       patjet = dynamic_cast<const pat::Jet*>(&jet);
       ispat = patjet != nullptr;
     }
  
     // Get jet energy correction
     float jec = 0.;
     if (gc->applyJec()) {
       // If haven't done it get rho from the event
       if (rho == 0.) {
         iEvent.getByToken(input_rho_token_, rhoH);
         rho = *rhoH;
       }
       // jet corrector
       if (not jecCor_) {
         initJetEnergyCorrector(iSetup, iEvent.isRealData());
       }
       if (ispat) {
         jecCor_->setJetPt(patjet->correctedJet(0).pt());
       } else {
         jecCor_->setJetPt(jet.pt());
       }
       jecCor_->setJetEta(jet.eta());
       jecCor_->setJetA(jet.jetArea());
       jecCor_->setRho(rho);
       jec = jecCor_->getCorrection();
     }
     // If it was requested AND the input is an uncorrected jet apply the JEC
     bool applyJec = gc->applyJec() && (ispat || !gc->inputIsCorrected());
     std::unique_ptr<reco::Jet> corrJet;
  
     if (applyJec) {
       float scale = jec;
       if (ispat) {
         corrJet = std::make_unique<pat::Jet>(patjet->correctedJet(0));
       } else {
         corrJet.reset(dynamic_cast<reco::Jet*>(jet.clone()));
       }
       corrJet->scaleEnergy(scale);
     }
     const reco::Jet* theJet = (applyJec ? corrJet.get() : &jet);
  
     PileupJetIdentifier puIdentifier;
     if (gc->produceJetIds()) {
       // Compute the input variables
       puIdentifier = ialgo->computeIdVariables(theJet, jec, &(*vtx), *vertexes, rho, gc->usePuppi());
       ids.push_back(puIdentifier);
     } else {
       // Or read it from the value map
       puIdentifier = (*vmap)[jets.refAt(i)];
       puIdentifier.jetPt(theJet->pt());  // make sure JEC is applied when computing the MVA
       puIdentifier.jetEta(theJet->eta());
       puIdentifier.jetPhi(theJet->phi());
       ialgo->set(puIdentifier);
       puIdentifier = ialgo->computeMva();
     }
  
     if (gc->runMvas()) {
       // Compute the MVA and WP
       mvas[algoi->first].push_back(puIdentifier.mva());
       idflags[algoi->first].push_back(puIdentifier.idFlag());
       for (++algoi; algoi != algos_.end(); ++algoi) {
         ialgo = algoi->second.get();
         ialgo->set(puIdentifier);
         PileupJetIdentifier id = ialgo->computeMva();
         mvas[algoi->first].push_back(id.mva());
         idflags[algoi->first].push_back(id.idFlag());
       }
     }
   }
  
   // Produce the output value maps
   if (gc->runMvas()) {
     for (const auto& ialgo : algos_) {
       // MVA
       vector<float>& mva = mvas[ialgo.first];
       auto mvaout = std::make_unique<ValueMap<float>>();
       ValueMap<float>::Filler mvafiller(*mvaout);
       mvafiller.insert(jetHandle, mva.begin(), mva.end());
       mvafiller.fill();
       iEvent.put(std::move(mvaout), ialgo.first + "Discriminant");
  
       // WP
       vector<int>& idflag = idflags[ialgo.first];
       auto idflagout = std::make_unique<ValueMap<int>>();
       ValueMap<int>::Filler idflagfiller(*idflagout);
       idflagfiller.insert(jetHandle, idflag.begin(), idflag.end());
       idflagfiller.fill();
       iEvent.put(std::move(idflagout), ialgo.first + "Id");
     }
   }
   // input variables
   if (gc->produceJetIds()) {
     assert(jetHandle->size() == ids.size());
     auto idsout = std::make_unique<ValueMap<StoredPileupJetIdentifier>>();
     ValueMap<StoredPileupJetIdentifier>::Filler idsfiller(*idsout);
     idsfiller.insert(jetHandle, ids.begin(), ids.end());
     idsfiller.fill();
     iEvent.put(std::move(idsout));
   }
 }