Use esConsumes for 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

@@ -98,7 +98,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

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);
 

PhysicsTools/PatAlgos/plugins/TauJetCorrFactorsProducer.cc

@@ -30,6 +30,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <unordered_map>
 
 namespace pat {
 
@@ -84,6 +85,9 @@ namespace pat {
     /// jec levels
     typedef std::vector<std::string> vstring;
     vstring levels_;
+
+    using CorrectionToken = edm::ESGetToken<JetCorrectorParametersCollection, JetCorrectionsRecord>;
+    std::unordered_map<std::string, CorrectionToken> payloadToTokens_;
   };
 }  // namespace pat
 
@@ -113,8 +117,13 @@ TauJetCorrFactorsProducer::TauJetCorrFactorsProducer(const edm::ParameterSet& cf
       }
     }
 
-    if (!payloadMapping.decayModes_.empty())
+    if (!payloadMapping.decayModes_.empty()) {
       payloadMappings_.push_back(payloadMapping);
+      payloadToTokens_.emplace(payloadMapping.payload_, CorrectionToken());
+    }
+  }
+  for (auto& payloadToken : payloadToTokens_) {
+    payloadToken.second = esConsumes(edm::ESInputTag("", payloadToken.first));
   }
 
   produces<TauJetCorrFactorsMap>();
@@ -180,10 +189,9 @@ void TauJetCorrFactorsProducer::produce(edm::Event& evt, const edm::EventSetup&
     // retrieve JEC parameters from the DB and build a new corrector,
     // in case it does not exist already for current payload
     if (correctorMapping.find(payload) == correctorMapping.end()) {
-      edm::ESHandle<JetCorrectorParametersCollection> jecParameters;
-      es.get<JetCorrectionsRecord>().get(payload, jecParameters);
+      auto const& jecParameters = es.getData(payloadToTokens_[payload]);
 
-      correctorMapping[payload] = std::make_shared<FactorizedJetCorrector>(params(*jecParameters, levels_));
+      correctorMapping[payload] = std::make_shared<FactorizedJetCorrector>(params(jecParameters, levels_));
     }
     FactorizedJetCorrectorPtr& corrector = correctorMapping[payload];
 

PhysicsTools/PatAlgos/src/KinResolutionsLoader.cc

@@ -5,17 +5,17 @@
 
 using pat::helper::KinResolutionsLoader;
 
-KinResolutionsLoader::KinResolutionsLoader(const edm::ParameterSet &iConfig) {
+KinResolutionsLoader::KinResolutionsLoader(const edm::ParameterSet &iConfig, edm::ConsumesCollector iCollector) {
   // Get the names (sorted)
   patlabels_ = iConfig.getParameterNamesForType<std::string>();
 
   // get the InputTags
-  for (std::vector<std::string>::const_iterator it = patlabels_.begin(), ed = patlabels_.end(); it != ed; ++it) {
-    eslabels_.push_back(iConfig.getParameter<std::string>(*it));
+  estokens_.reserve(patlabels_.size());
+  for (auto const &label : patlabels_) {
+    estokens_.emplace_back(iCollector.esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>(label))));
   }
-
-  // prepare the Handles
-  handles_.resize(patlabels_.size());
+  // prepare the resolutions
+  resolutions_.resize(patlabels_.size());
 
   // 'default' maps to empty string
   for (std::vector<std::string>::iterator it = patlabels_.begin(), ed = patlabels_.end(); it != ed; ++it) {
@@ -26,8 +26,7 @@ KinResolutionsLoader::KinResolutionsLoader(const edm::ParameterSet &iConfig) {
 
 void KinResolutionsLoader::newEvent(const edm::Event &iEvent, const edm::EventSetup &iSetup) {
   for (size_t i = 0, n = patlabels_.size(); i < n; ++i) {
-    iSetup.get<KinematicResolutionRcd>().get(eslabels_[i], handles_[i]);
-    handles_[i]->setup(iSetup);
+    resolutions_[i] = &iSetup.getData(estokens_[i]);
   }
 }
 

PhysicsTools/PatAlgos/src/VertexingHelper.cc

@@ -33,6 +33,9 @@ pat::helper::VertexingHelper::VertexingHelper(const edm::ParameterSet &iConfig,
   } else {
     enabled_ = false;
   }
+  if (!playback_) {
+    ttToken_ = iC.esConsumes(edm::ESInputTag("", "TransientTrackBuilder"));
+  }
 }
 
 void pat::helper::VertexingHelper::newEvent(const edm::Event &iEvent) {
@@ -46,7 +49,7 @@ void pat::helper::VertexingHelper::newEvent(const edm::Event &iEvent) {
 void pat::helper::VertexingHelper::newEvent(const edm::Event &iEvent, const edm::EventSetup &iSetup) {
   newEvent(iEvent);
   if (!playback_)
-    iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", ttBuilder_);
+    ttBuilder_ = iSetup.getHandle(ttToken_);
 }
 
 pat::VertexAssociation pat::helper::VertexingHelper::associate(const reco::Candidate &c) const {