modernize ElectronHcalHelper

Author: guitargeek

RecoEgamma/EgammaElectronAlgos/interface/ElectronHcalHelper.h

@@ -8,9 +8,9 @@
 #include "FWCore/Framework/interface/ESHandle.h"
 #include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
 #include "DataFormats/HcalRecHit/interface/HcalRecHitCollections.h"
+#include "RecoEgamma/EgammaIsolationAlgos/interface/EgammaHcalIsolation.h"
+#include "RecoEgamma/EgammaIsolationAlgos/interface/EgammaTowerIsolation.h"
 
-class EgammaHcalIsolation;
-class EgammaTowerIsolation;
 class EgammaHadTower;
 class HcalTopology;
 class HcalChannelQuality;
@@ -35,10 +35,9 @@ class ElectronHcalHelper {
     double hOverEHFMinE;
   };
 
-  ElectronHcalHelper(const Configuration &);
-  void checkSetup(const edm::EventSetup &);
-  void readEvent(const edm::Event &);
-  ~ElectronHcalHelper();
+  ElectronHcalHelper(const Configuration &cfg) : cfg_(cfg) {}
+
+  void beginEvent(const edm::Event &, const edm::EventSetup &);
 
   double hcalESum(const reco::SuperCluster &, const std::vector<CaloTowerDetId> *excludeTowers = nullptr) const;
   double hcalESumDepth1(const reco::SuperCluster &, const std::vector<CaloTowerDetId> *excludeTowers = nullptr) const;
@@ -58,15 +57,15 @@ class ElectronHcalHelper {
   const Configuration cfg_;
 
   // event setup data (rechits strategy)
-  unsigned long long caloGeomCacheId_;
+  unsigned long long caloGeomCacheId_ = 0;
   edm::ESHandle<CaloGeometry> caloGeom_;
 
   // event data (rechits strategy)
-  EgammaHcalIsolation *hcalIso_;
+  std::unique_ptr<EgammaHcalIsolation> hcalIso_ = nullptr;
 
   // event data (towers strategy)
-  EgammaTowerIsolation *towerIso1_;
-  EgammaTowerIsolation *towerIso2_;
+  std::unique_ptr<EgammaTowerIsolation> towerIso1_ = nullptr;
+  std::unique_ptr<EgammaTowerIsolation> towerIso2_ = nullptr;
   CaloTowerCollection const *towersFromCollection_ = nullptr;
   CaloTowerConstituentsMap const *towerMap_ = nullptr;
   HcalChannelQuality const *hcalQuality_ = nullptr;

RecoEgamma/EgammaElectronAlgos/src/ElectronHcalHelper.cc

@@ -1,6 +1,4 @@
 #include "RecoEgamma/EgammaElectronAlgos/interface/ElectronHcalHelper.h"
-#include "RecoEgamma/EgammaIsolationAlgos/interface/EgammaHcalIsolation.h"
-#include "RecoEgamma/EgammaIsolationAlgos/interface/EgammaTowerIsolation.h"
 #include "RecoEgamma/EgammaIsolationAlgos/interface/EgammaHadTower.h"
 #include "Geometry/Records/interface/CaloGeometryRecord.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
@@ -9,15 +7,18 @@
 
 using namespace reco;
 
-ElectronHcalHelper::ElectronHcalHelper(const Configuration& cfg)
-    : cfg_(cfg), caloGeomCacheId_(0), hcalIso_(nullptr), towerIso1_(nullptr), towerIso2_(nullptr) {}
-
-void ElectronHcalHelper::checkSetup(const edm::EventSetup& es) {
+void ElectronHcalHelper::beginEvent(const edm::Event& evt, const edm::EventSetup& es) {
   if (cfg_.hOverEConeSize == 0) {
     return;
   }
 
   if (cfg_.useTowers) {
+    towersFromCollection_ = &evt.get(cfg_.hcalTowers);
+    towerIso1_ =
+        std::make_unique<EgammaTowerIsolation>(cfg_.hOverEConeSize, 0., cfg_.hOverEPtMin, 1, towersFromCollection_);
+    towerIso2_ =
+        std::make_unique<EgammaTowerIsolation>(cfg_.hOverEConeSize, 0., cfg_.hOverEPtMin, 2, towersFromCollection_);
+
     edm::ESHandle<CaloTowerConstituentsMap> ctmaph;
     es.get<CaloGeometryRecord>().get(ctmaph);
     towerMap_ = ctmaph.product();
@@ -28,41 +29,20 @@ void ElectronHcalHelper::checkSetup(const edm::EventSetup& es) {
     edm::ESHandle<HcalTopology> hcalTopology;
     es.get<HcalRecNumberingRecord>().get(hcalTopology);
     hcalTopology_ = hcalTopology.product();
-
   } else {
-    unsigned long long newCaloGeomCacheId_ = es.get<CaloGeometryRecord>().cacheIdentifier();
-    if (caloGeomCacheId_ != newCaloGeomCacheId_) {
-      caloGeomCacheId_ = newCaloGeomCacheId_;
-      es.get<CaloGeometryRecord>().get(caloGeom_);
-    }
-  }
-}
-
-void ElectronHcalHelper::readEvent(const edm::Event& evt) {
-  if (cfg_.hOverEConeSize == 0) {
-    return;
-  }
-
-  if (cfg_.useTowers) {
-    delete towerIso1_;
-    towerIso1_ = nullptr;
-    delete towerIso2_;
-    towerIso2_ = nullptr;
-
-    towersFromCollection_ = &evt.get(cfg_.hcalTowers);
-    towerIso1_ = new EgammaTowerIsolation(cfg_.hOverEConeSize, 0., cfg_.hOverEPtMin, 1, towersFromCollection_);
-    towerIso2_ = new EgammaTowerIsolation(cfg_.hOverEConeSize, 0., cfg_.hOverEPtMin, 2, towersFromCollection_);
-  } else {
-    delete hcalIso_;
-    hcalIso_ = nullptr;
-
     edm::Handle<HBHERecHitCollection> hbhe_;
     if (!evt.getByToken(cfg_.hcalRecHits, hbhe_)) {
       edm::LogError("ElectronHcalHelper::readEvent") << "failed to get the rechits";
     }
 
-    hcalIso_ = new EgammaHcalIsolation(
+    hcalIso_ = std::make_unique<EgammaHcalIsolation>(
         cfg_.hOverEConeSize, 0., cfg_.hOverEHBMinE, cfg_.hOverEHFMinE, 0., 0., caloGeom_, *hbhe_);
+
+    unsigned long long newCaloGeomCacheId_ = es.get<CaloGeometryRecord>().cacheIdentifier();
+    if (caloGeomCacheId_ != newCaloGeomCacheId_) {
+      caloGeomCacheId_ = newCaloGeomCacheId_;
+      es.get<CaloGeometryRecord>().get(caloGeom_);
+    }
   }
 }
 
@@ -121,15 +101,3 @@ bool ElectronHcalHelper::hasActiveHcal(const reco::SuperCluster& sc) const {
     return true;
   }
 }
-
-ElectronHcalHelper::~ElectronHcalHelper() {
-  if (cfg_.hOverEConeSize == 0) {
-    return;
-  }
-  if (cfg_.useTowers) {
-    delete towerIso1_;
-    delete towerIso2_;
-  } else {
-    delete hcalIso_;
-  }
-}

RecoEgamma/EgammaElectronAlgos/src/GsfElectronAlgo.cc

@@ -397,7 +397,6 @@ GsfElectronAlgo::GsfElectronAlgo(const Tokens& input,
 {}
 
 void GsfElectronAlgo::checkSetup(const edm::EventSetup& es) {
-  hcalHelper_.checkSetup(es);
   if (cfg_.strategy.useEcalRegression || cfg_.strategy.useCombinationRegression)
     regHelper_.checkSetup(es);
 
@@ -412,9 +411,6 @@ void GsfElectronAlgo::checkSetup(const edm::EventSetup& es) {
 GsfElectronAlgo::EventData GsfElectronAlgo::beginEvent(edm::Event const& event,
                                                        CaloGeometry const& caloGeometry,
                                                        EcalSeverityLevelAlgo const& ecalSeveretyLevelAlgo) {
-  // prepare access to hcal data
-  hcalHelper_.readEvent(event);
-
   auto const& towers = event.get(cfg_.tokens.hcalTowersTag);
 
   // Isolation algos
@@ -538,6 +534,9 @@ reco::GsfElectronCollection GsfElectronAlgo::completeElectrons(edm::Event const&
   auto const& trackerGeometry = eventSetup.getData(trackerGeometryToken_);
   auto const& ecalSeveretyLevelAlgo = eventSetup.getData(ecalSeveretyLevelAlgoToken_);
 
+  // prepare access to hcal data
+  hcalHelper_.beginEvent(event, eventSetup);
+
   checkSetup(eventSetup);
   auto eventData = beginEvent(event, caloGeometry, ecalSeveretyLevelAlgo);
   double magneticFieldInTesla = magneticField.inTesla(GlobalPoint(0., 0., 0.)).z();

RecoEgamma/EgammaElectronProducers/plugins/ElectronSeedProducer.cc

@@ -77,7 +77,7 @@ ElectronSeedProducer::ElectronSeedProducer(const edm::ParameterSet& conf)
   // for H/E
   applyHOverECut_ = conf.getParameter<bool>("applyHOverECut");
   if (applyHOverECut_) {
-    ElectronHcalHelper::Configuration hcalCfg;
+    ElectronHcalHelper::Configuration hcalCfg{};
     hcalCfg.hOverEConeSize = conf.getParameter<double>("hOverEConeSize");
     if (hcalCfg.hOverEConeSize > 0) {
       hcalCfg.useTowers = true;
@@ -116,8 +116,7 @@ void ElectronSeedProducer::produce(edm::Event& e, const edm::EventSetup& iSetup)
   std::unique_ptr<TrajectorySeedCollection> initialSeedCollectionPtr = nullptr;  //created on the fly
 
   if (hcalHelper_) {
-    hcalHelper_->checkSetup(iSetup);
-    hcalHelper_->readEvent(e);
+    hcalHelper_->beginEvent(e, iSetup);
     if (allowHGCal_) {
       hgcClusterTools_->getEventSetup(iSetup);
       hgcClusterTools_->getEvent(e);