Modernize modules in CondFormats/CSCObjects

- moved to thread friendly module types - use esConsumes - switch to MessageLogger
cms-sw · Nov 30, 2021 · c78c0d6 · c78c0d6
1 parent 22ddbab
commit c78c0d6
Show file tree

Hide file tree

Showing 22 changed files with 537 additions and 508 deletions.
diff --git a/CondFormats/CSCObjects/test/CSCGainsStudy.cc b/CondFormats/CSCObjects/test/CSCGainsStudy.cc
@@ -21,7 +21,7 @@ using namespace std;
 using namespace edm;
 
 // Constructor
-CSCGainsStudy::CSCGainsStudy(const ParameterSet& pset) {
+CSCGainsStudy::CSCGainsStudy(const ParameterSet& pset) : gainsToken{esConsumes()} {
   // Get the various input parameters
   debug = pset.getUntrackedParameter<bool>("debug");
   rootFileName = pset.getUntrackedParameter<string>("rootFileName");
@@ -136,16 +136,16 @@ CSCGainsStudy::~CSCGainsStudy() {
   theFile->Close();
   if (debug)
     cout << "************* Finished writing histograms to file" << endl;
+
+  delete theFile;
 }
 
 /* analyze
  *
  */
 void CSCGainsStudy::analyze(const Event& event, const EventSetup& eventSetup) {
   // Get the gains and compute global gain average to store for later use in strip calibration
-  edm::ESHandle<CSCGains> hGains;
-  eventSetup.get<CSCGainsRcd>().get(hGains);
-  const CSCGains* hGains_ = &*hGains.product();
+  const CSCGains* hGains_ = &eventSetup.getData(gainsToken);
 
   // Store so it can be used in member functions
   pGains = hGains_;

diff --git a/CondFormats/CSCObjects/test/CSCGainsStudy.h b/CondFormats/CSCObjects/test/CSCGainsStudy.h
@@ -11,7 +11,7 @@
  *
  */
 
-#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
 #include "DataFormats/Common/interface/Handle.h"
 
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
@@ -36,7 +36,7 @@ namespace edm {
 
 class TFile;
 
-class CSCGainsStudy : public edm::EDAnalyzer {
+class CSCGainsStudy : public edm::one::EDAnalyzer<> {
 public:
   /// configurable parameters
   explicit CSCGainsStudy(const edm::ParameterSet& p);
@@ -112,6 +112,7 @@ class CSCGainsStudy : public edm::EDAnalyzer {
   std::string rootFileName;
 
   // Store in memory the Gains
+  const edm::ESGetToken<CSCGains, CSCGainsRcd> gainsToken;
   const CSCGains* pGains;
 };
 

diff --git a/CondFormats/CSCObjects/test/stubs/CSCChipSpeedCorrectionDBReadAnalyzer.cc b/CondFormats/CSCObjects/test/stubs/CSCChipSpeedCorrectionDBReadAnalyzer.cc
@@ -6,28 +6,28 @@ Toy EDProducers and EDProducts for testing purposes only.
 
 #include <stdexcept>
 #include <string>
-#include <iostream>
 #include <fstream>
-#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
 #include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/MakerMacros.h"
 
 #include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
 #include "CondFormats/CSCObjects/interface/CSCDBChipSpeedCorrection.h"
 #include "CondFormats/DataRecord/interface/CSCDBChipSpeedCorrectionRcd.h"
 
 namespace edmtest {
-  class CSCChipSpeedCorrectionDBReadAnalyzer : public edm::EDAnalyzer {
+  class CSCChipSpeedCorrectionDBReadAnalyzer : public edm::one::EDAnalyzer<> {
   public:
-    explicit CSCChipSpeedCorrectionDBReadAnalyzer(edm::ParameterSet const& p) {}
-    explicit CSCChipSpeedCorrectionDBReadAnalyzer(int i) {}
-    virtual ~CSCChipSpeedCorrectionDBReadAnalyzer() {}
-    virtual void analyze(const edm::Event& e, const edm::EventSetup& c);
+    explicit CSCChipSpeedCorrectionDBReadAnalyzer(edm::ParameterSet const& p) : token_{esConsumes()} {}
+    ~CSCChipSpeedCorrectionDBReadAnalyzer() override {}
+    void analyze(const edm::Event& e, const edm::EventSetup& c) override;
 
   private:
+    edm::ESGetToken<CSCDBChipSpeedCorrection, CSCDBChipSpeedCorrectionRcd> token_;
   };
 
   void CSCChipSpeedCorrectionDBReadAnalyzer::analyze(const edm::Event& e, const edm::EventSetup& context) {
@@ -38,12 +38,12 @@ namespace edmtest {
     std::ofstream DBChipSpeedCorrectionFile("dbChipSpeedCorrection.dat", std::ios::out);
     int counter = 0;
 
-    std::cout << " I AM IN RUN NUMBER " << e.id().run() << std::endl;
-    std::cout << " ---EVENT NUMBER " << e.id().event() << std::endl;
-    edm::ESHandle<CSCDBChipSpeedCorrection> pChipCorr;
-    context.get<CSCDBChipSpeedCorrectionRcd>().get(pChipCorr);
+    edm::LogSystem log("CSCDBChipSpeedCorrection");
 
-    const CSCDBChipSpeedCorrection* myChipCorr = pChipCorr.product();
+    log << " I AM IN RUN NUMBER " << e.id().run() << std::endl;
+    log << " ---EVENT NUMBER " << e.id().event() << std::endl;
+
+    const CSCDBChipSpeedCorrection* myChipCorr = &context.getData(token_);
     CSCDBChipSpeedCorrection::ChipSpeedContainer::const_iterator it;
 
     for (it = myChipCorr->chipSpeedCorr.begin(); it != myChipCorr->chipSpeedCorr.end(); ++it) {

diff --git a/CondFormats/CSCObjects/test/stubs/CSCCrossTalkDBReadAnalyzer.cc b/CondFormats/CSCObjects/test/stubs/CSCCrossTalkDBReadAnalyzer.cc
@@ -9,38 +9,40 @@ Toy EDProducers and EDProducts for testing purposes only.
 #include <iostream>
 #include <fstream>
 
-#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
 #include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/MakerMacros.h"
 
 #include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
 #include "CondFormats/CSCObjects/interface/CSCDBCrosstalk.h"
 #include "CondFormats/DataRecord/interface/CSCDBCrosstalkRcd.h"
 
 namespace edmtest {
-  class CSCCrossTalkDBReadAnalyzer : public edm::EDAnalyzer {
+  class CSCCrossTalkDBReadAnalyzer : public edm::one::EDAnalyzer<> {
   public:
-    explicit CSCCrossTalkDBReadAnalyzer(edm::ParameterSet const& p) {}
-    explicit CSCCrossTalkDBReadAnalyzer(int i) {}
-    virtual ~CSCCrossTalkDBReadAnalyzer() {}
-    virtual void analyze(const edm::Event& e, const edm::EventSetup& c);
+    explicit CSCCrossTalkDBReadAnalyzer(edm::ParameterSet const& p) : token_{esConsumes()} {}
+    ~CSCCrossTalkDBReadAnalyzer() override {}
+    void analyze(const edm::Event& e, const edm::EventSetup& c) override;
 
   private:
+    edm::ESGetToken<CSCDBCrosstalk, CSCDBCrosstalkRcd> token_;
   };
 
   void CSCCrossTalkDBReadAnalyzer::analyze(const edm::Event& e, const edm::EventSetup& context) {
     std::ofstream DBXtalkFile("dbxtalk.dat", std::ios::out);
     int counter = 0;
     using namespace edm::eventsetup;
-    std::cout << " I AM IN RUN NUMBER " << e.id().run() << std::endl;
-    std::cout << " ---EVENT NUMBER " << e.id().event() << std::endl;
-    edm::ESHandle<CSCDBCrosstalk> pcrosstalk;
-    context.get<CSCDBCrosstalkRcd>().get(pcrosstalk);
 
-    const CSCDBCrosstalk* mycrosstalk = pcrosstalk.product();
+    edm::LogInfo log("CSCDBCrosstalk");
+    log << " I AM IN RUN NUMBER " << e.id().run() << std::endl;
+    log << " ---EVENT NUMBER " << e.id().event() << std::endl;
+
+    const CSCDBCrosstalk* mycrosstalk = &context.getData(token_);
     std::vector<CSCDBCrosstalk::Item>::const_iterator it;
     for (it = mycrosstalk->crosstalk.begin(); it != mycrosstalk->crosstalk.end(); ++it) {
       counter++;

diff --git a/CondFormats/CSCObjects/test/stubs/CSCCrossTalkReadAnalyzer.cc b/CondFormats/CSCObjects/test/stubs/CSCCrossTalkReadAnalyzer.cc
@@ -9,45 +9,47 @@ Toy EDProducers and EDProducts for testing purposes only.
 #include <iostream>
 #include <map>
 #include <vector>
-#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/Framework/interface/global/EDAnalyzer.h"
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/MakerMacros.h"
 
 #include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
+
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
 #include "CondFormats/CSCObjects/interface/CSCcrosstalk.h"
 #include "CondFormats/DataRecord/interface/CSCcrosstalkRcd.h"
 
 using namespace std;
 
 namespace edmtest {
-  class CSCCrossTalkReadAnalyzer : public edm::EDAnalyzer {
+  class CSCCrossTalkReadAnalyzer : public edm::global::EDAnalyzer<> {
   public:
-    explicit CSCCrossTalkReadAnalyzer(edm::ParameterSet const& p) {}
-    explicit CSCCrossTalkReadAnalyzer(int i) {}
-    virtual ~CSCCrossTalkReadAnalyzer() {}
-    virtual void analyze(const edm::Event& e, const edm::EventSetup& c);
+    explicit CSCCrossTalkReadAnalyzer(edm::ParameterSet const& p) : crosstalkToken_{esConsumes()} {}
+    ~CSCCrossTalkReadAnalyzer() override {}
+    void analyze(edm::StreamID, const edm::Event& e, const edm::EventSetup& c) const override;
 
   private:
+    edm::ESGetToken<CSCcrosstalk, CSCcrosstalkRcd> crosstalkToken_;
   };
 
-  void CSCCrossTalkReadAnalyzer::analyze(const edm::Event& e, const edm::EventSetup& context) {
+  void CSCCrossTalkReadAnalyzer::analyze(edm::StreamID, const edm::Event& e, const edm::EventSetup& context) const {
     using namespace edm::eventsetup;
     // Context is not used.
-    std::cout << " I AM IN RUN NUMBER " << e.id().run() << std::endl;
-    std::cout << " ---EVENT NUMBER " << e.id().event() << std::endl;
-    edm::ESHandle<CSCcrosstalk> pcrosstalk;
-    context.get<CSCcrosstalkRcd>().get(pcrosstalk);
+    edm::LogSystem log("CSCCrossTalk");
+    log << " I AM IN RUN NUMBER " << e.id().run() << std::endl;
+    log << " ---EVENT NUMBER " << e.id().event() << std::endl;
 
-    const CSCcrosstalk* mycrosstalk = pcrosstalk.product();
+    const CSCcrosstalk* mycrosstalk = &context.getData(crosstalkToken_);
     std::map<int, std::vector<CSCcrosstalk::Item> >::const_iterator it;
     for (it = mycrosstalk->crosstalk.begin(); it != mycrosstalk->crosstalk.end(); ++it) {
-      std::cout << "layer id found " << it->first << std::endl;
+      log << "layer id found " << it->first << std::endl;
       std::vector<CSCcrosstalk::Item>::const_iterator crosstalkit;
       for (crosstalkit = it->second.begin(); crosstalkit != it->second.end(); ++crosstalkit) {
-        std::cout << "  crosstalk_slope_right:  " << crosstalkit->xtalk_slope_right
-                  << " crosstalk_intercept_right: " << crosstalkit->xtalk_intercept_right << std::endl;
+        log << "  crosstalk_slope_right:  " << crosstalkit->xtalk_slope_right
+            << " crosstalk_intercept_right: " << crosstalkit->xtalk_intercept_right << std::endl;
       }
     }
   }

diff --git a/CondFormats/CSCObjects/test/stubs/CSCGainsDBReadAnalyzer.cc b/CondFormats/CSCObjects/test/stubs/CSCGainsDBReadAnalyzer.cc
@@ -8,38 +8,40 @@ Toy EDProducers and EDProducts for testing purposes only.
 #include <string>
 #include <iostream>
 #include <fstream>
-#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
 #include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/MakerMacros.h"
 
 #include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
 #include "CondFormats/CSCObjects/interface/CSCDBGains.h"
 #include "CondFormats/DataRecord/interface/CSCDBGainsRcd.h"
 
 namespace edmtest {
-  class CSCGainsDBReadAnalyzer : public edm::EDAnalyzer {
+  class CSCGainsDBReadAnalyzer : public edm::one::EDAnalyzer<> {
   public:
-    explicit CSCGainsDBReadAnalyzer(edm::ParameterSet const& p) {}
-    explicit CSCGainsDBReadAnalyzer(int i) {}
-    virtual ~CSCGainsDBReadAnalyzer() {}
-    virtual void analyze(const edm::Event& e, const edm::EventSetup& c);
+    explicit CSCGainsDBReadAnalyzer(edm::ParameterSet const& p) : token_{esConsumes()} {}
+    ~CSCGainsDBReadAnalyzer() override {}
+    void analyze(const edm::Event& e, const edm::EventSetup& c) override;
 
   private:
+    edm::ESGetToken<CSCDBGains, CSCDBGainsRcd> token_;
   };
 
   void CSCGainsDBReadAnalyzer::analyze(const edm::Event& e, const edm::EventSetup& context) {
     using namespace edm::eventsetup;
     std::ofstream DBGainsFile("dbgains.dat", std::ios::out);
     int counter = 0;
-    std::cout << " I AM IN RUN NUMBER " << e.id().run() << std::endl;
-    std::cout << " ---EVENT NUMBER " << e.id().event() << std::endl;
-    edm::ESHandle<CSCDBGains> pGains;
-    context.get<CSCDBGainsRcd>().get(pGains);
 
-    const CSCDBGains* mygains = pGains.product();
+    edm::LogInfo log("CSCDBGains");
+    log << " I AM IN RUN NUMBER " << e.id().run() << std::endl;
+    log << " ---EVENT NUMBER " << e.id().event() << std::endl;
+
+    const CSCDBGains* mygains = &context.getData(token_);
     std::vector<CSCDBGains::Item>::const_iterator it;
 
     for (it = mygains->gains.begin(); it != mygains->gains.end(); ++it) {

diff --git a/CondFormats/CSCObjects/test/stubs/CSCGainsReadAnalyzer.cc b/CondFormats/CSCObjects/test/stubs/CSCGainsReadAnalyzer.cc
@@ -6,47 +6,48 @@ Toy EDProducers and EDProducts for testing purposes only.
 
 #include <stdexcept>
 #include <string>
-#include <iostream>
 #include <map>
 #include <vector>
-#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/Framework/interface/global/EDAnalyzer.h"
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/MakerMacros.h"
 
 #include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
+
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
 #include "CondFormats/CSCObjects/interface/CSCGains.h"
 #include "CondFormats/DataRecord/interface/CSCGainsRcd.h"
 
 using namespace std;
 
 namespace edmtest {
-  class CSCGainsReadAnalyzer : public edm::EDAnalyzer {
+  class CSCGainsReadAnalyzer : public edm::global::EDAnalyzer<> {
   public:
-    explicit CSCGainsReadAnalyzer(edm::ParameterSet const& p) {}
-    explicit CSCGainsReadAnalyzer(int i) {}
-    virtual ~CSCGainsReadAnalyzer() {}
-    virtual void analyze(const edm::Event& e, const edm::EventSetup& c);
+    explicit CSCGainsReadAnalyzer(edm::ParameterSet const& p) : gainsToken_{esConsumes()} {}
+    ~CSCGainsReadAnalyzer() override {}
+    void analyze(edm::StreamID, const edm::Event& e, const edm::EventSetup& c) const override;
 
   private:
+    edm::ESGetToken<CSCGains, CSCGainsRcd> gainsToken_;
   };
 
-  void CSCGainsReadAnalyzer::analyze(const edm::Event& e, const edm::EventSetup& context) {
+  void CSCGainsReadAnalyzer::analyze(edm::StreamID, const edm::Event& e, const edm::EventSetup& context) const {
     using namespace edm::eventsetup;
-    // Context is not used.
-    std::cout << " I AM IN RUN NUMBER " << e.id().run() << std::endl;
-    std::cout << " ---EVENT NUMBER " << e.id().event() << std::endl;
-    edm::ESHandle<CSCGains> pGains;
-    context.get<CSCGainsRcd>().get(pGains);
 
-    const CSCGains* mygains = pGains.product();
+    edm::LogSystem log("CSCGains");
+    log << " I AM IN RUN NUMBER " << e.id().run() << std::endl;
+    log << " ---EVENT NUMBER " << e.id().event() << std::endl;
+
+    const CSCGains* mygains = &context.getData(gainsToken_);
     std::map<int, std::vector<CSCGains::Item> >::const_iterator it;
     for (it = mygains->gains.begin(); it != mygains->gains.end(); ++it) {
-      std::cout << "layer id found " << it->first << std::endl;
+      log << "layer id found " << it->first << std::endl;
       std::vector<CSCGains::Item>::const_iterator gainsit;
       for (gainsit = it->second.begin(); gainsit != it->second.end(); ++gainsit) {
-        std::cout << "  gains:  " << gainsit->gain_slope << " intercept: " << gainsit->gain_intercept << std::endl;
+        log << "  gains:  " << gainsit->gain_slope << " intercept: " << gainsit->gain_intercept << std::endl;
       }
     }
   }