#include "PhysicsTools/PatAlgos/interface/PATJetUpdater.h"

Inheritance diagram for pat::PATJetUpdater:

Public Member Functions
	PATJetUpdater (const edm::ParameterSet &iConfig)

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

	~PATJetUpdater () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Private Attributes
bool	addBTagInfo_

bool	addDiscriminators_

bool	addJetCorrFactors_

bool	addTagInfos_

std::vector< std::string >	discriminatorLabels_

std::vector< edm::InputTag >	discriminatorTags_

std::vector< edm::EDGetTokenT< reco::JetFloatAssociation::Container > >	discriminatorTokens_

std::vector< edm::EDGetTokenT< edm::ValueMap< JetCorrFactors > > >	jetCorrFactorsTokens_

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

bool	printWarning_

GreaterByPt< Jet >	pTComparator_

std::vector< std::string >	tagInfoLabels_

std::vector< edm::InputTag >	tagInfoTags_

std::vector< edm::EDGetTokenT< edm::View< reco::BaseTagInfo > > >	tagInfoTokens_

pat::PATUserDataHelper< pat::Jet >	userDataHelper_

bool	useUserData_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
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

Produces pat::Jet's.

The PATJetUpdater produces analysis-level pat::Jet's starting from a collection of pat::Jet's and updates information.

Author: Andreas Hinzmann

Version

Id: PATJetUpdater.h,v 1.00 2014/03/11 18:13:54 srappocc Exp

Definition at line 33 of file PATJetUpdater.h.

Constructor & Destructor Documentation

PATJetUpdater::PATJetUpdater ( const edm::ParameterSet & iConfig )

explicit

Definition at line 25 of file PATJetUpdater.cc.

References addBTagInfo_, addDiscriminators_, addJetCorrFactors_, addTagInfos_, discriminatorLabels_, discriminatorTags_, discriminatorTokens_, edm::ParameterSet::getParameter(), jetCorrFactorsTokens_, jetsToken_, label, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, tagInfoLabels_, tagInfoTags_, tagInfoTokens_, userDataHelper_, useUserData_, and edm::vector_transform().

     : useUserData_(iConfig.exists("userData")), printWarning_(iConfig.getParameter<bool>("printWarning")) {
   // initialize configurables
   jetsToken_ = consumes<edm::View<reco::Jet>>(iConfig.getParameter<edm::InputTag>("jetSource"));
   addJetCorrFactors_ = iConfig.getParameter<bool>("addJetCorrFactors");
   if (addJetCorrFactors_) {
     jetCorrFactorsTokens_ = edm::vector_transform(
         iConfig.getParameter<std::vector<edm::InputTag>>("jetCorrFactorsSource"),
         [this](edm::InputTag const& tag) { return mayConsume<edm::ValueMap<JetCorrFactors>>(tag); });
   }
   addBTagInfo_ = iConfig.getParameter<bool>("addBTagInfo");
   addDiscriminators_ = iConfig.getParameter<bool>("addDiscriminators");
   discriminatorTags_ = iConfig.getParameter<std::vector<edm::InputTag>>("discriminatorSources");
   discriminatorTokens_ = edm::vector_transform(discriminatorTags_, [this](edm::InputTag const& tag) {
     return mayConsume<reco::JetFloatAssociation::Container>(tag);
   });
   addTagInfos_ = iConfig.getParameter<bool>("addTagInfos");
   tagInfoTags_ = iConfig.getParameter<std::vector<edm::InputTag>>("tagInfoSources");
   tagInfoTokens_ = edm::vector_transform(
       tagInfoTags_, [this](edm::InputTag const& tag) { return mayConsume<edm::View<reco::BaseTagInfo>>(tag); });
   if (discriminatorTags_.empty()) {
     addDiscriminators_ = false;
   } else {
     for (std::vector<edm::InputTag>::const_iterator it = discriminatorTags_.begin(), ed = discriminatorTags_.end();
          it != ed;
          ++it) {
       std::string label = it->label();
       std::string::size_type pos = label.find("JetTags");
       if ((pos != std::string::npos) && (pos != label.length() - 7)) {
         label.erase(pos + 7);  // trim a tail after "JetTags"
       }
       if (!it->instance().empty()) {
         label = (label + std::string(":") + it->instance());
       }
       discriminatorLabels_.push_back(label);
     }
   }
   if (tagInfoTags_.empty()) {
     addTagInfos_ = false;
   } else {
     for (std::vector<edm::InputTag>::const_iterator it = tagInfoTags_.begin(), ed = tagInfoTags_.end(); it != ed;
          ++it) {
       std::string label = it->label();
       std::string::size_type pos = label.find("TagInfos");
       if ((pos != std::string::npos) && (pos != label.length() - 8)) {
         label.erase(pos + 8);  // trim a tail after "TagInfos"
       }
       tagInfoLabels_.push_back(label);
     }
   }
   if (!addBTagInfo_) {
     addDiscriminators_ = false;
     addTagInfos_ = false;
   }
   // Check to see if the user wants to add user data
   if (useUserData_) {
     userDataHelper_ = PATUserDataHelper<Jet>(iConfig.getParameter<edm::ParameterSet>("userData"), consumesCollector());
   }
   // produces vector of jets
   produces<std::vector<Jet>>();
   produces<edm::OwnVector<reco::BaseTagInfo>>("tagInfos");
 }

PATJetUpdater::~PATJetUpdater ( )

override

Definition at line 88 of file PATJetUpdater.cc.

88 {}

Member Function Documentation

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

static

Definition at line 228 of file PATJetUpdater.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), DEFINE_FWK_MODULE, pat::PATUserDataHelper< ObjectType >::fillDescription(), HLT_2018_cff::InputTag, and edm::ParameterSetDescription::setComment().

                                                                                {
   edm::ParameterSetDescription iDesc;
   iDesc.setComment("PAT jet producer module");
 
   // input source
   iDesc.add<edm::InputTag>("jetSource", edm::InputTag("no default"))->setComment("input collection");
 
   // tag info
   iDesc.add<bool>("addTagInfos", true);
   std::vector<edm::InputTag> emptyVInputTags;
   iDesc.add<std::vector<edm::InputTag>>("tagInfoSources", emptyVInputTags);
 
   // jet energy corrections
   iDesc.add<bool>("addJetCorrFactors", true);
   iDesc.add<std::vector<edm::InputTag>>("jetCorrFactorsSource", emptyVInputTags);
 
   // btag discriminator tags
   iDesc.add<bool>("addBTagInfo", true);
   iDesc.add<bool>("addDiscriminators", true);
   iDesc.add<std::vector<edm::InputTag>>("discriminatorSources", emptyVInputTags);
 
   // silent warning if false
   iDesc.add<bool>("printWarning", true);
 
   // Check to see if the user wants to add user data
   edm::ParameterSetDescription userDataPSet;
   PATUserDataHelper<Jet>::fillDescription(userDataPSet);
   iDesc.addOptional("userData", userDataPSet);
 
   descriptions.add("PATJetUpdater", iDesc);
 }

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

override

Definition at line 90 of file PATJetUpdater.cc.

References pat::Jet::addBDiscriminatorPair(), addBTagInfo_, addDiscriminators_, pat::Jet::addJECFactors(), addJetCorrFactors_, pat::Jet::addTagInfo(), addTagInfos_, edm::View< T >::begin(), edm::RefToBase< T >::castTo(), reco::BaseTagInfo::clone(), pat::Jet::correctedP4(), discriminatorLabels_, discriminatorTokens_, edm::View< T >::end(), spr::find(), edm::Event::getByToken(), edm::Event::getRefBeforePut(), mps_fire::i, training_settings::idx, pat::Jet::initializeJEC(), edm::Ptr< T >::isNonnull(), pat::Jet::jec_, metsig::jet, jetCorrFactorsTokens_, singleTopDQM_cfi::jets, jetsToken_, dqmdumpme::k, jets_cff::levels, match(), eostools::move(), hemisphereProducer_cfi::patJets, printWarning_, pTComparator_, edm::View< T >::ptrAt(), edm::Event::put(), pat::PATObject< ObjectType >::refToOrig_, reco::LeafCandidate::setP4(), edm::View< T >::size(), tagInfoLabels_, tagInfoTokens_, userDataHelper_, and useUserData_.

                                                                          {
   // Get the vector of jets
   edm::Handle<edm::View<reco::Jet>> jets;
   iEvent.getByToken(jetsToken_, jets);
 
   // read in the jet correction factors ValueMap
   std::vector<edm::ValueMap<JetCorrFactors>> jetCorrs;
   if (addJetCorrFactors_) {
     for (size_t i = 0; i < jetCorrFactorsTokens_.size(); ++i) {
       edm::Handle<edm::ValueMap<JetCorrFactors>> jetCorr;
       iEvent.getByToken(jetCorrFactorsTokens_[i], jetCorr);
       jetCorrs.push_back(*jetCorr);
     }
   }
 
   // Get the vector of jet tags with b-tagging info
   std::vector<edm::Handle<reco::JetFloatAssociation::Container>> jetDiscriminators;
   if (addBTagInfo_ && addDiscriminators_) {
     jetDiscriminators.resize(discriminatorTokens_.size());
     for (size_t i = 0; i < discriminatorTokens_.size(); ++i) {
       iEvent.getByToken(discriminatorTokens_[i], jetDiscriminators[i]);
     }
   }
   std::vector<edm::Handle<edm::View<reco::BaseTagInfo>>> jetTagInfos;
   if (addBTagInfo_ && addTagInfos_) {
     jetTagInfos.resize(tagInfoTokens_.size());
     for (size_t i = 0; i < tagInfoTokens_.size(); ++i) {
       iEvent.getByToken(tagInfoTokens_[i], jetTagInfos[i]);
     }
   }
 
   // loop over jets
   auto patJets = std::make_unique<std::vector<Jet>>();
 
   auto tagInfosOut = std::make_unique<edm::OwnVector<reco::BaseTagInfo>>();
 
   edm::RefProd<edm::OwnVector<reco::BaseTagInfo>> h_tagInfosOut =
       iEvent.getRefBeforePut<edm::OwnVector<reco::BaseTagInfo>>("tagInfos");
 
   for (edm::View<reco::Jet>::const_iterator itJet = jets->begin(); itJet != jets->end(); itJet++) {
     // construct the Jet from the ref -> save ref to original object
     unsigned int idx = itJet - jets->begin();
     const edm::RefToBase<reco::Jet> jetRef = jets->refAt(idx);
     const edm::RefToBase<Jet> patJetRef(jetRef.castTo<JetRef>());
     Jet ajet(patJetRef);
 
     if (addJetCorrFactors_) {
       // undo previous jet energy corrections
       ajet.setP4(ajet.correctedP4(0));
       // clear previous JetCorrFactors
       ajet.jec_.clear();
       // add additional JetCorrs to the jet
       for (unsigned int i = 0; i < jetCorrFactorsTokens_.size(); ++i) {
         const JetCorrFactors& jcf = jetCorrs[i][jetRef];
         // uncomment for debugging
         // jcf.print();
         ajet.addJECFactors(jcf);
       }
       std::vector<std::string> levels = jetCorrs[0][jetRef].correctionLabels();
       if (std::find(levels.begin(), levels.end(), "L2L3Residual") != levels.end()) {
         ajet.initializeJEC(jetCorrs[0][jetRef].jecLevel("L2L3Residual"));
       } else if (std::find(levels.begin(), levels.end(), "L3Absolute") != levels.end()) {
         ajet.initializeJEC(jetCorrs[0][jetRef].jecLevel("L3Absolute"));
       } else {
         ajet.initializeJEC(jetCorrs[0][jetRef].jecLevel("Uncorrected"));
         if (printWarning_) {
           edm::LogWarning("L3Absolute not found")
               << "L2L3Residual and L3Absolute are not part of the jetCorrFactors\n"
               << "of module " << jetCorrs[0][jetRef].jecSet() << ". Jets will remain"
               << " uncorrected.";
           printWarning_ = false;
         }
       }
     }
 
     // add b-tag info if available & required
     if (addBTagInfo_) {
       if (addDiscriminators_) {
         for (size_t k = 0; k < jetDiscriminators.size(); ++k) {
           float value = (*jetDiscriminators[k])[jetRef];
           ajet.addBDiscriminatorPair(std::make_pair(discriminatorLabels_[k], value));
         }
       }
       if (addTagInfos_) {
         for (size_t k = 0; k < jetTagInfos.size(); ++k) {
           const edm::View<reco::BaseTagInfo>& taginfos = *jetTagInfos[k];
           // This is not associative, so we have to search the jet
           edm::Ptr<reco::BaseTagInfo> match;
           // Try first by 'same index'
           if ((idx < taginfos.size()) && (taginfos[idx].jet() == jetRef)) {
             match = taginfos.ptrAt(idx);
           } else {
             // otherwise fail back to a simple search
             for (edm::View<reco::BaseTagInfo>::const_iterator itTI = taginfos.begin(), edTI = taginfos.end();
                  itTI != edTI;
                  ++itTI) {
               if (itTI->jet() == jetRef) {
                 match = taginfos.ptrAt(itTI - taginfos.begin());
                 break;
               }
             }
           }
           if (match.isNonnull()) {
             tagInfosOut->push_back(match->clone());
             // set the "forward" ptr to the thinned collection
             edm::Ptr<reco::BaseTagInfo> tagInfoForwardPtr(
                 h_tagInfosOut.id(), &tagInfosOut->back(), tagInfosOut->size() - 1);
             // set the "backward" ptr to the original collection for association
             const edm::Ptr<reco::BaseTagInfo>& tagInfoBackPtr(match);
             // make FwdPtr
             TagInfoFwdPtrCollection::value_type tagInfoFwdPtr(tagInfoForwardPtr, tagInfoBackPtr);
             ajet.addTagInfo(tagInfoLabels_[k], tagInfoFwdPtr);
           }
         }
       }
     }
 
     if (useUserData_) {
       userDataHelper_.add(ajet, iEvent, iSetup);
     }
 
     // reassign the original object reference to preserve reference to the original jet the input PAT jet was derived from
     // (this needs to be done at the end since cloning the input PAT jet would interfere with adding UserData)
     ajet.refToOrig_ = patJetRef->originalObjectRef();
 
     patJets->push_back(ajet);
   }
 
   // sort jets in pt
   std::sort(patJets->begin(), patJets->end(), pTComparator_);
 
   // put genEvt  in Event
   iEvent.put(std::move(patJets));
 
   iEvent.put(std::move(tagInfosOut), "tagInfos");
 }