implement review comments and less template parameters

guitargeek · guitargeek · commit 548ed0cb3049 · 2020-10-19T00:52:00.000+02:00
diff --git a/RecoEgamma/EgammaElectronAlgos/interface/ElectronHcalHelper.h b/RecoEgamma/EgammaElectronAlgos/interface/ElectronHcalHelper.h
@@ -10,6 +10,7 @@
 #include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
 #include "DataFormats/HcalRecHit/interface/HcalRecHitCollections.h"
 #include "RecoEgamma/EgammaIsolationAlgos/interface/EgammaHcalIsolation.h"
+#include "RecoEgamma/EgammaIsolationAlgos/interface/EgammaHadTower.h"
 #include "RecoEgamma/EgammaIsolationAlgos/interface/EgammaTowerIsolation.h"
 #include "CondFormats/DataRecord/interface/HcalChannelQualityRcd.h"
 
@@ -48,9 +49,13 @@ class ElectronHcalHelper {
   double hOverEConeSize() const { return cfg_.hOverEConeSize; }
 
   // Behind clusters
-  std::vector<CaloTowerDetId> hcalTowersBehindClusters(const reco::SuperCluster &sc) const;
-  double hcalESumDepth1BehindClusters(const std::vector<CaloTowerDetId> &towers) const;
-  double hcalESumDepth2BehindClusters(const std::vector<CaloTowerDetId> &towers) const;
+  inline auto hcalTowersBehindClusters(const reco::SuperCluster &sc) const { return egamma::towersOf(sc, *towerMap_); }
+  inline auto hcalESumDepth1BehindClusters(const std::vector<CaloTowerDetId> &towers) const {
+    return egamma::depth1HcalESum(towers, *towersFromCollection_);
+  }
+  inline auto hcalESumDepth2BehindClusters(const std::vector<CaloTowerDetId> &towers) const {
+    return egamma::depth2HcalESum(towers, *towersFromCollection_);
+  }
 
   // forward EgammaHadTower methods, if checkHcalStatus is enabled, using towers and H/E
   // otherwise, return true
diff --git a/RecoEgamma/EgammaElectronAlgos/src/ElectronHcalHelper.cc b/RecoEgamma/EgammaElectronAlgos/src/ElectronHcalHelper.cc
@@ -1,5 +1,4 @@
 #include "RecoEgamma/EgammaElectronAlgos/interface/ElectronHcalHelper.h"
-#include "RecoEgamma/EgammaIsolationAlgos/interface/EgammaHadTower.h"
 #include "Geometry/Records/interface/CaloGeometryRecord.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 #include "Geometry/Records/interface/CaloGeometryRecord.h"
@@ -49,18 +48,6 @@ void ElectronHcalHelper::beginEvent(const edm::Event& evt, const edm::EventSetup
   }
 }
 
-std::vector<CaloTowerDetId> ElectronHcalHelper::hcalTowersBehindClusters(const reco::SuperCluster& sc) const {
-  return egammaHadTower::towersOf(sc, *towerMap_);
-}
-
-double ElectronHcalHelper::hcalESumDepth1BehindClusters(const std::vector<CaloTowerDetId>& towers) const {
-  return egammaHadTower::getDepth1HcalESum(towers, *towersFromCollection_);
-}
-
-double ElectronHcalHelper::hcalESumDepth2BehindClusters(const std::vector<CaloTowerDetId>& towers) const {
-  return egammaHadTower::getDepth2HcalESum(towers, *towersFromCollection_);
-}
-
 double ElectronHcalHelper::hcalESum(const SuperCluster& sc, const std::vector<CaloTowerDetId>* excludeTowers) const {
   if (cfg_.hOverEConeSize == 0) {
     return 0;
@@ -98,8 +85,7 @@ double ElectronHcalHelper::hcalESumDepth2(const SuperCluster& sc,
 
 bool ElectronHcalHelper::hasActiveHcal(const reco::SuperCluster& sc) const {
   if (cfg_.checkHcalStatus && cfg_.hOverEConeSize != 0 && cfg_.useTowers) {
-    return egammaHadTower::hasActiveHcal(
-        egammaHadTower::towersOf(sc, *towerMap_), *towerMap_, *hcalQuality_, *hcalTopology_);
+    return egamma::hasActiveHcal(egamma::towersOf(sc, *towerMap_), *towerMap_, *hcalQuality_, *hcalTopology_);
   } else {
     return true;
   }
diff --git a/RecoEgamma/EgammaElectronAlgos/src/TrajSeedMatcher.cc b/RecoEgamma/EgammaElectronAlgos/src/TrajSeedMatcher.cc
@@ -81,13 +81,10 @@ namespace {
 };  // namespace
 
 TrajSeedMatcher::Configuration::Configuration(const edm::ParameterSet& pset, edm::ConsumesCollector&& cc)
-    : magFieldToken{cc.esConsumes<MagneticField, IdealMagneticFieldRecord>()},
-      paramMagFieldToken{
-          cc.esConsumes<MagneticField, IdealMagneticFieldRecord>(pset.getParameter<edm::ESInputTag>("paramMagField"))},
-      navSchoolToken{
-          cc.esConsumes<NavigationSchool, NavigationSchoolRecord>(pset.getParameter<edm::ESInputTag>("navSchool"))},
-      detLayerGeomToken{
-          cc.esConsumes<DetLayerGeometry, RecoGeometryRecord>(pset.getParameter<edm::ESInputTag>("detLayerGeom"))},
+    : magFieldToken{cc.esConsumes()},
+      paramMagFieldToken{cc.esConsumes(pset.getParameter<edm::ESInputTag>("paramMagField"))},
+      navSchoolToken{cc.esConsumes(pset.getParameter<edm::ESInputTag>("navSchool"))},
+      detLayerGeomToken{cc.esConsumes(pset.getParameter<edm::ESInputTag>("detLayerGeom"))},
       useRecoVertex{pset.getParameter<bool>("useRecoVertex")},
       enableHitSkipping{pset.getParameter<bool>("enableHitSkipping")},
       requireExactMatchCount{pset.getParameter<bool>("requireExactMatchCount")},
diff --git a/RecoEgamma/EgammaElectronProducers/plugins/ElectronNHitSeedProducer.cc b/RecoEgamma/EgammaElectronProducers/plugins/ElectronNHitSeedProducer.cc
@@ -85,7 +85,7 @@ ElectronNHitSeedProducer::ElectronNHitSeedProducer(const edm::ParameterSet& pset
       beamSpotToken_(consumes<reco::BeamSpot>(pset.getParameter<edm::InputTag>("beamSpot"))),
       measTkEvtToken_(consumes<MeasurementTrackerEvent>(pset.getParameter<edm::InputTag>("measTkEvt"))),
       putToken_{produces<reco::ElectronSeedCollection>()},
-      trackerTopologyToken_{esConsumes<TrackerTopology, TrackerTopologyRcd>()} {
+      trackerTopologyToken_{esConsumes()} {
   for (const auto& scTag : pset.getParameter<std::vector<edm::InputTag>>("superClusters")) {
     superClustersTokens_.emplace_back(consumes<std::vector<reco::SuperClusterRef>>(scTag));
   }
diff --git a/RecoEgamma/EgammaHLTProducers/plugins/EgammaHLTBcHcalIsolationProducersRegional.cc b/RecoEgamma/EgammaHLTProducers/plugins/EgammaHLTBcHcalIsolationProducersRegional.cc
@@ -135,8 +135,8 @@ void EgammaHLTBcHcalIsolationProducersRegional::produce(edm::StreamID,
 
     float isol = 0;
 
-    auto towersBehindCluster = useSingleTower_ ? egammaHadTower::towersOf(*(recoEcalCandRef->superCluster()), *ctmaph)
-                                               : std::vector<CaloTowerDetId>{};
+    auto towersBehindCluster =
+        useSingleTower_ ? egamma::towersOf(*(recoEcalCandRef->superCluster()), *ctmaph) : std::vector<CaloTowerDetId>{};
 
     if (doEtSum_) {  //calculate hcal isolation excluding the towers behind the cluster which will be used for H for H/E
       const EgammaTowerIsolation isolAlgo(outerCone_, innerCone_, etMin_, depth_, &caloTowers);
@@ -149,8 +149,8 @@ void EgammaHLTBcHcalIsolationProducersRegional::produce(edm::StreamID,
 
     } else {  //calcuate H for H/E
       if (useSingleTower_)
-        isol = egammaHadTower::getDepth1HcalESum(towersBehindCluster, caloTowers) +
-               egammaHadTower::getDepth2HcalESum(towersBehindCluster, caloTowers);
+        isol = egamma::depth1HcalESum(towersBehindCluster, caloTowers) +
+               egamma::depth2HcalESum(towersBehindCluster, caloTowers);
       else {
         auto const &sc = recoEcalCandRef->superCluster().get();
         isol = towerIso1.getTowerESum(sc) + towerIso2.getTowerESum(sc);
diff --git a/RecoEgamma/EgammaHLTProducers/plugins/EgammaHLTGsfTrackVarProducer.cc b/RecoEgamma/EgammaHLTProducers/plugins/EgammaHLTGsfTrackVarProducer.cc
@@ -73,8 +73,8 @@ EgammaHLTGsfTrackVarProducer::EgammaHLTGsfTrackVarProducer(const edm::ParameterS
       electronToken_{consumes<reco::ElectronCollection>(config.getParameter<edm::InputTag>("inputCollection"))},
       gsfTrackToken_{consumes<reco::GsfTrackCollection>(config.getParameter<edm::InputTag>("inputCollection"))},
       beamSpotToken_{consumes<reco::BeamSpot>(config.getParameter<edm::InputTag>("beamSpotProducer"))},
-      magneticFieldToken_{esConsumes<MagneticField, IdealMagneticFieldRecord>()},
-      trackerGeometryToken_{esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>()},
+      magneticFieldToken_{esConsumes()},
+      trackerGeometryToken_{esConsumes()},
       upperTrackNrToRemoveCut_{config.getParameter<int>("upperTrackNrToRemoveCut")},
       lowerTrackNrToRemoveCut_{config.getParameter<int>("lowerTrackNrToRemoveCut")},
       useDefaultValuesForBarrel_{config.getParameter<bool>("useDefaultValuesForBarrel")},
diff --git a/RecoEgamma/EgammaIsolationAlgos/interface/EgammaHadTower.h b/RecoEgamma/EgammaIsolationAlgos/interface/EgammaHadTower.h
@@ -12,11 +12,11 @@
 
 class HcalChannelQuality;
 
-namespace egammaHadTower {
+namespace egamma {
   enum class HoeMode { SingleTower = 0, TowersBehindCluster = 1 };
 
-  double getDepth1HcalESum(std::vector<CaloTowerDetId> const& towers, CaloTowerCollection const&);
-  double getDepth2HcalESum(std::vector<CaloTowerDetId> const& towers, CaloTowerCollection const&);
+  double depth1HcalESum(std::vector<CaloTowerDetId> const& towers, CaloTowerCollection const&);
+  double depth2HcalESum(std::vector<CaloTowerDetId> const& towers, CaloTowerCollection const&);
 
   std::vector<CaloTowerDetId> towersOf(reco::SuperCluster const& sc,
                                        CaloTowerConstituentsMap const& towerMap,
@@ -28,6 +28,6 @@ namespace egammaHadTower {
                      CaloTowerConstituentsMap const& towerMap,
                      HcalChannelQuality const& hcalQuality,
                      HcalTopology const& hcalTopology);
-};  // namespace egammaHadTower
+};  // namespace egamma
 
 #endif
diff --git a/RecoEgamma/EgammaIsolationAlgos/plugins/EgammaEcalRecHitIsolationProducer.cc b/RecoEgamma/EgammaIsolationAlgos/plugins/EgammaEcalRecHitIsolationProducer.cc
@@ -48,8 +48,8 @@ EgammaEcalRecHitIsolationProducer::EgammaEcalRecHitIsolationProducer(const edm::
   vetoClustered_ = conf_.getParameter<bool>("vetoClustered");
 
   //EventSetup Tokens
-  sevLvToken_ = esConsumes<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd>();
-  caloGeometrytoken_ = esConsumes<CaloGeometry, CaloGeometryRecord>();
+  sevLvToken_ = esConsumes();
+  caloGeometrytoken_ = esConsumes();
 
   //register your products
   produces<edm::ValueMap<double>>();
diff --git a/RecoEgamma/EgammaIsolationAlgos/plugins/EleIsoDetIdCollectionProducer.cc b/RecoEgamma/EgammaIsolationAlgos/plugins/EleIsoDetIdCollectionProducer.cc
@@ -27,8 +27,8 @@
 EleIsoDetIdCollectionProducer::EleIsoDetIdCollectionProducer(const edm::ParameterSet& iConfig)
     : recHitsToken_(consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitsLabel"))),
       emObjectToken_(consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("emObjectLabel"))),
-      caloGeometryToken_(esConsumes<CaloGeometry, CaloGeometryRecord>()),
-      sevLvToken_(esConsumes<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd>()),
+      caloGeometryToken_(esConsumes()),
+      sevLvToken_(esConsumes()),
       recHitsLabel_(iConfig.getParameter<edm::InputTag>("recHitsLabel")),
       emObjectLabel_(iConfig.getParameter<edm::InputTag>("emObjectLabel")),
       energyCut_(iConfig.getParameter<double>("energyCut")),
diff --git a/RecoEgamma/EgammaIsolationAlgos/plugins/GamIsoDetIdCollectionProducer.cc b/RecoEgamma/EgammaIsolationAlgos/plugins/GamIsoDetIdCollectionProducer.cc
@@ -27,8 +27,8 @@
 GamIsoDetIdCollectionProducer::GamIsoDetIdCollectionProducer(const edm::ParameterSet& iConfig)
     : recHitsToken_(consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitsLabel"))),
       emObjectToken_(consumes<reco::PhotonCollection>(iConfig.getParameter<edm::InputTag>("emObjectLabel"))),
-      caloGeometryToken_(esConsumes<CaloGeometry, CaloGeometryRecord>()),
-      sevLvToken_(esConsumes<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd>()),
+      caloGeometryToken_(esConsumes()),
+      sevLvToken_(esConsumes()),
       //the labels are still used to decide if its endcap or barrel...
       recHitsLabel_(iConfig.getParameter<edm::InputTag>("recHitsLabel")),
       emObjectLabel_(iConfig.getParameter<edm::InputTag>("emObjectLabel")),
diff --git a/RecoEgamma/EgammaIsolationAlgos/src/EgammaHadTower.cc b/RecoEgamma/EgammaIsolationAlgos/src/EgammaHadTower.cc
@@ -7,7 +7,7 @@
 #include <iostream>
 #include <algorithm>
 
-CaloTowerDetId egammaHadTower::towerOf(const reco::CaloCluster& cluster, CaloTowerConstituentsMap const& towerMap) {
+CaloTowerDetId egamma::towerOf(const reco::CaloCluster& cluster, CaloTowerConstituentsMap const& towerMap) {
   DetId detid = cluster.seed();
   if (detid.det() != DetId::Ecal) {
     // Basic clusters of hybrid super-cluster do not have the seed set; take the first DetId instead
@@ -22,9 +22,9 @@ CaloTowerDetId egammaHadTower::towerOf(const reco::CaloCluster& cluster, CaloTow
   return id;
 }
 
-std::vector<CaloTowerDetId> egammaHadTower::towersOf(const reco::SuperCluster& sc,
-                                                     CaloTowerConstituentsMap const& towerMap,
-                                                     HoeMode mode) {
+std::vector<CaloTowerDetId> egamma::towersOf(const reco::SuperCluster& sc,
+                                             CaloTowerConstituentsMap const& towerMap,
+                                             HoeMode mode) {
   constexpr unsigned int nMaxClusters = 4;
 
   std::vector<CaloTowerDetId> towers;
@@ -70,8 +70,7 @@ std::vector<CaloTowerDetId> egammaHadTower::towersOf(const reco::SuperCluster& s
   return towers;
 }
 
-double egammaHadTower::getDepth1HcalESum(const std::vector<CaloTowerDetId>& towers,
-                                         CaloTowerCollection const& towerCollection) {
+double egamma::depth1HcalESum(const std::vector<CaloTowerDetId>& towers, CaloTowerCollection const& towerCollection) {
   double esum = 0.;
   for (auto const& tower : towerCollection) {
     if (std::find(towers.begin(), towers.end(), tower.id()) != towers.end()) {
@@ -81,8 +80,7 @@ double egammaHadTower::getDepth1HcalESum(const std::vector<CaloTowerDetId>& towe
   return esum;
 }
 
-double egammaHadTower::getDepth2HcalESum(const std::vector<CaloTowerDetId>& towers,
-                                         CaloTowerCollection const& towerCollection) {
+double egamma::depth2HcalESum(const std::vector<CaloTowerDetId>& towers, CaloTowerCollection const& towerCollection) {
   double esum = 0.;
   for (auto const& tower : towerCollection) {
     if (std::find(towers.begin(), towers.end(), tower.id()) != towers.end()) {
@@ -92,10 +90,10 @@ double egammaHadTower::getDepth2HcalESum(const std::vector<CaloTowerDetId>& towe
   return esum;
 }
 
-bool egammaHadTower::hasActiveHcal(const std::vector<CaloTowerDetId>& towers,
-                                   CaloTowerConstituentsMap const& towerMap,
-                                   const HcalChannelQuality& hcalQuality,
-                                   HcalTopology const& hcalTopology) {
+bool egamma::hasActiveHcal(const std::vector<CaloTowerDetId>& towers,
+                           CaloTowerConstituentsMap const& towerMap,
+                           const HcalChannelQuality& hcalQuality,
+                           HcalTopology const& hcalTopology) {
   bool active = false;
   int statusMask = ((1 << HcalChannelStatus::HcalCellOff) | (1 << HcalChannelStatus::HcalCellMask) |
                     (1 << HcalChannelStatus::HcalCellDead));
@@ -113,9 +111,9 @@ bool egammaHadTower::hasActiveHcal(const std::vector<CaloTowerDetId>& towers,
       if (hid.subdet() != HcalBarrel && hid.subdet() != HcalEndcap)
         continue;
 #ifdef EDM_ML_DEBUG
-      std::cout << "egammaHadTower DetId " << std::hex << id.rawId() << "  hid.rawId  " << hid.rawId() << std::dec
-                << "   sub " << hid.subdet() << "   ieta " << hid.ieta() << "   iphi " << hid.iphi() << "   depth "
-                << hid.depth() << std::endl;
+      std::cout << "egamma DetId " << std::hex << id.rawId() << "  hid.rawId  " << hid.rawId() << std::dec << "   sub "
+                << hid.subdet() << "   ieta " << hid.ieta() << "   iphi " << hid.iphi() << "   depth " << hid.depth()
+                << std::endl;
 #endif
       // Sunanda's fix for 2017 Plan1
       // and removed protection
diff --git a/RecoEgamma/EgammaPhotonProducers/src/ConversionProducer.cc b/RecoEgamma/EgammaPhotonProducers/src/ConversionProducer.cc
@@ -97,10 +97,9 @@ ConversionProducer::ConversionProducer(const edm::ParameterSet& iConfig)
 
   vertexProducer_ = consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("primaryVertexProducer"));
 
-  transientTrackBuilder_ =
-      esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"));
-  trackerGeometry_ = esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>();
-  magneticField_ = esConsumes<MagneticField, IdealMagneticFieldRecord>();
+  transientTrackBuilder_ = esConsumes(edm::ESInputTag("", "TransientTrackBuilder"));
+  trackerGeometry_ = esConsumes();
+  magneticField_ = esConsumes();
 
   //Track-cluster matching eta and phi cuts
   dEtaTkBC_ = iConfig.getParameter<double>("dEtaTrackBC");  //TODO research on cut endcap/barrel
diff --git a/RecoEgamma/EgammaPhotonProducers/src/ConversionTrackProducer.cc b/RecoEgamma/EgammaPhotonProducers/src/ConversionTrackProducer.cc
@@ -45,7 +45,7 @@ ConversionTrackProducer::ConversionTrackProducer(edm::ParameterSet const& conf)
     kfTrajectories = consumes<TrajTrackAssociationCollection>(thetp);
     gsfTrajectories = consumes<TrajGsfTrackAssociationCollection>(thetp);
   }
-  magFieldToken = esConsumes<MagneticField, IdealMagneticFieldRecord>();
+  magFieldToken = esConsumes();
   produces<reco::ConversionTrackCollection>();
 }
 
diff --git a/RecoEgamma/EgammaPhotonProducers/src/ConvertedPhotonProducer.cc b/RecoEgamma/EgammaPhotonProducers/src/ConvertedPhotonProducer.cc
@@ -87,7 +87,7 @@ ConvertedPhotonProducer::ConvertedPhotonProducer(const edm::ParameterSet& config
   risolveAmbiguity_ = conf_.getParameter<bool>("risolveConversionAmbiguity");
   likelihoodWeights_ = conf_.getParameter<std::string>("MVA_weights_location");
 
-  caloGeomToken_ = esConsumes<CaloGeometry, CaloGeometryRecord>();
+  caloGeomToken_ = esConsumes();
   mFToken_ = esConsumes<MagneticField, IdealMagneticFieldRecord, edm::Transition::BeginRun>();
   transientTrackToken_ = esConsumes<TransientTrackBuilder, TransientTrackRecord, edm::Transition::BeginRun>(
       edm::ESInputTag("", "TransientTrackBuilder"));
diff --git a/RecoEgamma/EgammaPhotonProducers/src/GEDPhotonProducer.cc b/RecoEgamma/EgammaPhotonProducers/src/GEDPhotonProducer.cc
@@ -518,12 +518,12 @@ void GEDPhotonProducer::fillPhotonCollection(edm::Event& evt,
       edm::ESHandle<HcalTopology> hcalTopology;
       es.get<HcalRecNumberingRecord>().get(hcalTopology);
 
-      TowersBehindClus = egammaHadTower::towersOf(*scRef, *ctmaph);
-      hcalDepth1OverEcalBc = egammaHadTower::getDepth1HcalESum(TowersBehindClus, *hcalTowers) / scRef->energy();
-      hcalDepth2OverEcalBc = egammaHadTower::getDepth2HcalESum(TowersBehindClus, *hcalTowers) / scRef->energy();
+      TowersBehindClus = egamma::towersOf(*scRef, *ctmaph);
+      hcalDepth1OverEcalBc = egamma::depth1HcalESum(TowersBehindClus, *hcalTowers) / scRef->energy();
+      hcalDepth2OverEcalBc = egamma::depth2HcalESum(TowersBehindClus, *hcalTowers) / scRef->energy();
 
       if (checkHcalStatus_ && hcalDepth1OverEcalBc == 0 && hcalDepth2OverEcalBc == 0) {
-        invalidHcal = !egammaHadTower::hasActiveHcal(TowersBehindClus, *ctmaph, *hcalQuality, *hcalTopology);
+        invalidHcal = !egamma::hasActiveHcal(TowersBehindClus, *ctmaph, *hcalQuality, *hcalTopology);
       }
     }
 
diff --git a/RecoEgamma/EgammaPhotonProducers/src/PhotonProducer.cc b/RecoEgamma/EgammaPhotonProducers/src/PhotonProducer.cc
@@ -275,9 +275,9 @@ void PhotonProducer::fillPhotonCollection(edm::Event& evt,
     edm::ESHandle<CaloTowerConstituentsMap> ctmaph;
     es.get<CaloGeometryRecord>().get(ctmaph);
 
-    auto towersBehindCluster = egammaHadTower::towersOf(*scRef, *ctmaph);
-    float hcalDepth1OverEcalBc = egammaHadTower::getDepth1HcalESum(towersBehindCluster, hcalTowers) / scRef->energy();
-    float hcalDepth2OverEcalBc = egammaHadTower::getDepth2HcalESum(towersBehindCluster, hcalTowers) / scRef->energy();
+    auto towersBehindCluster = egamma::towersOf(*scRef, *ctmaph);
+    float hcalDepth1OverEcalBc = egamma::depth1HcalESum(towersBehindCluster, hcalTowers) / scRef->energy();
+    float hcalDepth2OverEcalBc = egamma::depth2HcalESum(towersBehindCluster, hcalTowers) / scRef->energy();
 
     // recalculate position of seed BasicCluster taking shower depth for unconverted photon
     math::XYZPoint unconvPos =
diff --git a/RecoEgamma/EgammaPhotonProducers/src/ReducedEGProducer.cc b/RecoEgamma/EgammaPhotonProducers/src/ReducedEGProducer.cc
@@ -99,7 +99,7 @@ ReducedEGProducer::ReducedEGProducer(const edm::ParameterSet& config)
       relinkGsfElectronSel_(config.getParameter<std::string>("relinkGsfElectrons")),
       hcalHitSel_(config.getParameter<edm::ParameterSet>("hcalHitSel"), consumesCollector()) {
   const edm::InputTag& aTag = config.getParameter<edm::InputTag>("ootPhotons");
-  caloTopology_ = esConsumes<CaloTopology, CaloTopologyRecord>();
+  caloTopology_ = esConsumes();
   if (not aTag.label().empty())
     ootPhotonT_ = consumes<reco::PhotonCollection>(aTag);
 
diff --git a/RecoEgamma/EgammaTools/src/HGCalEgammaIDHelper.cc b/RecoEgamma/EgammaTools/src/HGCalEgammaIDHelper.cc
@@ -16,7 +16,7 @@ HGCalEgammaIDHelper::HGCalEgammaIDHelper(const edm::ParameterSet& iConfig, edm::
   recHitsFH_ = iC.consumes<HGCRecHitCollection>(fhRecHitInputTag_);
   recHitsBH_ = iC.consumes<HGCRecHitCollection>(bhRecHitInputTag_);
   hitMap_ = iC.consumes<std::unordered_map<DetId, const HGCRecHit*>>(hitMapInputTag_);
-  caloGeometry_ = iC.esConsumes<CaloGeometry, CaloGeometryRecord>();
+  caloGeometry_ = iC.esConsumes();
   pcaHelper_.setdEdXWeights(dEdXWeights_);
   debug_ = iConfig.getUntrackedParameter<bool>("debug", false);
 }
diff --git a/RecoEgamma/ElectronIdentification/plugins/ElectronHEEPIDValueMapProducer.cc b/RecoEgamma/ElectronIdentification/plugins/ElectronHEEPIDValueMapProducer.cc
@@ -198,7 +198,7 @@ ElectronHEEPIDValueMapProducer::ElectronHEEPIDValueMapProducer(const edm::Parame
   setToken(eleToken_, iConfig, "elesAOD", "elesMiniAOD", dataFormat_);
   setToken(candTokens_, iConfig, "candsAOD", "candsMiniAOD", dataFormat_);
   setToken(beamSpotToken_, iConfig, "beamSpot");
-  caloTopoToken_ = esConsumes<CaloTopology, CaloTopologyRecord>();
+  caloTopoToken_ = esConsumes();
 
   auto fillVetos = [](const auto& in, auto& out) {
     std::transform(in.begin(), in.end(), std::back_inserter(out), EleTkIsolFromCands::pidVetoFromStr);
diff --git a/RecoParticleFlow/PFProducer/plugins/importers/SuperClusterImporter.cc b/RecoParticleFlow/PFProducer/plugins/importers/SuperClusterImporter.cc

Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ ElectronNHitSeedProducer::ElectronNHitSeedProducer(const edm::ParameterSet& pset`
`85`	`85`	`beamSpotToken_(consumes<reco::BeamSpot>(pset.getParameter<edm::InputTag>("beamSpot"))),`
`86`	`86`	`measTkEvtToken_(consumes<MeasurementTrackerEvent>(pset.getParameter<edm::InputTag>("measTkEvt"))),`
`87`	`87`	`putToken_{produces<reco::ElectronSeedCollection>()},`
`88`		`- trackerTopologyToken_{esConsumes<TrackerTopology, TrackerTopologyRcd>()} {`
	`88`	`+ trackerTopologyToken_{esConsumes()} {`
`89`	`89`	`for (const auto& scTag : pset.getParameter<std::vector<edm::InputTag>>("superClusters")) {`
`90`	`90`	`superClustersTokens_.emplace_back(consumes<std::vector<reco::SuperClusterRef>>(scTag));`
`91`	`91`	`}`