Merge pull request #34997 from Dr15Jones/esConsumesForPAT

use esConsumes in PhysicsTools/PatAlgos modules

PhysicsTools/PatAlgos/interface/KinResolutionsLoader.h

@@ -5,13 +5,16 @@
 
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 
 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
 
+#include "FWCore/Utilities/interface/ESGetToken.h"
+
 #include "PhysicsTools/PatAlgos/interface/KinematicResolutionProvider.h"
+#include "PhysicsTools/PatAlgos/interface/KinematicResolutionRcd.h"
 
 namespace pat {
   namespace helper {
@@ -21,7 +24,7 @@ namespace pat {
       KinResolutionsLoader() {}
 
       /// Constructor from a PSet
-      KinResolutionsLoader(const edm::ParameterSet &iConfig);
+      KinResolutionsLoader(const edm::ParameterSet &iConfig, edm::ConsumesCollector);
 
       /// 'true' if this there is at least one efficiency configured
       bool enabled() const { return !patlabels_.empty(); }
@@ -40,15 +43,15 @@ namespace pat {
       /// Labels of the resolutions in PAT
       std::vector<std::string> patlabels_;
       /// Labels of the KinematicResolutionProvider in the EventSetup
-      std::vector<std::string> eslabels_;
+      std::vector<edm::ESGetToken<KinematicResolutionProvider, KinematicResolutionRcd>> estokens_;
       /// Handles to the EventSetup
-      std::vector<edm::ESHandle<KinematicResolutionProvider> > handles_;
+      std::vector<KinematicResolutionProvider const *> resolutions_;
     };  // class
 
     template <typename T>
     void KinResolutionsLoader::setResolutions(pat::PATObject<T> &obj) const {
       for (size_t i = 0, n = patlabels_.size(); i < n; ++i) {
-        obj.setKinResolution(handles_[i]->getResolution(obj), patlabels_[i]);
+        obj.setKinResolution(resolutions_[i]->getResolution(obj), patlabels_[i]);
       }
     }
 

PhysicsTools/PatAlgos/interface/KinematicResolutionProvider.h

@@ -21,16 +21,10 @@ namespace reco {
 namespace pat {
   class CandKinResolution;
 }
-namespace edm {
-  class ParameterSet;
-  class EventSetup;
-}  // namespace edm
 
 class KinematicResolutionProvider {
 public:
   virtual ~KinematicResolutionProvider() = default;
-  /// everything that needs to be done before the event loop
-  virtual void setup(const edm::EventSetup &iSetup) const {}
   /// get a CandKinResolution object from the service; this
   /// function needs to be implemented by any derived class
   virtual pat::CandKinResolution getResolution(const reco::Candidate &c) const = 0;

PhysicsTools/PatAlgos/interface/VertexingHelper.h

@@ -22,6 +22,7 @@
 #include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/Framework/interface/ESHandle.h"
 #include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
+#include "TrackingTools/Records/interface/TransientTrackRecord.h"
 
 #include "PhysicsTools/UtilAlgos/interface/ParameterAdapter.h"
 namespace reco {
@@ -82,6 +83,7 @@ namespace pat {
       edm::Handle<reco::VertexCollection> vertexHandle_;
       /// use tracks inside candidates
       bool useTracks_;
+      edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> ttToken_;
       edm::ESHandle<TransientTrackBuilder> ttBuilder_;
 
       //--------- Tools for reading vertex associations (playback mode) -----

PhysicsTools/PatAlgos/plugins/PATCompositeCandidateProducer.cc

@@ -72,7 +72,8 @@ PATCompositeCandidateProducer::PATCompositeCandidateProducer(const ParameterSet&
 
   // Resolution configurables
   if (addResolutions_) {
-    resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
+    resolutionLoader_ =
+        pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
 
   // produces vector of particles

PhysicsTools/PatAlgos/plugins/PATElectronProducer.cc

@@ -339,7 +339,8 @@ PATElectronProducer::PATElectronProducer(const edm::ParameterSet& iConfig)
   }
   // resolution configurables
   if (addResolutions_) {
-    resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
+    resolutionLoader_ =
+        pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
   if (addPuppiIsolation_) {
     //puppi

PhysicsTools/PatAlgos/plugins/PATGenericParticleProducer.cc

@@ -149,7 +149,8 @@ PATGenericParticleProducer::PATGenericParticleProducer(const edm::ParameterSet&
   // Resolution configurables
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
   if (addResolutions_) {
-    resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
+    resolutionLoader_ =
+        pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
 
   if (iConfig.exists("vertexing")) {

PhysicsTools/PatAlgos/plugins/PATIsolatedTrackProducer.cc

@@ -85,6 +85,9 @@ namespace pat {
     const edm::EDGetTokenT<edm::ValueMap<reco::DeDxData>> gt2dedxStrip_;
     const edm::EDGetTokenT<edm::ValueMap<reco::DeDxData>> gt2dedxPixel_;
     const edm::EDGetTokenT<reco::DeDxHitInfoAss> gt2dedxHitInfo_;
+    const edm::ESGetToken<HcalChannelQuality, HcalChannelQualityRcd> hcalQToken_;
+    const edm::ESGetToken<EcalChannelStatus, EcalChannelStatusRcd> ecalSToken_;
+    const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> bFieldToken_;
     const bool addPrescaledDeDxTracks_;
     const edm::EDGetTokenT<edm::ValueMap<int>> gt2dedxHitInfoPrescale_;
     const bool usePrecomputedDeDxStrip_;
@@ -128,6 +131,9 @@ pat::PATIsolatedTrackProducer::PATIsolatedTrackProducer(const edm::ParameterSet&
       gt2dedxStrip_(consumes<edm::ValueMap<reco::DeDxData>>(iConfig.getParameter<edm::InputTag>("dEdxDataStrip"))),
       gt2dedxPixel_(consumes<edm::ValueMap<reco::DeDxData>>(iConfig.getParameter<edm::InputTag>("dEdxDataPixel"))),
       gt2dedxHitInfo_(consumes<reco::DeDxHitInfoAss>(iConfig.getParameter<edm::InputTag>("dEdxHitInfo"))),
+      hcalQToken_(esConsumes(edm::ESInputTag("", "withTopo"))),
+      ecalSToken_(esConsumes()),
+      bFieldToken_(esConsumes()),
       addPrescaledDeDxTracks_(iConfig.getParameter<bool>("addPrescaledDeDxTracks")),
       gt2dedxHitInfoPrescale_(addPrescaledDeDxTracks_ ? consumes<edm::ValueMap<int>>(
                                                             iConfig.getParameter<edm::InputTag>("dEdxHitInfoPrescale"))
@@ -223,13 +229,9 @@ void pat::PATIsolatedTrackProducer::produce(edm::Event& iEvent, const edm::Event
     iEvent.getByToken(gt2dedxHitInfoPrescale_, gt2dedxHitInfoPrescale);
   }
 
-  edm::ESHandle<HcalChannelQuality> hcalQ_h;
-  iSetup.get<HcalChannelQualityRcd>().get("withTopo", hcalQ_h);
-  const HcalChannelQuality* hcalQ = hcalQ_h.product();
+  const HcalChannelQuality* hcalQ = &iSetup.getData(hcalQToken_);
 
-  edm::ESHandle<EcalChannelStatus> ecalS_h;
-  iSetup.get<EcalChannelStatusRcd>().get(ecalS_h);
-  const EcalChannelStatus* ecalS = ecalS_h.product();
+  const EcalChannelStatus* ecalS = &iSetup.getData(ecalSToken_);
 
   auto outDeDxC = std::make_unique<reco::DeDxHitInfoCollection>();
   std::vector<int> dEdXass;
@@ -749,9 +751,8 @@ float pat::PATIsolatedTrackProducer::getDeDx(const reco::DeDxHitInfo* hitInfo, b
 TrackDetMatchInfo pat::PATIsolatedTrackProducer::getTrackDetMatchInfo(const edm::Event& iEvent,
                                                                       const edm::EventSetup& iSetup,
                                                                       const reco::Track& track) {
-  edm::ESHandle<MagneticField> bField;
-  iSetup.get<IdealMagneticFieldRecord>().get(bField);
-  FreeTrajectoryState initialState = trajectoryStateTransform::initialFreeState(track, &*bField);
+  auto const& bField = iSetup.getData(bFieldToken_);
+  FreeTrajectoryState initialState = trajectoryStateTransform::initialFreeState(track, &bField);
 
   // can't use the associate() using reco::Track directly, since
   // track->extra() is non-null but segfaults when trying to use it

PhysicsTools/PatAlgos/plugins/PATJetProducer.cc

@@ -184,7 +184,8 @@ PATJetProducer::PATJetProducer(const edm::ParameterSet &iConfig)
   // Resolution configurables
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
   if (addResolutions_) {
-    resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
+    resolutionLoader_ =
+        pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
   if (discriminatorTags_.empty()) {
     addDiscriminators_ = false;

PhysicsTools/PatAlgos/plugins/PATJetSlimmer.cc

@@ -29,7 +29,6 @@ namespace pat {
     ~PATJetSlimmer() override {}
 
     void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override;
-    void beginLuminosityBlock(const edm::LuminosityBlock&, const edm::EventSetup&) final;
 
   private:
     edm::EDGetTokenT<edm::Association<pat::PackedCandidateCollection>> pf2pc_;
@@ -71,15 +70,13 @@ pat::PATJetSlimmer::PATJetSlimmer(const edm::ParameterSet& iConfig)
   produces<std::vector<pat::Jet>>();
 }
 
-void pat::PATJetSlimmer::beginLuminosityBlock(const edm::LuminosityBlock&, const edm::EventSetup& iSetup) {
-  if (modifyJet_)
-    jetModifier_->setEventContent(iSetup);
-}
-
 void pat::PATJetSlimmer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
   using namespace edm;
   using namespace std;
 
+  if (modifyJet_)
+    jetModifier_->setEventContent(iSetup);
+
   Handle<View<pat::Jet>> src;
   iEvent.getByToken(jets_, src);
   Handle<edm::Association<pat::PackedCandidateCollection>> pf2pc;

PhysicsTools/PatAlgos/plugins/PATMETProducer.cc

@@ -25,6 +25,8 @@
 #include "PhysicsTools/PatAlgos/interface/KinResolutionsLoader.h"
 #include "PhysicsTools/PatAlgos/interface/PATUserDataHelper.h"
 #include "RecoMET/METAlgorithms/interface/METSignificance.h"
+#include "CondFormats/DataRecord/interface/JetResolutionRcd.h"
+#include "CondFormats/DataRecord/interface/JetResolutionScaleFactorRcd.h"
 
 #include <memory>
 
@@ -65,10 +67,10 @@ namespace pat {
     edm::EDGetTokenT<edm::View<reco::Candidate>> pfCandToken_;
     std::vector<edm::EDGetTokenT<edm::View<reco::Candidate>>> lepTokens_;
     edm::EDGetTokenT<double> rhoToken_;
-    std::string jetResPtType_;
-    std::string jetResPhiType_;
-    std::string jetSFType_;
     edm::EDGetTokenT<edm::ValueMap<float>> weightsToken_;
+    edm::ESGetToken<JME::JetResolutionObject, JetResolutionRcd> jetResPtToken_;
+    edm::ESGetToken<JME::JetResolutionObject, JetResolutionRcd> jetResPhiToken_;
+    edm::ESGetToken<JME::JetResolutionObject, JetResolutionScaleFactorRcd> jetSFToken_;
 
     const reco::METCovMatrix getMETCovMatrix(const edm::Event& event,
                                              const edm::EventSetup& iSetup,
@@ -98,7 +100,8 @@ PATMETProducer::PATMETProducer(const edm::ParameterSet& iConfig) : useUserData_(
   // Resolution configurables
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
   if (addResolutions_) {
-    resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
+    resolutionLoader_ =
+        pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
 
   // Check to see if the user wants to add user data
@@ -114,15 +117,18 @@ PATMETProducer::PATMETProducer(const edm::ParameterSet& iConfig) : useUserData_(
       weightsToken_ = consumes<edm::ValueMap<float>>(srcWeights);
     metSigAlgo_ = new metsig::METSignificance(iConfig);
     rhoToken_ = consumes<double>(iConfig.getParameter<edm::InputTag>("srcRho"));
-    jetSFType_ = iConfig.getParameter<std::string>("srcJetSF");
-    jetResPtType_ = iConfig.getParameter<std::string>("srcJetResPt");
-    jetResPhiType_ = iConfig.getParameter<std::string>("srcJetResPhi");
     jetToken_ = consumes<edm::View<reco::Jet>>(iConfig.getParameter<edm::InputTag>("srcJets"));
     pfCandToken_ = consumes<edm::View<reco::Candidate>>(iConfig.getParameter<edm::InputTag>("srcPFCands"));
     std::vector<edm::InputTag> srcLeptonsTags = iConfig.getParameter<std::vector<edm::InputTag>>("srcLeptons");
     for (std::vector<edm::InputTag>::const_iterator it = srcLeptonsTags.begin(); it != srcLeptonsTags.end(); it++) {
       lepTokens_.push_back(consumes<edm::View<reco::Candidate>>(*it));
     }
+    auto jetSFType = iConfig.getParameter<std::string>("srcJetSF");
+    auto jetResPtType = iConfig.getParameter<std::string>("srcJetResPt");
+    auto jetResPhiType = iConfig.getParameter<std::string>("srcJetResPhi");
+    jetResPtToken_ = esConsumes(edm::ESInputTag("", jetResPtType));
+    jetResPhiToken_ = esConsumes(edm::ESInputTag("", jetResPhiType));
+    jetSFToken_ = esConsumes(edm::ESInputTag("", jetSFType));
   }
 
   // produces vector of mets
@@ -254,9 +260,9 @@ const reco::METCovMatrix PATMETProducer::getMETCovMatrix(const edm::Event& event
   if (!weightsToken_.isUninitialized())
     event.getByToken(weightsToken_, weights);
 
-  JME::JetResolution resPtObj = JME::JetResolution::get(iSetup, jetResPtType_);
-  JME::JetResolution resPhiObj = JME::JetResolution::get(iSetup, jetResPhiType_);
-  JME::JetResolutionScaleFactor resSFObj = JME::JetResolutionScaleFactor::get(iSetup, jetSFType_);
+  JME::JetResolution resPtObj = iSetup.getData(jetResPtToken_);
+  JME::JetResolution resPhiObj = iSetup.getData(jetResPhiToken_);
+  JME::JetResolutionScaleFactor resSFObj = iSetup.getData(jetSFToken_);
 
   //Compute the covariance matrix and fill it
   const edm::ValueMap<float>* weightsPtr = nullptr;

PhysicsTools/PatAlgos/plugins/PATMuonProducer.cc

@@ -403,7 +403,8 @@ PATMuonProducer::PATMuonProducer(const edm::ParameterSet& iConfig, PATMuonHeavyO
   // resolutions
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
   if (addResolutions_) {
-    resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
+    resolutionLoader_ =
+        pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
   // puppi
   addPuppiIsolation_ = iConfig.getParameter<bool>("addPuppiIsolation");

PhysicsTools/PatAlgos/plugins/PATMuonSlimmer.cc

@@ -28,7 +28,6 @@ namespace pat {
     ~PATMuonSlimmer() override {}
 
     void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override;
-    void beginLuminosityBlock(const edm::LuminosityBlock &, const edm::EventSetup &) final;
 
   private:
     const edm::EDGetTokenT<pat::MuonCollection> src_;
@@ -85,15 +84,13 @@ pat::PATMuonSlimmer::PATMuonSlimmer(const edm::ParameterSet &iConfig)
   }
 }
 
-void pat::PATMuonSlimmer::beginLuminosityBlock(const edm::LuminosityBlock &, const edm::EventSetup &iSetup) {
-  if (modifyMuon_)
-    muonModifier_->setEventContent(iSetup);
-}
-
 void pat::PATMuonSlimmer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) {
   using namespace edm;
   using namespace std;
 
+  if (modifyMuon_)
+    muonModifier_->setEventContent(iSetup);
+
   Handle<pat::MuonCollection> src;
   iEvent.getByToken(src_, src);
 

PhysicsTools/PatAlgos/plugins/PATPFParticleProducer.cc

@@ -96,7 +96,8 @@ PATPFParticleProducer::PATPFParticleProducer(const edm::ParameterSet& iConfig)
   // Resolution configurables
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
   if (addResolutions_) {
-    resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
+    resolutionLoader_ =
+        pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
 
   // Check to see if the user wants to add user data

PhysicsTools/PatAlgos/plugins/PATPhotonProducer.cc

@@ -289,7 +289,8 @@ PATPhotonProducer::PATPhotonProducer(const edm::ParameterSet& iConfig)
   // Resolution configurables
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
   if (addResolutions_) {
-    resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
+    resolutionLoader_ =
+        pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
   // Check to see if the user wants to add user data
   if (useUserData_) {

PhysicsTools/PatAlgos/plugins/PATTauProducer.cc

@@ -273,7 +273,8 @@ PATTauProducer::PATTauProducer(const edm::ParameterSet& iConfig)
   // Resolution configurables
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
   if (addResolutions_) {
-    resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
+    resolutionLoader_ =
+        pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
   // Check to see if the user wants to add user data
   if (useUserData_) {

PhysicsTools/PatAlgos/plugins/PATTauSlimmer.cc

@@ -22,7 +22,6 @@ namespace pat {
     ~PATTauSlimmer() override {}
 
     void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override;
-    void beginLuminosityBlock(const edm::LuminosityBlock &, const edm::EventSetup &) final;
 
   private:
     const edm::EDGetTokenT<edm::View<pat::Tau>> src_;
@@ -54,15 +53,13 @@ pat::PATTauSlimmer::PATTauSlimmer(const edm::ParameterSet &iConfig)
   produces<std::vector<pat::Tau>>();
 }
 
-void pat::PATTauSlimmer::beginLuminosityBlock(const edm::LuminosityBlock &, const edm::EventSetup &iSetup) {
-  if (modifyTau_)
-    tauModifier_->setEventContent(iSetup);
-}
-
 void pat::PATTauSlimmer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) {
   using namespace edm;
   using namespace std;
 
+  if (modifyTau_)
+    tauModifier_->setEventContent(iSetup);
+
   Handle<View<pat::Tau>> src;
   iEvent.getByToken(src_, src);