#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

	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 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::ValueMap< float >	constituentWeights_

edm::EDGetTokenT< edm::ValueMap< float > >	input_constituent_weights_token_

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_

edm::ESGetToken< JetCorrectorParametersCollection, JetCorrectionsRecord >	parameters_token_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< GBRForestsAndConstants > >
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: [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 51 of file PileupJetIdProducer.cc.

References algos_, deDxTools::esConsumes(), edm::ParameterSet::getParameter(), input_constituent_weights_token_, input_jet_token_, input_rho_token_, input_vertex_token_, input_vm_pujetid_token_, GBRForestsAndConstants::jec(), label, parameters_token_, GBRForestsAndConstants::produceJetIds(), GBRForestsAndConstants::runMvas(), PileupJetID_cfi::srcConstituentWeights, AlCaHLTBitMon_QueryRunRegistry::string, and GBRForestsAndConstants::vAlgoGBRForestsAndConstants().

                                                                                                                   {
   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"));
   parameters_token_ = esConsumes(edm::ESInputTag("", globalCache->jec()));
 
   edm::InputTag srcConstituentWeights = iConfig.getParameter<edm::InputTag>("srcConstituentWeights");
   if (!srcConstituentWeights.label().empty()) {
     input_constituent_weights_token_ = consumes<edm::ValueMap<float>>(srcConstituentWeights);
   }
 }

◆ ~PileupJetIdProducer()

PileupJetIdProducer::~PileupJetIdProducer ( )

override

Definition at line 78 of file PileupJetIdProducer.cc.

78 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 247 of file PileupJetIdProducer.cc.

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

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

◆ 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.

References muonDTDigis_cfi::pset.

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

◆ initJetEnergyCorrector()

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

private

Definition at line 256 of file PileupJetIdProducer.cc.

References edm::FileInPath::fullPath(), edm::EventSetup::getData(), ConfigBuilder::isData, jecCor_, jetCorPars_, parameters_token_, GBRForestsAndConstants::residualsFromTxt(), and GBRForestsAndConstants::residualsTxt().

Referenced by produce().

                                                                                          {
   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
   auto const& parameters = iSetup.getData(parameters_token_);
   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_);
 }

◆ produce()

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

overrideprivate

Definition at line 81 of file PileupJetIdProducer.cc.

References algos_, GBRForestsAndConstants::applyConstituentWeight(), jetMETDQMOfflineSource_cff::applyJec, GBRForestsAndConstants::applyJec(), cms::cuda::assert(), PileupJetIdAlgo::computeIdVariables(), PileupJetIdAlgo::computeMva(), pat::Jet::correctedJet(), reco::LeafCandidate::eta(), mps_fire::i, PileupJetIdentifier::idFlag(), iEvent, initJetEnergyCorrector(), input_constituent_weights_token_, input_jet_token_, input_rho_token_, input_vertex_token_, input_vm_pujetid_token_, GBRForestsAndConstants::inputIsCorrected(), edm::EDGetTokenT< T >::isUninitialized(), jetMETDQMOfflineSource_cff::jec, jecCor_, metsig::jet, StoredPileupJetIdentifier::jetEta(), PileupJetIdentifier::jetPhi(), StoredPileupJetIdentifier::jetPt(), PDWG_EXODelayedJetMET_cff::jets, eostools::move(), PileupJetIdentifier::mva(), beam_dqm_sourceclient-live_cfg::mva, reco::LeafCandidate::phi(), GBRForestsAndConstants::produceJetIds(), edm::Handle< T >::product(), reco::LeafCandidate::pt(), rho, GBRForestsAndConstants::runMvas(), isotrackNtupler::scale, PileupJetIdAlgo::set(), jetsAK4_CHS_cff::vertexes, and L1BJetProducer_cff::vtx.

                                                                                {
   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;
 
   // Constituent weight (e.g PUPPI) Value Map
   edm::ValueMap<float> constituentWeights;
   if (!input_constituent_weights_token_.isUninitialized()) {
     constituentWeights = iEvent.get(input_constituent_weights_token_);
   }
 
   // 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_->setJetPhi(jet.phi());
       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, constituentWeights, gc->applyConstituentWeight());
       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));
   }
 }