diff --git a/RecoEgamma/EgammaTools/interface/EgammaRegressionContainer.h b/RecoEgamma/EgammaTools/interface/EgammaRegressionContainer.h
index d58feff1ec1c4..f8f9033a8fcae 100644
--- a/RecoEgamma/EgammaTools/interface/EgammaRegressionContainer.h
+++ b/RecoEgamma/EgammaTools/interface/EgammaRegressionContainer.h
@@ -10,7 +10,10 @@
 //  currently e/gamma also can optionally force saturated electrons
 //  to always be in the high et training
 
+#include "CondFormats/DataRecord/interface/GBRDWrapperRcd.h"
+#include "CondFormats/EgammaObjects/interface/GBRForestD.h"
 #include "RecoEgamma/EgammaTools/interface/EgammaBDTOutputTransformer.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
 
 #include <string>
 
@@ -18,12 +21,12 @@ namespace edm {
   class ParameterSet;
   class ParameterSetDescription;
   class EventSetup;
+  class ConsumesCollector;
 }  // namespace edm
-class GBRForestD;
 
 class EgammaRegressionContainer {
 public:
-  EgammaRegressionContainer(const edm::ParameterSet& iConfig);
+  EgammaRegressionContainer(const edm::ParameterSet& iConfig, edm::ConsumesCollector& cc);
   ~EgammaRegressionContainer() {}
 
   static edm::ParameterSetDescription makePSetDescription();
@@ -40,15 +43,16 @@ class EgammaRegressionContainer {
 
   bool forceHighEnergyTrainingIfSaturated_;
   const float lowEtHighEtBoundary_;
-  const std::string ebLowEtForestName_;
-  const std::string ebHighEtForestName_;
-  const std::string eeLowEtForestName_;
-  const std::string eeHighEtForestName_;
-
-  const GBRForestD* ebLowEtForest_;   //not owned
-  const GBRForestD* ebHighEtForest_;  //not owned
-  const GBRForestD* eeLowEtForest_;   //not owned
-  const GBRForestD* eeHighEtForest_;  //not owned
+
+  const edm::ESGetToken<GBRForestD, GBRDWrapperRcd> ebLowEtForestToken_;
+  const edm::ESGetToken<GBRForestD, GBRDWrapperRcd> ebHighEtForestToken_;
+  const edm::ESGetToken<GBRForestD, GBRDWrapperRcd> eeLowEtForestToken_;
+  const edm::ESGetToken<GBRForestD, GBRDWrapperRcd> eeHighEtForestToken_;
+
+  const GBRForestD* ebLowEtForest_ = nullptr;   //not owned
+  const GBRForestD* ebHighEtForest_ = nullptr;  //not owned
+  const GBRForestD* eeLowEtForest_ = nullptr;   //not owned
+  const GBRForestD* eeHighEtForest_ = nullptr;  //not owned
 };
 
 #endif
diff --git a/RecoEgamma/EgammaTools/interface/EpCombinationTool.h b/RecoEgamma/EgammaTools/interface/EpCombinationTool.h
index 123bfdf8aa099..52a9c6b1c64a7 100644
--- a/RecoEgamma/EgammaTools/interface/EpCombinationTool.h
+++ b/RecoEgamma/EgammaTools/interface/EpCombinationTool.h
@@ -11,6 +11,7 @@ namespace edm {
   class ParameterSet;
   class ParameterSetDescription;
   class EventSetup;
+  class ConsumesCollector;
 }  // namespace edm
 namespace reco {
   class GsfElectron;
@@ -18,7 +19,7 @@ namespace reco {
 
 class EpCombinationTool {
 public:
-  EpCombinationTool(const edm::ParameterSet& iConfig);
+  EpCombinationTool(const edm::ParameterSet& iConfig, edm::ConsumesCollector&& cc);
   ~EpCombinationTool() {}
 
   static edm::ParameterSetDescription makePSetDescription();
diff --git a/RecoEgamma/EgammaTools/plugins/CalibratedElectronProducers.cc b/RecoEgamma/EgammaTools/plugins/CalibratedElectronProducers.cc
index f251c32d2da23..72160c50af80d 100644
--- a/RecoEgamma/EgammaTools/plugins/CalibratedElectronProducers.cc
+++ b/RecoEgamma/EgammaTools/plugins/CalibratedElectronProducers.cc
@@ -16,6 +16,7 @@
 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
 #include "FWCore/Utilities/interface/EDGetToken.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 
 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
 #include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
@@ -86,7 +87,7 @@ namespace {
 template <typename T>
 CalibratedElectronProducerT<T>::CalibratedElectronProducerT(const edm::ParameterSet& conf)
     : electronToken_(consumes<edm::View<T>>(conf.getParameter<edm::InputTag>("src"))),
-      epCombinationTool_(conf.getParameter<edm::ParameterSet>("epCombConfig")),
+      epCombinationTool_{conf.getParameter<edm::ParameterSet>("epCombConfig"), consumesCollector()},
       energyCorrector_(epCombinationTool_, conf.getParameter<std::string>("correctionFile")),
       recHitCollectionEBToken_(consumes<EcalRecHitCollection>(conf.getParameter<edm::InputTag>("recHitCollectionEB"))),
       recHitCollectionEEToken_(consumes<EcalRecHitCollection>(conf.getParameter<edm::InputTag>("recHitCollectionEE"))),
diff --git a/RecoEgamma/EgammaTools/plugins/EG8XObjectUpdateModifier.cc b/RecoEgamma/EgammaTools/plugins/EG8XObjectUpdateModifier.cc
index 0e398840e7a21..4be824344dc90 100644
--- a/RecoEgamma/EgammaTools/plugins/EG8XObjectUpdateModifier.cc
+++ b/RecoEgamma/EgammaTools/plugins/EG8XObjectUpdateModifier.cc
@@ -34,44 +34,46 @@ class EG8XObjectUpdateModifier : public ModifyObjectValueBase {
 private:
   std::pair<int, bool> getSaturationInfo(const reco::SuperCluster& superClus) const;
 
-  edm::ESHandle<CaloTopology> caloTopoHandle_;
-  edm::Handle<EcalRecHitCollection> ecalRecHitsEBHandle_;
-  edm::Handle<EcalRecHitCollection> ecalRecHitsEEHandle_;
+  CaloTopology const* caloTopo_ = nullptr;
+  EcalRecHitCollection const* ecalRecHitsEB_ = nullptr;
+  EcalRecHitCollection const* ecalRecHitsEE_ = nullptr;
+
+  edm::ESGetToken<CaloTopology, CaloTopologyRecord> caloTopoToken_;
   edm::EDGetTokenT<EcalRecHitCollection> ecalRecHitsEBToken_;
   edm::EDGetTokenT<EcalRecHitCollection> ecalRecHitsEEToken_;
 };
 
 EG8XObjectUpdateModifier::EG8XObjectUpdateModifier(const edm::ParameterSet& conf, edm::ConsumesCollector& cc)
     : ModifyObjectValueBase(conf),
-      ecalRecHitsEBToken_(cc.consumes<EcalRecHitCollection>(conf.getParameter<edm::InputTag>("ecalRecHitsEB"))),
-      ecalRecHitsEEToken_(cc.consumes<EcalRecHitCollection>(conf.getParameter<edm::InputTag>("ecalRecHitsEE"))) {}
+      caloTopoToken_{cc.esConsumes()},
+      ecalRecHitsEBToken_(cc.consumes(conf.getParameter<edm::InputTag>("ecalRecHitsEB"))),
+      ecalRecHitsEEToken_(cc.consumes(conf.getParameter<edm::InputTag>("ecalRecHitsEE"))) {}
 
 void EG8XObjectUpdateModifier::setEvent(const edm::Event& iEvent) {
-  iEvent.getByToken(ecalRecHitsEBToken_, ecalRecHitsEBHandle_);
-  iEvent.getByToken(ecalRecHitsEEToken_, ecalRecHitsEEHandle_);
+  ecalRecHitsEB_ = &iEvent.get(ecalRecHitsEBToken_);
+  ecalRecHitsEE_ = &iEvent.get(ecalRecHitsEEToken_);
 }
 
 void EG8XObjectUpdateModifier::setEventContent(const edm::EventSetup& iSetup) {
-  iSetup.get<CaloTopologyRecord>().get(caloTopoHandle_);
+  caloTopo_ = &iSetup.getData<CaloTopology, CaloTopologyRecord>(caloTopoToken_);
 }
 
 void EG8XObjectUpdateModifier::modifyObject(reco::GsfElectron& ele) const {
   const reco::CaloCluster& seedClus = *(ele.superCluster()->seed());
-  const EcalRecHitCollection* ecalRecHits = ele.isEB() ? &*ecalRecHitsEBHandle_ : &*ecalRecHitsEEHandle_;
-  const auto* caloTopo = caloTopoHandle_.product();
+  const EcalRecHitCollection* ecalRecHits = ele.isEB() ? ecalRecHitsEB_ : ecalRecHitsEE_;
 
   auto full5x5ShowerShapes = ele.full5x5_showerShape();
-  full5x5ShowerShapes.e2x5Left = noZS::EcalClusterTools::e2x5Left(seedClus, ecalRecHits, caloTopo);
-  full5x5ShowerShapes.e2x5Right = noZS::EcalClusterTools::e2x5Right(seedClus, ecalRecHits, caloTopo);
-  full5x5ShowerShapes.e2x5Top = noZS::EcalClusterTools::e2x5Top(seedClus, ecalRecHits, caloTopo);
-  full5x5ShowerShapes.e2x5Bottom = noZS::EcalClusterTools::e2x5Bottom(seedClus, ecalRecHits, caloTopo);
+  full5x5ShowerShapes.e2x5Left = noZS::EcalClusterTools::e2x5Left(seedClus, ecalRecHits, caloTopo_);
+  full5x5ShowerShapes.e2x5Right = noZS::EcalClusterTools::e2x5Right(seedClus, ecalRecHits, caloTopo_);
+  full5x5ShowerShapes.e2x5Top = noZS::EcalClusterTools::e2x5Top(seedClus, ecalRecHits, caloTopo_);
+  full5x5ShowerShapes.e2x5Bottom = noZS::EcalClusterTools::e2x5Bottom(seedClus, ecalRecHits, caloTopo_);
   ele.full5x5_setShowerShape(full5x5ShowerShapes);
 
   auto showerShapes = ele.showerShape();
-  showerShapes.e2x5Left = EcalClusterTools::e2x5Left(seedClus, ecalRecHits, caloTopo);
-  showerShapes.e2x5Right = EcalClusterTools::e2x5Right(seedClus, ecalRecHits, caloTopo);
-  showerShapes.e2x5Top = EcalClusterTools::e2x5Top(seedClus, ecalRecHits, caloTopo);
-  showerShapes.e2x5Bottom = EcalClusterTools::e2x5Bottom(seedClus, ecalRecHits, caloTopo);
+  showerShapes.e2x5Left = EcalClusterTools::e2x5Left(seedClus, ecalRecHits, caloTopo_);
+  showerShapes.e2x5Right = EcalClusterTools::e2x5Right(seedClus, ecalRecHits, caloTopo_);
+  showerShapes.e2x5Top = EcalClusterTools::e2x5Top(seedClus, ecalRecHits, caloTopo_);
+  showerShapes.e2x5Bottom = EcalClusterTools::e2x5Bottom(seedClus, ecalRecHits, caloTopo_);
   ele.setShowerShape(showerShapes);
 
   reco::GsfElectron::SaturationInfo eleSatInfo;
@@ -91,7 +93,7 @@ void EG8XObjectUpdateModifier::modifyObject(reco::Photon& pho) const {
 
 std::pair<int, bool> EG8XObjectUpdateModifier::getSaturationInfo(const reco::SuperCluster& superClus) const {
   bool isEB = superClus.seed()->seed().subdetId() == EcalBarrel;
-  const auto& ecalRecHits = isEB ? *ecalRecHitsEBHandle_ : *ecalRecHitsEEHandle_;
+  const auto& ecalRecHits = isEB ? *ecalRecHitsEB_ : *ecalRecHitsEE_;
 
   int nrSatCrys = 0;
   bool seedSaturated = false;
diff --git a/RecoEgamma/EgammaTools/plugins/EG9X105XObjectUpdateModifier.cc b/RecoEgamma/EgammaTools/plugins/EG9X105XObjectUpdateModifier.cc
index f6a1ad7a1cb4c..d03dc704390aa 100644
--- a/RecoEgamma/EgammaTools/plugins/EG9X105XObjectUpdateModifier.cc
+++ b/RecoEgamma/EgammaTools/plugins/EG9X105XObjectUpdateModifier.cc
@@ -39,7 +39,6 @@ class EG9X105XObjectUpdateModifier : public ModifyObjectValueBase {
   ~EG9X105XObjectUpdateModifier() override {}
 
   void setEvent(const edm::Event&) final;
-  void setEventContent(const edm::EventSetup&) final;
 
   void modifyObject(reco::GsfElectron& ele) const final;
   void modifyObject(reco::Photon& pho) const final;
@@ -120,8 +119,6 @@ void EG9X105XObjectUpdateModifier::setEvent(const edm::Event& iEvent) {
     phoChargedHadPFPVIso_.setHandle(iEvent);
 }
 
-void EG9X105XObjectUpdateModifier::setEventContent(const edm::EventSetup& iSetup) {}
-
 void EG9X105XObjectUpdateModifier::modifyObject(reco::GsfElectron& ele) const {
   edm::Ptr<reco::GsfElectron> ptrForVM = getPtrForValueMap(ele, eleCollVMsAreKeyedTo_.handle());
   if (ptrForVM.isNull()) {
diff --git a/RecoEgamma/EgammaTools/plugins/EGEtScaleSysModifier.cc b/RecoEgamma/EgammaTools/plugins/EGEtScaleSysModifier.cc
index 3de3de8a29aa4..7acf59a8751b5 100644
--- a/RecoEgamma/EgammaTools/plugins/EGEtScaleSysModifier.cc
+++ b/RecoEgamma/EgammaTools/plugins/EGEtScaleSysModifier.cc
@@ -86,8 +86,8 @@ class EGEtScaleSysModifier : public ModifyObjectValueBase {
   std::unique_ptr<UncertFuncBase> uncertFunc_;
 };
 
-EGEtScaleSysModifier::EGEtScaleSysModifier(const edm::ParameterSet& conf, edm::ConsumesCollector&)
-    : ModifyObjectValueBase(conf), epCombTool_(conf.getParameter<edm::ParameterSet>("epCombConfig")) {
+EGEtScaleSysModifier::EGEtScaleSysModifier(const edm::ParameterSet& conf, edm::ConsumesCollector& cc)
+    : ModifyObjectValueBase(conf), epCombTool_{conf.getParameter<edm::ParameterSet>("epCombConfig"), std::move(cc)} {
   const edm::ParameterSet funcPSet = conf.getParameter<edm::ParameterSet>("uncertFunc");
   const std::string& funcName = funcPSet.getParameter<std::string>("name");
   if (funcName == "UncertFuncV1") {
diff --git a/RecoEgamma/EgammaTools/plugins/EGFull5x5ShowerShapeModifier.cc b/RecoEgamma/EgammaTools/plugins/EGFull5x5ShowerShapeModifier.cc
index 8704c54c190c3..2bda92161a427 100644
--- a/RecoEgamma/EgammaTools/plugins/EGFull5x5ShowerShapeModifier.cc
+++ b/RecoEgamma/EgammaTools/plugins/EGFull5x5ShowerShapeModifier.cc
@@ -53,7 +53,6 @@ class EGFull5x5ShowerShapeModifierFromValueMaps : public ModifyObjectValueBase {
   EGFull5x5ShowerShapeModifierFromValueMaps(const edm::ParameterSet& conf, edm::ConsumesCollector& cc);
 
   void setEvent(const edm::Event&) final;
-  void setEventContent(const edm::EventSetup&) final;
 
   void modifyObject(pat::Electron&) const final;
   void modifyObject(pat::Photon&) const final;
@@ -192,8 +191,6 @@ void EGFull5x5ShowerShapeModifierFromValueMaps::setEvent(const edm::Event& evt)
   get_product(evt, ph_conf.tok_hcalDepth2OverEcalBc, pho_vmaps);
 }
 
-void EGFull5x5ShowerShapeModifierFromValueMaps::setEventContent(const edm::EventSetup& evs) {}
-
 namespace {
   template <typename T, typename U, typename V>
   inline void assignValue(const T& ptr, const U& tok, const V& map, float& value) {
diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierHelpers.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierHelpers.cc
index 1a7f8f68dc2e2..0eb561f3ba3b4 100644
--- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierHelpers.cc
+++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierHelpers.cc
@@ -1,12 +1,24 @@
 #include "RecoEgamma/EgammaTools/plugins/EGRegressionModifierHelpers.h"
 
-std::vector<const GBRForestD*> retrieveGBRForests(edm::EventSetup const& evs, std::vector<std::string> const& names) {
+EGRegressionModifierCondTokens::EGRegressionModifierCondTokens(edm::ParameterSet const& config,
+                                                               std::string const& regressionKey,
+                                                               std::string const& uncertaintyKey,
+                                                               edm::ConsumesCollector& cc) {
+  for (auto const& name : config.getParameter<std::vector<std::string>>(regressionKey)) {
+    mean.push_back(cc.esConsumes<GBRForestD, GBRDWrapperRcd>(edm::ESInputTag("", name)));
+  }
+  for (auto const& name : config.getParameter<std::vector<std::string>>(uncertaintyKey)) {
+    sigma.push_back(cc.esConsumes<GBRForestD, GBRDWrapperRcd>(edm::ESInputTag("", name)));
+  }
+}
+
+std::vector<const GBRForestD*> retrieveGBRForests(
+    edm::EventSetup const& evs, std::vector<edm::ESGetToken<GBRForestD, GBRDWrapperRcd>> const& tokens) {
   std::vector<const GBRForestD*> items;
-  edm::ESHandle<GBRForestD> handle;
 
-  for (auto const& name : names) {
-    evs.get<GBRDWrapperRcd>().get(name, handle);
-    items.push_back(handle.product());
+  items.reserve(tokens.size());
+  for (auto const& token : tokens) {
+    items.push_back(&evs.getData(token));
   }
 
   return items;
diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierHelpers.h b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierHelpers.h
index d148202aa1225..5deb256ff1d90 100644
--- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierHelpers.h
+++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierHelpers.h
@@ -3,12 +3,23 @@
 
 #include "CondFormats/DataRecord/interface/GBRDWrapperRcd.h"
 #include "CondFormats/EgammaObjects/interface/GBRForestD.h"
-#include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
-#include <string>
 #include <vector>
 
-std::vector<const GBRForestD*> retrieveGBRForests(edm::EventSetup const& evs, std::vector<std::string> const& names);
+struct EGRegressionModifierCondTokens {
+  EGRegressionModifierCondTokens(edm::ParameterSet const& config,
+                                 std::string const& regressionKey,
+                                 std::string const& uncertaintyKey,
+                                 edm::ConsumesCollector& cc);
+  std::vector<edm::ESGetToken<GBRForestD, GBRDWrapperRcd>> mean;
+  std::vector<edm::ESGetToken<GBRForestD, GBRDWrapperRcd>> sigma;
+};
+
+std::vector<const GBRForestD*> retrieveGBRForests(
+    edm::EventSetup const& evs, std::vector<edm::ESGetToken<GBRForestD, GBRDWrapperRcd>> const& tokens);
 
 #endif
diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV1.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV1.cc
index 5e619d826298f..e474d3b0df893 100644
--- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV1.cc
+++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV1.cc
@@ -30,15 +30,10 @@ class EGRegressionModifierV1 : public ModifyObjectValueBase {
   void modifyObject(pat::Photon& pho) const final { modifyObject(static_cast<reco::Photon&>(pho)); }
 
 private:
-  struct CondNames {
-    std::vector<std::string> mean50ns;
-    std::vector<std::string> sigma50ns;
-    std::vector<std::string> mean25ns;
-    std::vector<std::string> sigma25ns;
-  };
-
-  CondNames eleCondNames_;
-  CondNames phoCondNames_;
+  EGRegressionModifierCondTokens eleCond50nsTokens_;
+  EGRegressionModifierCondTokens phoCond50nsTokens_;
+  EGRegressionModifierCondTokens eleCond25nsTokens_;
+  EGRegressionModifierCondTokens phoCond25nsTokens_;
 
   std::string condNamesWeight50ns_;
   std::string condNamesWeight25ns_;
@@ -65,6 +60,14 @@ DEFINE_EDM_PLUGIN(ModifyObjectValueFactory, EGRegressionModifierV1, "EGRegressio
 
 EGRegressionModifierV1::EGRegressionModifierV1(const edm::ParameterSet& conf, edm::ConsumesCollector& cc)
     : ModifyObjectValueBase(conf),
+      eleCond50nsTokens_{
+          conf.getParameter<edm::ParameterSet>("electron_config"), "regressionKey_50ns", "uncertaintyKey_50ns", cc},
+      phoCond50nsTokens_{
+          conf.getParameter<edm::ParameterSet>("photon_config"), "regressionKey_50ns", "uncertaintyKey_50ns", cc},
+      eleCond25nsTokens_{
+          conf.getParameter<edm::ParameterSet>("electron_config"), "regressionKey_25ns", "uncertaintyKey_25ns", cc},
+      phoCond25nsTokens_{
+          conf.getParameter<edm::ParameterSet>("photon_config"), "regressionKey_25ns", "uncertaintyKey_25ns", cc},
       autoDetectBunchSpacing_(conf.getParameter<bool>("autoDetectBunchSpacing")),
       bunchspacing_(autoDetectBunchSpacing_ ? 450 : conf.getParameter<int>("manualBunchSpacing")),
       rhoToken_(cc.consumes<double>(conf.getParameter<edm::InputTag>("rhoCollection"))),
@@ -73,19 +76,9 @@ EGRegressionModifierV1::EGRegressionModifierV1(const edm::ParameterSet& conf, ed
   if (autoDetectBunchSpacing_)
     bunchSpacingToken_ = cc.consumes<unsigned int>(conf.getParameter<edm::InputTag>("bunchSpacingTag"));
 
-  const edm::ParameterSet& electrons = conf.getParameter<edm::ParameterSet>("electron_config");
-  eleCondNames_ = CondNames{.mean50ns = electrons.getParameter<std::vector<std::string>>("regressionKey_50ns"),
-                            .sigma50ns = electrons.getParameter<std::vector<std::string>>("uncertaintyKey_50ns"),
-                            .mean25ns = electrons.getParameter<std::vector<std::string>>("regressionKey_25ns"),
-                            .sigma25ns = electrons.getParameter<std::vector<std::string>>("uncertaintyKey_25ns")};
+  auto const& electrons = conf.getParameter<edm::ParameterSet>("electron_config");
   condNamesWeight50ns_ = electrons.getParameter<std::string>("combinationKey_50ns");
   condNamesWeight25ns_ = electrons.getParameter<std::string>("combinationKey_25ns");
-
-  const edm::ParameterSet& photons = conf.getParameter<edm::ParameterSet>("photon_config");
-  phoCondNames_ = CondNames{.mean50ns = photons.getParameter<std::vector<std::string>>("regressionKey_50ns"),
-                            .sigma50ns = photons.getParameter<std::vector<std::string>>("uncertaintyKey_50ns"),
-                            .mean25ns = photons.getParameter<std::vector<std::string>>("regressionKey_25ns"),
-                            .sigma25ns = photons.getParameter<std::vector<std::string>>("uncertaintyKey_25ns")};
 }
 
 void EGRegressionModifierV1::setEvent(const edm::Event& evt) {
@@ -106,11 +99,13 @@ void EGRegressionModifierV1::setEvent(const edm::Event& evt) {
 void EGRegressionModifierV1::setEventContent(const edm::EventSetup& evs) {
   evs.get<CaloGeometryRecord>().get(caloGeomH_);
 
-  phoForestsMean_ = retrieveGBRForests(evs, (bunchspacing_ == 25) ? phoCondNames_.mean25ns : phoCondNames_.mean50ns);
-  phoForestsSigma_ = retrieveGBRForests(evs, (bunchspacing_ == 25) ? phoCondNames_.sigma25ns : phoCondNames_.sigma50ns);
+  phoForestsMean_ = retrieveGBRForests(evs, (bunchspacing_ == 25) ? phoCond25nsTokens_.mean : phoCond50nsTokens_.mean);
+  phoForestsSigma_ =
+      retrieveGBRForests(evs, (bunchspacing_ == 25) ? phoCond25nsTokens_.sigma : phoCond50nsTokens_.sigma);
 
-  eleForestsMean_ = retrieveGBRForests(evs, (bunchspacing_ == 25) ? eleCondNames_.mean25ns : eleCondNames_.mean50ns);
-  eleForestsSigma_ = retrieveGBRForests(evs, (bunchspacing_ == 25) ? eleCondNames_.sigma25ns : eleCondNames_.sigma50ns);
+  eleForestsMean_ = retrieveGBRForests(evs, (bunchspacing_ == 25) ? eleCond25nsTokens_.mean : eleCond50nsTokens_.mean);
+  eleForestsSigma_ =
+      retrieveGBRForests(evs, (bunchspacing_ == 25) ? eleCond25nsTokens_.sigma : eleCond50nsTokens_.sigma);
 
   edm::ESHandle<GBRForest> forestEH;
   const std::string ep_condnames_weight = (bunchspacing_ == 25) ? condNamesWeight25ns_ : condNamesWeight50ns_;
diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV2.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV2.cc
index b7b3ec8125f3b..175c84cbab4e0 100644
--- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV2.cc
+++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV2.cc
@@ -28,13 +28,8 @@ class EGRegressionModifierV2 : public ModifyObjectValueBase {
   void modifyObject(pat::Photon& pho) const final { modifyObject(static_cast<reco::Photon&>(pho)); }
 
 private:
-  struct CondNames {
-    std::vector<std::string> mean;
-    std::vector<std::string> sigma;
-  };
-
-  CondNames eleCondNames_;
-  CondNames phoCondNames_;
+  EGRegressionModifierCondTokens eleCondTokens_;
+  EGRegressionModifierCondTokens phoCondTokens_;
 
   float rhoValue_;
   edm::EDGetTokenT<double> rhoToken_;
@@ -58,6 +53,9 @@ DEFINE_EDM_PLUGIN(ModifyObjectValueFactory, EGRegressionModifierV2, "EGRegressio
 
 EGRegressionModifierV2::EGRegressionModifierV2(const edm::ParameterSet& conf, edm::ConsumesCollector& cc)
     : ModifyObjectValueBase(conf),
+      eleCondTokens_{conf.getParameter<edm::ParameterSet>("electron_config"), "regressionKey", "uncertaintyKey", cc},
+      phoCondTokens_{conf.getParameter<edm::ParameterSet>("photon_config"), "regressionKey", "uncertaintyKey", cc},
+
       rhoToken_(cc.consumes<double>(conf.getParameter<edm::InputTag>("rhoCollection"))),
       lowEnergyEcalOnlyThr_(conf.getParameter<double>("lowEnergy_ECALonlyThr")),
       lowEnergyEcalTrackThr_(conf.getParameter<double>("lowEnergy_ECALTRKThr")),
@@ -66,23 +64,11 @@ EGRegressionModifierV2::EGRegressionModifierV2(const edm::ParameterSet& conf, ed
       epDiffSigEcalTrackThr_(conf.getParameter<double>("epDiffSig_ECALTRKThr")),
       epSigEcalTrackThr_(conf.getParameter<double>("epSig_ECALTRKThr")),
       forceHighEnergyEcalTrainingIfSaturated_(conf.getParameter<bool>("forceHighEnergyEcalTrainingIfSaturated")) {
-  const edm::ParameterSet& electrons = conf.getParameter<edm::ParameterSet>("electron_config");
-  eleCondNames_ = CondNames{
-      .mean = electrons.getParameter<std::vector<std::string> >("regressionKey"),
-      .sigma = electrons.getParameter<std::vector<std::string> >("uncertaintyKey"),
-  };
-
-  unsigned int encor = eleCondNames_.mean.size();
+  unsigned int encor = eleCondTokens_.mean.size();
   eleForestsMean_.reserve(2 * encor);
   eleForestsSigma_.reserve(2 * encor);
 
-  const edm::ParameterSet& photons = conf.getParameter<edm::ParameterSet>("photon_config");
-  phoCondNames_ = CondNames{
-      .mean = photons.getParameter<std::vector<std::string> >("regressionKey"),
-      .sigma = photons.getParameter<std::vector<std::string> >("uncertaintyKey"),
-  };
-
-  unsigned int ncor = phoCondNames_.mean.size();
+  unsigned int ncor = phoCondTokens_.mean.size();
   phoForestsMean_.reserve(ncor);
   phoForestsSigma_.reserve(ncor);
 }
@@ -94,11 +80,11 @@ void EGRegressionModifierV2::setEvent(const edm::Event& evt) {
 }
 
 void EGRegressionModifierV2::setEventContent(const edm::EventSetup& evs) {
-  phoForestsMean_ = retrieveGBRForests(evs, phoCondNames_.mean);
-  phoForestsSigma_ = retrieveGBRForests(evs, phoCondNames_.sigma);
+  phoForestsMean_ = retrieveGBRForests(evs, phoCondTokens_.mean);
+  phoForestsSigma_ = retrieveGBRForests(evs, phoCondTokens_.sigma);
 
-  eleForestsMean_ = retrieveGBRForests(evs, eleCondNames_.mean);
-  eleForestsSigma_ = retrieveGBRForests(evs, eleCondNames_.sigma);
+  eleForestsMean_ = retrieveGBRForests(evs, eleCondTokens_.mean);
+  eleForestsSigma_ = retrieveGBRForests(evs, eleCondTokens_.sigma);
 
   evs.get<CaloGeometryRecord>().get(caloGeometry_);
 }
diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV3.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV3.cc
index 0a5715473bb47..d0cd1f96edf3f 100644
--- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV3.cc
+++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierV3.cc
@@ -22,7 +22,7 @@
 class EGRegressionModifierV3 : public ModifyObjectValueBase {
 public:
   struct EleRegs {
-    EleRegs(const edm::ParameterSet& iConfig);
+    EleRegs(const edm::ParameterSet& iConfig, edm::ConsumesCollector& cc);
     void setEventContent(const edm::EventSetup& iSetup);
     EgammaRegressionContainer ecalOnlyMean;
     EgammaRegressionContainer ecalOnlySigma;
@@ -30,7 +30,7 @@ class EGRegressionModifierV3 : public ModifyObjectValueBase {
   };
 
   struct PhoRegs {
-    PhoRegs(const edm::ParameterSet& iConfig);
+    PhoRegs(const edm::ParameterSet& iConfig, edm::ConsumesCollector& cc);
     void setEventContent(const edm::EventSetup& iSetup);
     EgammaRegressionContainer ecalOnlyMean;
     EgammaRegressionContainer ecalOnlySigma;
@@ -76,10 +76,10 @@ EGRegressionModifierV3::EGRegressionModifierV3(const edm::ParameterSet& conf, ed
       maxRawEnergyForLowPtEBSigma_(conf.getParameter<double>("maxRawEnergyForLowPtEBSigma")),
       maxRawEnergyForLowPtEESigma_(conf.getParameter<double>("maxRawEnergyForLowPtEESigma")) {
   if (conf.exists("eleRegs")) {
-    eleRegs_ = std::make_unique<EleRegs>(conf.getParameter<edm::ParameterSet>("eleRegs"));
+    eleRegs_ = std::make_unique<EleRegs>(conf.getParameter<edm::ParameterSet>("eleRegs"), cc);
   }
   if (conf.exists("phoRegs")) {
-    phoRegs_ = std::make_unique<PhoRegs>(conf.getParameter<edm::ParameterSet>("phoRegs"));
+    phoRegs_ = std::make_unique<PhoRegs>(conf.getParameter<edm::ParameterSet>("phoRegs"), cc);
   }
 }
 
@@ -358,10 +358,10 @@ void EGRegressionModifierV3::getSeedCrysCoord(const reco::CaloCluster& clus, int
   }
 }
 
-EGRegressionModifierV3::EleRegs::EleRegs(const edm::ParameterSet& iConfig)
-    : ecalOnlyMean(iConfig.getParameter<edm::ParameterSet>("ecalOnlyMean")),
-      ecalOnlySigma(iConfig.getParameter<edm::ParameterSet>("ecalOnlySigma")),
-      epComb(iConfig.getParameter<edm::ParameterSet>("epComb")) {}
+EGRegressionModifierV3::EleRegs::EleRegs(const edm::ParameterSet& iConfig, edm::ConsumesCollector& cc)
+    : ecalOnlyMean(iConfig.getParameter<edm::ParameterSet>("ecalOnlyMean"), cc),
+      ecalOnlySigma(iConfig.getParameter<edm::ParameterSet>("ecalOnlySigma"), cc),
+      epComb(iConfig.getParameter<edm::ParameterSet>("epComb"), std::move(cc)) {}
 
 void EGRegressionModifierV3::EleRegs::setEventContent(const edm::EventSetup& iSetup) {
   ecalOnlyMean.setEventContent(iSetup);
@@ -369,9 +369,9 @@ void EGRegressionModifierV3::EleRegs::setEventContent(const edm::EventSetup& iSe
   epComb.setEventContent(iSetup);
 }
 
-EGRegressionModifierV3::PhoRegs::PhoRegs(const edm::ParameterSet& iConfig)
-    : ecalOnlyMean(iConfig.getParameter<edm::ParameterSet>("ecalOnlyMean")),
-      ecalOnlySigma(iConfig.getParameter<edm::ParameterSet>("ecalOnlySigma")) {}
+EGRegressionModifierV3::PhoRegs::PhoRegs(const edm::ParameterSet& iConfig, edm::ConsumesCollector& cc)
+    : ecalOnlyMean(iConfig.getParameter<edm::ParameterSet>("ecalOnlyMean"), cc),
+      ecalOnlySigma(iConfig.getParameter<edm::ParameterSet>("ecalOnlySigma"), cc) {}
 
 void EGRegressionModifierV3::PhoRegs::setEventContent(const edm::EventSetup& iSetup) {
   ecalOnlyMean.setEventContent(iSetup);
diff --git a/RecoEgamma/EgammaTools/python/calibratedEgammas_cff.py b/RecoEgamma/EgammaTools/python/calibratedEgammas_cff.py
index 5974043067748..e7ef2cbc63a6f 100644
--- a/RecoEgamma/EgammaTools/python/calibratedEgammas_cff.py
+++ b/RecoEgamma/EgammaTools/python/calibratedEgammas_cff.py
@@ -38,10 +38,10 @@
         rangeMaxHighEt = cms.double(3.0),
         lowEtHighEtBoundary = cms.double(50.),
         forceHighEnergyTrainingIfSaturated = cms.bool(False),
-        ebLowEtForestName = cms.string('electron_eb_ECALTRK_lowpt'),
-        ebHighEtForestName = cms.string('electron_eb_ECALTRK'),
-        eeLowEtForestName = cms.string('electron_ee_ECALTRK_lowpt'),
-        eeHighEtForestName = cms.string('electron_ee_ECALTRK')
+        ebLowEtForestName = cms.ESInputTag('', 'electron_eb_ECALTRK_lowpt'),
+        ebHighEtForestName = cms.ESInputTag('', 'electron_eb_ECALTRK'),
+        eeLowEtForestName = cms.ESInputTag('', 'electron_ee_ECALTRK_lowpt'),
+        eeHighEtForestName = cms.ESInputTag('', 'electron_ee_ECALTRK')
         ),
     ecalTrkRegressionUncertConfig = cms.PSet(
         rangeMinLowEt = cms.double(0.0002),
@@ -50,10 +50,10 @@
         rangeMaxHighEt = cms.double(0.5),
         lowEtHighEtBoundary = cms.double(50.),  
         forceHighEnergyTrainingIfSaturated = cms.bool(False),
-        ebLowEtForestName = cms.string('electron_eb_ECALTRK_lowpt_var'),
-        ebHighEtForestName = cms.string('electron_eb_ECALTRK_var'),
-        eeLowEtForestName = cms.string('electron_ee_ECALTRK_lowpt_var'),
-        eeHighEtForestName = cms.string('electron_ee_ECALTRK_var')
+        ebLowEtForestName = cms.ESInputTag('', 'electron_eb_ECALTRK_lowpt_var'),
+        ebHighEtForestName = cms.ESInputTag('', 'electron_eb_ECALTRK_var'),
+        eeLowEtForestName = cms.ESInputTag('', 'electron_ee_ECALTRK_lowpt_var'),
+        eeHighEtForestName = cms.ESInputTag('', 'electron_ee_ECALTRK_var')
         ),
     maxEcalEnergyForComb=cms.double(200.),
     minEOverPForComb=cms.double(0.025),
diff --git a/RecoEgamma/EgammaTools/python/regressionModifier_cfi.py b/RecoEgamma/EgammaTools/python/regressionModifier_cfi.py
index f709ac008c437..ebeafeacd0f41 100644
--- a/RecoEgamma/EgammaTools/python/regressionModifier_cfi.py
+++ b/RecoEgamma/EgammaTools/python/regressionModifier_cfi.py
@@ -14,10 +14,10 @@
             rangeMaxHighEt = cms.double(3.0),
             forceHighEnergyTrainingIfSaturated = cms.bool(True),
             lowEtHighEtBoundary = cms.double(999999.),
-            ebLowEtForestName = cms.string("electron_eb_ecalOnly_1To300_0p2To2_mean"),
-            ebHighEtForestName = cms.string("electron_eb_ECALonly"),
-            eeLowEtForestName = cms.string("electron_ee_ecalOnly_1To300_0p2To2_mean"),
-            eeHighEtForestName = cms.string("electron_ee_ECALonly"),
+            ebLowEtForestName = cms.ESInputTag("", "electron_eb_ecalOnly_1To300_0p2To2_mean"),
+            ebHighEtForestName = cms.ESInputTag("", "electron_eb_ECALonly"),
+            eeLowEtForestName = cms.ESInputTag("", "electron_ee_ecalOnly_1To300_0p2To2_mean"),
+            eeHighEtForestName = cms.ESInputTag("", "electron_ee_ECALonly"),
             ),
         ecalOnlySigma = cms.PSet(
             rangeMinLowEt = cms.double(0.0002),
@@ -26,10 +26,10 @@
             rangeMaxHighEt = cms.double(0.5),
             forceHighEnergyTrainingIfSaturated = cms.bool(True),
             lowEtHighEtBoundary = cms.double(999999.),
-            ebLowEtForestName = cms.string("electron_eb_ecalOnly_1To300_0p0002To0p5_sigma"),
-            ebHighEtForestName = cms.string("electron_eb_ECALonly_var"),
-            eeLowEtForestName = cms.string("electron_ee_ecalOnly_1To300_0p0002To0p5_sigma"),
-            eeHighEtForestName = cms.string("electron_ee_ECALonly_var"),
+            ebLowEtForestName = cms.ESInputTag("", "electron_eb_ecalOnly_1To300_0p0002To0p5_sigma"),
+            ebHighEtForestName = cms.ESInputTag("", "electron_eb_ECALonly_var"),
+            eeLowEtForestName = cms.ESInputTag("", "electron_ee_ecalOnly_1To300_0p0002To0p5_sigma"),
+            eeHighEtForestName = cms.ESInputTag("", "electron_ee_ECALonly_var"),
             ),
         epComb = cms.PSet(
             ecalTrkRegressionConfig = cms.PSet(
@@ -39,10 +39,10 @@
                 rangeMaxHighEt = cms.double(2.0),
                 lowEtHighEtBoundary = cms.double(999999.),
                 forceHighEnergyTrainingIfSaturated = cms.bool(False),
-                ebLowEtForestName = cms.string('electron_eb_ecalTrk_1To300_0p2To2_mean'),
-                ebHighEtForestName = cms.string('electron_eb_ecalTrk_1To300_0p2To2_mean'),
-                eeLowEtForestName = cms.string('electron_ee_ecalTrk_1To300_0p2To2_mean'),
-                eeHighEtForestName = cms.string('electron_ee_ecalTrk_1To300_0p2To2_mean'),
+                ebLowEtForestName = cms.ESInputTag("", 'electron_eb_ecalTrk_1To300_0p2To2_mean'),
+                ebHighEtForestName = cms.ESInputTag("", 'electron_eb_ecalTrk_1To300_0p2To2_mean'),
+                eeLowEtForestName = cms.ESInputTag("", 'electron_ee_ecalTrk_1To300_0p2To2_mean'),
+                eeHighEtForestName = cms.ESInputTag("", 'electron_ee_ecalTrk_1To300_0p2To2_mean'),
                 ),
             ecalTrkRegressionUncertConfig = cms.PSet(
                 rangeMinLowEt = cms.double(0.0002),
@@ -51,10 +51,10 @@
                 rangeMaxHighEt = cms.double(0.5),
                 lowEtHighEtBoundary = cms.double(999999.),  
                 forceHighEnergyTrainingIfSaturated = cms.bool(False),
-                ebLowEtForestName = cms.string('electron_eb_ecalTrk_1To300_0p0002To0p5_sigma'),
-                ebHighEtForestName = cms.string('electron_eb_ecalTrk_1To300_0p0002To0p5_sigma'),
-                eeLowEtForestName = cms.string('electron_ee_ecalTrk_1To300_0p0002To0p5_sigma'),
-                eeHighEtForestName = cms.string('electron_ee_ecalTrk_1To300_0p0002To0p5_sigma'),
+                ebLowEtForestName = cms.ESInputTag("", 'electron_eb_ecalTrk_1To300_0p0002To0p5_sigma'),
+                ebHighEtForestName = cms.ESInputTag("", 'electron_eb_ecalTrk_1To300_0p0002To0p5_sigma'),
+                eeLowEtForestName = cms.ESInputTag("", 'electron_ee_ecalTrk_1To300_0p0002To0p5_sigma'),
+                eeHighEtForestName = cms.ESInputTag("", 'electron_ee_ecalTrk_1To300_0p0002To0p5_sigma'),
                 ),
             maxEcalEnergyForComb=cms.double(200.),
             minEOverPForComb=cms.double(0.025),
@@ -70,10 +70,10 @@
             rangeMaxHighEt = cms.double(3.0),
             forceHighEnergyTrainingIfSaturated = cms.bool(True),
             lowEtHighEtBoundary = cms.double(999999.),
-            ebLowEtForestName = cms.string("photon_eb_ecalOnly_5To300_0p2To2_mean"),
-            ebHighEtForestName = cms.string("photon_eb_ECALonly"),
-            eeLowEtForestName = cms.string("photon_ee_ecalOnly_5To300_0p2To2_mean"),
-            eeHighEtForestName = cms.string("photon_ee_ECALonly"),
+            ebLowEtForestName = cms.ESInputTag("", "photon_eb_ecalOnly_5To300_0p2To2_mean"),
+            ebHighEtForestName = cms.ESInputTag("", "photon_eb_ECALonly"),
+            eeLowEtForestName = cms.ESInputTag("", "photon_ee_ecalOnly_5To300_0p2To2_mean"),
+            eeHighEtForestName = cms.ESInputTag("", "photon_ee_ECALonly"),
             ),
         ecalOnlySigma = cms.PSet(
             rangeMinLowEt = cms.double(0.0002),
@@ -82,10 +82,10 @@
             rangeMaxHighEt = cms.double(0.5),
             forceHighEnergyTrainingIfSaturated = cms.bool(True),
             lowEtHighEtBoundary = cms.double(999999.),
-            ebLowEtForestName = cms.string("photon_eb_ecalOnly_5To300_0p0002To0p5_sigma"),
-            ebHighEtForestName = cms.string("photon_eb_ECALonly_var"),
-            eeLowEtForestName = cms.string("photon_ee_ecalOnly_5To300_0p0002To0p5_sigma"),
-            eeHighEtForestName = cms.string("photon_ee_ECALonly_var"),
+            ebLowEtForestName = cms.ESInputTag("", "photon_eb_ecalOnly_5To300_0p0002To0p5_sigma"),
+            ebHighEtForestName = cms.ESInputTag("", "photon_eb_ECALonly_var"),
+            eeLowEtForestName = cms.ESInputTag("", "photon_ee_ecalOnly_5To300_0p0002To0p5_sigma"),
+            eeHighEtForestName = cms.ESInputTag("", "photon_ee_ECALonly_var"),
         ),
     )
 )
@@ -104,10 +104,10 @@
             rangeMaxHighEt = cms.double(3.0),
             forceHighEnergyTrainingIfSaturated = cms.bool(True),
             lowEtHighEtBoundary = cms.double(999999.),
-            ebLowEtForestName = cms.string("electron_eb_ecalOnly_1To20_0p2To2_mean"),
-            ebHighEtForestName = cms.string("electron_eb_ECALonly"),
-            eeLowEtForestName = cms.string("electron_ee_ecalOnly_1To20_0p2To2_mean"),
-            eeHighEtForestName = cms.string("electron_ee_ECALonly"),
+            ebLowEtForestName = cms.ESInputTag("", "electron_eb_ecalOnly_1To20_0p2To2_mean"),
+            ebHighEtForestName = cms.ESInputTag("", "electron_eb_ECALonly"),
+            eeLowEtForestName = cms.ESInputTag("", "electron_ee_ecalOnly_1To20_0p2To2_mean"),
+            eeHighEtForestName = cms.ESInputTag("", "electron_ee_ECALonly"),
             ),
         ecalOnlySigma = cms.PSet(
             rangeMinLowEt = cms.double(0.0002),
@@ -116,10 +116,10 @@
             rangeMaxHighEt = cms.double(0.5),
             forceHighEnergyTrainingIfSaturated = cms.bool(True),
             lowEtHighEtBoundary = cms.double(999999.),
-            ebLowEtForestName = cms.string("electron_eb_ecalOnly_1To20_0p0002To0p5_sigma"),
-            ebHighEtForestName = cms.string("electron_eb_ECALonly_var"),
-            eeLowEtForestName = cms.string("electron_ee_ecalOnly_1To20_0p0002To0p5_sigma"),
-            eeHighEtForestName = cms.string("electron_ee_ECALonly_var"),
+            ebLowEtForestName = cms.ESInputTag("", "electron_eb_ecalOnly_1To20_0p0002To0p5_sigma"),
+            ebHighEtForestName = cms.ESInputTag("", "electron_eb_ECALonly_var"),
+            eeLowEtForestName = cms.ESInputTag("", "electron_ee_ecalOnly_1To20_0p0002To0p5_sigma"),
+            eeHighEtForestName = cms.ESInputTag("", "electron_ee_ECALonly_var"),
             ),
         epComb = cms.PSet(
             ecalTrkRegressionConfig = cms.PSet(
@@ -129,10 +129,10 @@
                 rangeMaxHighEt = cms.double(2.0),
                 lowEtHighEtBoundary = cms.double(999999.),
                 forceHighEnergyTrainingIfSaturated = cms.bool(False),
-                ebLowEtForestName = cms.string('electron_eb_ecalTrk_1To20_0p2To2_mean'),
-                ebHighEtForestName = cms.string('electron_eb_ecalTrk_1To20_0p2To2_mean'),
-                eeLowEtForestName = cms.string('electron_ee_ecalTrk_1To20_0p2To2_mean'),
-                eeHighEtForestName = cms.string('electron_ee_ecalTrk_1To20_0p2To2_mean'),
+                ebLowEtForestName = cms.ESInputTag("", 'electron_eb_ecalTrk_1To20_0p2To2_mean'),
+                ebHighEtForestName = cms.ESInputTag("", 'electron_eb_ecalTrk_1To20_0p2To2_mean'),
+                eeLowEtForestName = cms.ESInputTag("", 'electron_ee_ecalTrk_1To20_0p2To2_mean'),
+                eeHighEtForestName = cms.ESInputTag("", 'electron_ee_ecalTrk_1To20_0p2To2_mean'),
                 ),
             ecalTrkRegressionUncertConfig = cms.PSet(
                 rangeMinLowEt = cms.double(0.0002),
@@ -141,10 +141,10 @@
                 rangeMaxHighEt = cms.double(0.5),
                 lowEtHighEtBoundary = cms.double(999999.),  
                 forceHighEnergyTrainingIfSaturated = cms.bool(False),
-                ebLowEtForestName = cms.string('electron_eb_ecalTrk_1To20_0p0002To0p5_sigma'),
-                ebHighEtForestName = cms.string('electron_eb_ecalTrk_1To20_0p0002To0p5_sigma'),
-                eeLowEtForestName = cms.string('electron_ee_ecalTrk_1To20_0p0002To0p5_sigma'),
-                eeHighEtForestName = cms.string('electron_ee_ecalTrk_1To20_0p0002To0p5_sigma'),
+                ebLowEtForestName = cms.ESInputTag("", 'electron_eb_ecalTrk_1To20_0p0002To0p5_sigma'),
+                ebHighEtForestName = cms.ESInputTag("", 'electron_eb_ecalTrk_1To20_0p0002To0p5_sigma'),
+                eeLowEtForestName = cms.ESInputTag("", 'electron_ee_ecalTrk_1To20_0p0002To0p5_sigma'),
+                eeHighEtForestName = cms.ESInputTag("", 'electron_ee_ecalTrk_1To20_0p0002To0p5_sigma'),
                 ),
             maxEcalEnergyForComb=cms.double(200.),
             minEOverPForComb=cms.double(0.025),
@@ -160,10 +160,10 @@
             rangeMaxHighEt = cms.double(3.0),
             forceHighEnergyTrainingIfSaturated = cms.bool(True),
             lowEtHighEtBoundary = cms.double(999999.),
-            ebLowEtForestName = cms.string("photon_eb_ecalOnly_1To20_0p2To2_mean"),
-            ebHighEtForestName = cms.string("photon_eb_ECALonly"),
-            eeLowEtForestName = cms.string("photon_ee_ecalOnly_1To20_0p2To2_mean"),
-            eeHighEtForestName = cms.string("photon_ee_ECALonly"),
+            ebLowEtForestName = cms.ESInputTag("", "photon_eb_ecalOnly_1To20_0p2To2_mean"),
+            ebHighEtForestName = cms.ESInputTag("", "photon_eb_ECALonly"),
+            eeLowEtForestName = cms.ESInputTag("", "photon_ee_ecalOnly_1To20_0p2To2_mean"),
+            eeHighEtForestName = cms.ESInputTag("", "photon_ee_ECALonly"),
             ),
         ecalOnlySigma = cms.PSet(
             rangeMinLowEt = cms.double(0.0002),
@@ -172,10 +172,10 @@
             rangeMaxHighEt = cms.double(0.5),
             forceHighEnergyTrainingIfSaturated = cms.bool(True),
             lowEtHighEtBoundary = cms.double(999999.),
-            ebLowEtForestName = cms.string("photon_eb_ecalOnly_1To20_0p0002To0p5_sigma"),
-            ebHighEtForestName = cms.string("photon_eb_ECALonly_var"),
-            eeLowEtForestName = cms.string("photon_ee_ecalOnly_1To20_0p0002To0p5_sigma"),
-            eeHighEtForestName = cms.string("photon_ee_ECALonly_var"),
+            ebLowEtForestName = cms.ESInputTag("", "photon_eb_ecalOnly_1To20_0p0002To0p5_sigma"),
+            ebHighEtForestName = cms.ESInputTag("", "photon_eb_ECALonly_var"),
+            eeLowEtForestName = cms.ESInputTag("", "photon_ee_ecalOnly_1To20_0p0002To0p5_sigma"),
+            eeHighEtForestName = cms.ESInputTag("", "photon_ee_ECALonly_var"),
         ),
     )
 )
diff --git a/RecoEgamma/EgammaTools/src/EgammaRegressionContainer.cc b/RecoEgamma/EgammaTools/src/EgammaRegressionContainer.cc
index a109f9d119922..23f74b63004d0 100644
--- a/RecoEgamma/EgammaTools/src/EgammaRegressionContainer.cc
+++ b/RecoEgamma/EgammaTools/src/EgammaRegressionContainer.cc
@@ -4,24 +4,19 @@
 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
 #include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/Framework/interface/ESHandle.h"
-#include "CondFormats/DataRecord/interface/GBRDWrapperRcd.h"
-#include "CondFormats/EgammaObjects/interface/GBRForestD.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 
-EgammaRegressionContainer::EgammaRegressionContainer(const edm::ParameterSet& iConfig)
+EgammaRegressionContainer::EgammaRegressionContainer(const edm::ParameterSet& iConfig, edm::ConsumesCollector& cc)
     : outputTransformerLowEt_(iConfig.getParameter<double>("rangeMinLowEt"),
                               iConfig.getParameter<double>("rangeMaxLowEt")),
       outputTransformerHighEt_(iConfig.getParameter<double>("rangeMinHighEt"),
                                iConfig.getParameter<double>("rangeMaxHighEt")),
       forceHighEnergyTrainingIfSaturated_(iConfig.getParameter<bool>("forceHighEnergyTrainingIfSaturated")),
       lowEtHighEtBoundary_(iConfig.getParameter<double>("lowEtHighEtBoundary")),
-      ebLowEtForestName_(iConfig.getParameter<std::string>("ebLowEtForestName")),
-      ebHighEtForestName_(iConfig.getParameter<std::string>("ebHighEtForestName")),
-      eeLowEtForestName_(iConfig.getParameter<std::string>("eeLowEtForestName")),
-      eeHighEtForestName_(iConfig.getParameter<std::string>("eeHighEtForestName")),
-      ebLowEtForest_(nullptr),
-      ebHighEtForest_(nullptr),
-      eeLowEtForest_(nullptr),
-      eeHighEtForest_(nullptr) {}
+      ebLowEtForestToken_{cc.esConsumes(iConfig.getParameter<edm::ESInputTag>("ebLowEtForestName"))},
+      ebHighEtForestToken_{cc.esConsumes(iConfig.getParameter<edm::ESInputTag>("ebHighEtForestName"))},
+      eeLowEtForestToken_{cc.esConsumes(iConfig.getParameter<edm::ESInputTag>("eeLowEtForestName"))},
+      eeHighEtForestToken_{cc.esConsumes(iConfig.getParameter<edm::ESInputTag>("eeHighEtForestName"))} {}
 
 edm::ParameterSetDescription EgammaRegressionContainer::makePSetDescription() {
   edm::ParameterSetDescription desc;
@@ -38,19 +33,11 @@ edm::ParameterSetDescription EgammaRegressionContainer::makePSetDescription() {
   return desc;
 }
 
-namespace {
-  const GBRForestD* getForest(const edm::EventSetup& iSetup, const std::string& name) {
-    edm::ESHandle<GBRForestD> handle;
-    iSetup.get<GBRDWrapperRcd>().get(name, handle);
-    return handle.product();
-  }
-}  // namespace
-
 void EgammaRegressionContainer::setEventContent(const edm::EventSetup& iSetup) {
-  ebLowEtForest_ = getForest(iSetup, ebLowEtForestName_);
-  ebHighEtForest_ = getForest(iSetup, ebHighEtForestName_);
-  eeLowEtForest_ = getForest(iSetup, eeLowEtForestName_);
-  eeHighEtForest_ = getForest(iSetup, eeHighEtForestName_);
+  ebLowEtForest_ = &iSetup.getData(ebLowEtForestToken_);
+  ebHighEtForest_ = &iSetup.getData(ebHighEtForestToken_);
+  eeLowEtForest_ = &iSetup.getData(eeLowEtForestToken_);
+  eeHighEtForest_ = &iSetup.getData(eeHighEtForestToken_);
 }
 
 float EgammaRegressionContainer::operator()(const float et,
diff --git a/RecoEgamma/EgammaTools/src/EpCombinationTool.cc b/RecoEgamma/EgammaTools/src/EpCombinationTool.cc
index 573f7f8c2ef87..05f1deca1b3ea 100644
--- a/RecoEgamma/EgammaTools/src/EpCombinationTool.cc
+++ b/RecoEgamma/EgammaTools/src/EpCombinationTool.cc
@@ -6,14 +6,15 @@
 
 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 
 #include <cmath>
 #include <vector>
 #include <vdt/vdtMath.h>
 
-EpCombinationTool::EpCombinationTool(const edm::ParameterSet& iConfig)
-    : ecalTrkEnergyRegress_(iConfig.getParameter<edm::ParameterSet>("ecalTrkRegressionConfig")),
-      ecalTrkEnergyRegressUncert_(iConfig.getParameter<edm::ParameterSet>("ecalTrkRegressionUncertConfig")),
+EpCombinationTool::EpCombinationTool(const edm::ParameterSet& iConfig, edm::ConsumesCollector&& cc)
+    : ecalTrkEnergyRegress_(iConfig.getParameter<edm::ParameterSet>("ecalTrkRegressionConfig"), cc),
+      ecalTrkEnergyRegressUncert_(iConfig.getParameter<edm::ParameterSet>("ecalTrkRegressionUncertConfig"), cc),
       maxEcalEnergyForComb_(iConfig.getParameter<double>("maxEcalEnergyForComb")),
       minEOverPForComb_(iConfig.getParameter<double>("minEOverPForComb")),
       maxEPDiffInSigmaForComb_(iConfig.getParameter<double>("maxEPDiffInSigmaForComb")),