Merge CMSSW_10_5_X into CMSSW_10_5_DEVEL_X.

cms-sw · Feb 18, 2019 · b7d1682 · b7d1682
2 parents ff5d351 + 5fd1581
commit b7d1682
Show file tree

Hide file tree

Showing 9 changed files with 32 additions and 65 deletions.
diff --git a/RecoEcal/EgammaClusterProducers/interface/EgammaSCCorrectionMaker.h b/RecoEcal/EgammaClusterProducers/interface/EgammaSCCorrectionMaker.h
@@ -44,13 +44,13 @@ class EgammaSCCorrectionMaker : public edm::stream::EDProducer<> {
 
    private:
 
-     EcalClusterFunctionBaseClass* energyCorrectionFunction_;
-     EcalClusterFunctionBaseClass* crackCorrectionFunction_;
-     EcalClusterFunctionBaseClass* localContCorrectionFunction_;
+     std::unique_ptr<EcalClusterFunctionBaseClass> energyCorrectionFunction_;
+     std::unique_ptr<EcalClusterFunctionBaseClass> crackCorrectionFunction_;
+     std::unique_ptr<EcalClusterFunctionBaseClass> localContCorrectionFunction_;
 
 
      // pointer to the correction algo object
-     EgammaSCEnergyCorrectionAlgo *energyCorrector_;
+     std::unique_ptr<EgammaSCEnergyCorrectionAlgo> energyCorrector_;
 
 
 

diff --git a/RecoEcal/EgammaClusterProducers/src/EgammaSCCorrectionMaker.cc b/RecoEcal/EgammaClusterProducers/src/EgammaSCCorrectionMaker.cc
@@ -77,36 +77,23 @@ EgammaSCCorrectionMaker::EgammaSCCorrectionMaker(const edm::ParameterSet& ps)
   produces<reco::SuperClusterCollection>(outputCollection_);
 
   // instanciate the correction algo object
-  energyCorrector_ = new EgammaSCEnergyCorrectionAlgo(sigmaElectronicNoise_, sCAlgo_, fCorrPset);
+  energyCorrector_ = std::make_unique<EgammaSCEnergyCorrectionAlgo>(sigmaElectronicNoise_, sCAlgo_, fCorrPset);
 
   // energy correction class
   if (applyEnergyCorrection_ )
-    energyCorrectionFunction_ = EcalClusterFunctionFactory::get()->create(energyCorrectorName_, ps);
+    energyCorrectionFunction_ = std::unique_ptr<EcalClusterFunctionBaseClass>(EcalClusterFunctionFactory::get()->create(energyCorrectorName_, ps));
     //energyCorrectionFunction_ = EcalClusterFunctionFactory::get()->create("EcalClusterEnergyCorrection", ps);
-  else
-    energyCorrectionFunction_=nullptr;
 
   if (applyCrackCorrection_ )
-    crackCorrectionFunction_ = EcalClusterFunctionFactory::get()->create(crackCorrectorName_, ps);
-  else
-    crackCorrectionFunction_=nullptr;
+    crackCorrectionFunction_ = std::unique_ptr<EcalClusterFunctionBaseClass>(EcalClusterFunctionFactory::get()->create(crackCorrectorName_, ps));
 
 
   if (applyLocalContCorrection_ )
-    localContCorrectionFunction_ = EcalClusterFunctionFactory::get()->create(localContCorrectorName_, ps);
-  else
-    localContCorrectionFunction_=nullptr;
+    localContCorrectionFunction_ = std::unique_ptr<EcalClusterFunctionBaseClass>(EcalClusterFunctionFactory::get()->create(localContCorrectorName_, ps));
 
 }
 
-EgammaSCCorrectionMaker::~EgammaSCCorrectionMaker()
-{
-  if (energyCorrectionFunction_)    delete energyCorrectionFunction_;
-  if (crackCorrectionFunction_)     delete crackCorrectionFunction_;
-  if (localContCorrectionFunction_) delete localContCorrectionFunction_;
-
-  delete energyCorrector_;
-}
+EgammaSCCorrectionMaker::~EgammaSCCorrectionMaker() = default;
 
 void
 EgammaSCCorrectionMaker::produce(edm::Event& evt, const edm::EventSetup& es)
@@ -169,19 +156,19 @@ EgammaSCCorrectionMaker::produce(edm::Event& evt, const edm::EventSetup& es)
       i++;
 
       if(applyEnergyCorrection_) 
-        enecorrClus = energyCorrector_->applyCorrection(*aClus, *hitCollection, sCAlgo_, geometry_p, energyCorrectionFunction_, energyCorrectorName_, modeEB_, modeEE_);
+        enecorrClus = energyCorrector_->applyCorrection(*aClus, *hitCollection, sCAlgo_, geometry_p, energyCorrectionFunction_.get(), energyCorrectorName_, modeEB_, modeEE_);
       else
 	enecorrClus=*aClus;
 
 
       if(applyCrackCorrection_)
-	crackcorrClus=energyCorrector_->applyCrackCorrection(enecorrClus,crackCorrectionFunction_);
+	crackcorrClus=energyCorrector_->applyCrackCorrection(enecorrClus,crackCorrectionFunction_.get());
       else 
 	crackcorrClus=enecorrClus;
 
       if (applyLocalContCorrection_)
 	localContCorrClus = 
-	  energyCorrector_->applyLocalContCorrection(crackcorrClus,localContCorrectionFunction_);
+	  energyCorrector_->applyLocalContCorrection(crackcorrClus,localContCorrectionFunction_.get());
       else
 	localContCorrClus = crackcorrClus;
 

diff --git a/RecoEcal/EgammaCoreTools/test/testEcalClusterFunctions.cc b/RecoEcal/EgammaCoreTools/test/testEcalClusterFunctions.cc
@@ -39,28 +39,21 @@ Description: <one line class summary>
 class testEcalClusterFunctions : public edm::EDAnalyzer {
         public:
                 explicit testEcalClusterFunctions(const edm::ParameterSet&);
-                ~testEcalClusterFunctions();
+                ~testEcalClusterFunctions() override = default;
 
         private:
-                virtual void analyze(const edm::Event&, const edm::EventSetup&);
-                EcalClusterFunctionBaseClass *ff_;
+                void analyze(const edm::Event&, const edm::EventSetup&) override;
+                std::unique_ptr<EcalClusterFunctionBaseClass> ff_;
 
 };
 
 
 
-testEcalClusterFunctions::testEcalClusterFunctions(const edm::ParameterSet& ps) :
-        ff_(0)
+testEcalClusterFunctions::testEcalClusterFunctions(const edm::ParameterSet& ps)
 {
         std::string functionName = ps.getParameter<std::string>("functionName");
-        ff_ = EcalClusterFunctionFactory::get()->create( functionName, ps );
-        std::cout << "got " << functionName << " function at: " << ff_ << "\n";
-}
-
-
-
-testEcalClusterFunctions::~testEcalClusterFunctions()
-{
+        ff_ = std::unique_ptr<EcalClusterFunctionBaseClass>{EcalClusterFunctionFactory::get()->create( functionName, ps )};
+        std::cout << "got " << functionName << " function at: " << ff_.get() << "\n";
 }
 
 

diff --git a/RecoLocalCalo/EcalRecProducers/plugins/ESRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/ESRecHitProducer.cc
@@ -14,18 +14,13 @@
 
 ESRecHitProducer::ESRecHitProducer(edm::ParameterSet const& ps) :
   digiToken_( consumes<ESDigiCollection>(ps.getParameter<edm::InputTag>("ESdigiCollection")) ),
-  rechitCollection_( ps.getParameter<std::string>("ESrechitCollection") )
+  rechitCollection_( ps.getParameter<std::string>("ESrechitCollection") ),
+  worker_{ESRecHitWorkerFactory::get()->create(ps.getParameter<std::string>("algo"), ps )}
 {
   produces<ESRecHitCollection>(rechitCollection_);
-
-  std::string const & componentType = ps.getParameter<std::string>("algo");
-  worker_ = ESRecHitWorkerFactory::get()->create( componentType, ps );
 }
 
-ESRecHitProducer::~ESRecHitProducer() {
-
-  delete worker_;
-}
+ESRecHitProducer::~ESRecHitProducer()  = default;
 
 void ESRecHitProducer::produce(edm::Event& e, const edm::EventSetup& es) {
 

diff --git a/RecoLocalCalo/EcalRecProducers/plugins/ESRecHitProducer.h b/RecoLocalCalo/EcalRecProducers/plugins/ESRecHitProducer.h
@@ -27,6 +27,6 @@ class ESRecHitProducer : public edm::stream::EDProducer<> {
   const edm::EDGetTokenT<ESDigiCollection> digiToken_;
   const std::string rechitCollection_; // secondary name to be given to collection of hits
 
-  ESRecHitWorkerBaseClass * worker_;
+  std::unique_ptr<ESRecHitWorkerBaseClass> worker_;
 };
 #endif
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducer.cc
@@ -64,23 +64,18 @@ EcalRecHitProducer::EcalRecHitProducer(const edm::ParameterSet& ps)
 
         std::string componentType = ps.getParameter<std::string>("algo");
 	edm::ConsumesCollector c{consumesCollector()};
-        worker_ = EcalRecHitWorkerFactory::get()->create(componentType, ps, c);
+        worker_ = std::unique_ptr<EcalRecHitWorkerBaseClass>{EcalRecHitWorkerFactory::get()->create(componentType, ps, c)};
 
         // to recover problematic channels
         componentType = ps.getParameter<std::string>("algoRecover");
-        workerRecover_ = EcalRecHitWorkerFactory::get()->create(componentType, ps, c);
+        workerRecover_ = std::unique_ptr<EcalRecHitWorkerBaseClass>{EcalRecHitWorkerFactory::get()->create(componentType, ps, c)};
 
 	edm::ParameterSet cleaningPs = 
 	  ps.getParameter<edm::ParameterSet>("cleaningConfig");
-	cleaningAlgo_ = new EcalCleaningAlgo(cleaningPs);
+	cleaningAlgo_ = std::make_unique<EcalCleaningAlgo>(cleaningPs);
 }
 
-EcalRecHitProducer::~EcalRecHitProducer()
-{
-        delete worker_;
-        delete workerRecover_;
-	delete cleaningAlgo_;
-}
+EcalRecHitProducer::~EcalRecHitProducer() = default;
 
 void
 EcalRecHitProducer::produce(edm::Event& evt, const edm::EventSetup& es)

diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducer.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducer.h
@@ -44,10 +44,10 @@ class EcalRecHitProducer : public edm::stream::EDProducer<> {
                 bool killDeadChannels_;
 
 
-                EcalRecHitWorkerBaseClass * worker_;
-                EcalRecHitWorkerBaseClass * workerRecover_;
+                std::unique_ptr<EcalRecHitWorkerBaseClass> worker_;
+                std::unique_ptr<EcalRecHitWorkerBaseClass> workerRecover_;
 
-		EcalCleaningAlgo * cleaningAlgo_;  
+                std::unique_ptr<EcalCleaningAlgo> cleaningAlgo_;
 
 		edm::EDGetTokenT<EBUncalibratedRecHitCollection> ebUncalibRecHitToken_;
 		edm::EDGetTokenT<EEUncalibratedRecHitCollection> eeUncalibRecHitToken_;

diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc
@@ -34,13 +34,10 @@ EcalUncalibRecHitProducer::EcalUncalibRecHitProducer(const edm::ParameterSet& ps
 	edm::ParameterSet algoConf = ps.getParameter<edm::ParameterSet>("algoPSet");
 
 	edm::ConsumesCollector c{consumesCollector()};
-        worker_ = EcalUncalibRecHitWorkerFactory::get()->create(componentType, algoConf, c);
+        worker_ = std::unique_ptr<EcalUncalibRecHitWorkerBaseClass>{EcalUncalibRecHitWorkerFactory::get()->create(componentType, algoConf, c)};
 }
 
-EcalUncalibRecHitProducer::~EcalUncalibRecHitProducer()
-{
-        delete worker_;
-}
+EcalUncalibRecHitProducer::~EcalUncalibRecHitProducer() = default;
 
 void EcalUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
 

diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.h
@@ -31,6 +31,6 @@ class EcalUncalibRecHitProducer : public edm::stream::EDProducer<> {
                 std::string ebHitCollection_; 
                 std::string eeHitCollection_; 
 
-                EcalUncalibRecHitWorkerBaseClass * worker_;
+                std::unique_ptr<EcalUncalibRecHitWorkerBaseClass> worker_;
 };
 #endif