LHCInfo* validation tools

add printLHCInfoPerPayloads

disable unecessary logs from LHCInfoPerFillAnalyzer

Add lumiid timetype support for LHCInfoPerLS and LHCInfoPerFill printing

fix isseus related to DumpStats argument

Author: JanChyczynski

CondTools/RunInfo/plugins/BuildFile.xml

@@ -51,10 +51,18 @@
   <flags EDM_PLUGIN="1"/>
 </library>  
 
+<library file="LHCInfoPerLSWriter.cc" name="LHCInfoPerLSWriter">
+  <flags EDM_PLUGIN="1"/>
+</library>
+
 <library file="LHCInfoPerLSAnalyzer.cc" name="LHCInfoPerLSAnalyzer">
   <flags EDM_PLUGIN="1"/>
 </library>
 
+<library file="LHCInfoPerLSTester.cc" name="LHCInfoPerLSTester">
+  <flags EDM_PLUGIN="1"/>
+</library>
+
 <library file="LHCInfoPerFillWriter.cc" name="LHCInfoPerFillWriter">
   <flags EDM_PLUGIN="1"/>
 </library>
@@ -67,6 +75,14 @@
   <flags EDM_PLUGIN="1"/>
 </library>
 
+<library file="LHCInfoPerFillTester.cc" name="LHCInfoPerFillTester">
+  <flags EDM_PLUGIN="1"/>
+</library>
+
+<library file="LHCInfoAnalyzer.cc" name="LHCInfoAnalyzer">
+  <flags EDM_PLUGIN="1"/>
+</library>
+
 <library file="LHCInfoPerLSPopConAnalyzer.cc" name="CondToolsLHCInfoPerLSPopConAnalyzer">
   <flags EDM_PLUGIN="1"/>
 </library>

CondTools/RunInfo/plugins/LHCInfoAnalyzer.cc

@@ -0,0 +1,43 @@
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/Framework/interface/ESWatcher.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ServiceRegistry/interface/Service.h"
+
+#include "CondCore/DBOutputService/interface/PoolDBOutputService.h"
+
+#include "CondFormats/RunInfo/interface/LHCInfo.h"
+#include "CondFormats/DataRecord/interface/LHCInfoRcd.h"
+
+#include <memory>
+#include <iostream>
+
+class LHCInfoAnalyzer : public edm::one::EDAnalyzer<> {
+public:
+  explicit LHCInfoAnalyzer(const edm::ParameterSet&) : tokenInfo_(esConsumes<LHCInfo, LHCInfoRcd>()) {}
+
+private:
+  void beginJob() override {}
+  void analyze(const edm::Event&, const edm::EventSetup&) override;
+  void endJob() override {}
+
+  edm::ESWatcher<LHCInfoRcd> InfoWatcher_;
+
+  edm::ESGetToken<LHCInfo, LHCInfoRcd> tokenInfo_;
+};
+
+void LHCInfoAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
+  // get Info
+  if (InfoWatcher_.check(iSetup)) {
+    const auto& lhcInfo = iSetup.getData(tokenInfo_);
+    std::cout << "LHCInfo;" << iEvent.time().unixTime() << ";" << lhcInfo.lumiSection() << ";"
+              << lhcInfo.crossingAngle() << ";" << lhcInfo.betaStar() << ";" << lhcInfo.delivLumi() << ";" << std::endl;
+  }
+}
+
+DEFINE_FWK_MODULE(LHCInfoAnalyzer);

CondTools/RunInfo/plugins/LHCInfoPerFillAnalyzer.cc

@@ -1,3 +1,4 @@
+#include "CondFormats/Common/interface/Time.h"
 #include "FWCore/Framework/interface/Frameworkfwd.h"
 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
 #include "FWCore/Framework/interface/Event.h"
@@ -15,8 +16,9 @@
 
 class LHCInfoPerFillAnalyzer : public edm::one::EDAnalyzer<> {
 public:
-  explicit LHCInfoPerFillAnalyzer(const edm::ParameterSet&)
-      : tokenInfoPerFill_(esConsumes<LHCInfoPerFill, LHCInfoPerFillRcd>()) {}
+  explicit LHCInfoPerFillAnalyzer(const edm::ParameterSet& pset)
+      : tokenInfoPerFill_(esConsumes<LHCInfoPerFill, LHCInfoPerFillRcd>()),
+        iov_(pset.getUntrackedParameter<cond::Time_t>("iov")) {}
 
 private:
   void beginJob() override {}
@@ -26,39 +28,15 @@ class LHCInfoPerFillAnalyzer : public edm::one::EDAnalyzer<> {
   edm::ESWatcher<LHCInfoPerFillRcd> infoPerFillWatcher_;
 
   edm::ESGetToken<LHCInfoPerFill, LHCInfoPerFillRcd> tokenInfoPerFill_;
+  const cond::Time_t iov_;
 };
 
 void LHCInfoPerFillAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
   assert(infoPerFillWatcher_.check(iSetup));
 
-  LHCInfoPerFill lhcInfoPerFill = iSetup.getData(tokenInfoPerFill_);
-  const float EPS = 1E-4;
-  assert(lhcInfoPerFill.fillNumber() == 3);
-  assert(lhcInfoPerFill.bunchesInBeam1() == 10);
-  assert(lhcInfoPerFill.bunchesInBeam2() == 8);
-  assert(lhcInfoPerFill.collidingBunches() == 5);
-  assert(lhcInfoPerFill.targetBunches() == 4);
-  assert(lhcInfoPerFill.fillType() == lhcInfoPerFill.PROTONS);
-  assert(lhcInfoPerFill.particleTypeForBeam1() == lhcInfoPerFill.PROTON);
-  assert(lhcInfoPerFill.particleTypeForBeam2() == lhcInfoPerFill.PROTON);
-  assert(abs(lhcInfoPerFill.intensityForBeam1() - 1016.5) < EPS);
-  assert(abs(lhcInfoPerFill.intensityForBeam2() - 1096.66) < EPS);
-  assert(abs(lhcInfoPerFill.energy() - 7000) < EPS);
-  assert(abs(lhcInfoPerFill.delivLumi() - 2E-07) < EPS);
-  assert(abs(lhcInfoPerFill.recLumi() - 2E-07) < EPS);
-  assert(abs(lhcInfoPerFill.instLumi() - 0) < EPS);
-  assert(abs(lhcInfoPerFill.instLumiError() - 0) < EPS);
-  assert(lhcInfoPerFill.createTime() == 6561530930997627120);
-  assert(lhcInfoPerFill.beginTime() == 6561530930997627120);
-  assert(lhcInfoPerFill.endTime() == 6561530930997627120);
-  assert(lhcInfoPerFill.injectionScheme() == "None");
-  assert(lhcInfoPerFill.lumiPerBX().size() == 2);
-  assert(abs(lhcInfoPerFill.lumiPerBX()[0] - 0.000114139) < EPS);
-  assert(abs(lhcInfoPerFill.lumiPerBX()[1] - 0.000114139) < EPS);
-  assert(lhcInfoPerFill.lhcState() == "some lhcState");
-  assert(lhcInfoPerFill.lhcComment() == "some lhcComment");
-  assert(lhcInfoPerFill.ctppsStatus() == "some ctppsStatus");
-  edm::LogInfo("LHCInfoPerFillAnalyzer") << "LHCInfoPerFill retrieved:\n" << lhcInfoPerFill;
+  const LHCInfoPerFill& lhcInfoPerFill = iSetup.getData(tokenInfoPerFill_);
+
+  std::cout << "IOV " << iov_ << "\nLHCInfoPerFill retrieved:\n" << lhcInfoPerFill;
 }
 
 DEFINE_FWK_MODULE(LHCInfoPerFillAnalyzer);

CondTools/RunInfo/plugins/LHCInfoPerFillTester.cc

@@ -0,0 +1,64 @@
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/ESWatcher.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+#include "CondFormats/RunInfo/interface/LHCInfoPerFill.h"
+#include "CondFormats/DataRecord/interface/LHCInfoPerFillRcd.h"
+
+#include <memory>
+#include <iostream>
+#include <vector>
+#include <cassert>
+
+class LHCInfoPerFillTester : public edm::one::EDAnalyzer<> {
+public:
+  explicit LHCInfoPerFillTester(const edm::ParameterSet&)
+      : tokenInfoPerFill_(esConsumes<LHCInfoPerFill, LHCInfoPerFillRcd>()) {}
+
+private:
+  void beginJob() override {}
+  void analyze(const edm::Event&, const edm::EventSetup&) override;
+  void endJob() override {}
+
+  edm::ESWatcher<LHCInfoPerFillRcd> infoPerFillWatcher_;
+
+  edm::ESGetToken<LHCInfoPerFill, LHCInfoPerFillRcd> tokenInfoPerFill_;
+};
+
+void LHCInfoPerFillTester::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
+  assert(infoPerFillWatcher_.check(iSetup));
+
+  const LHCInfoPerFill& lhcInfoPerFill = iSetup.getData(tokenInfoPerFill_);
+  const float EPS = 1E-4;
+  assert(lhcInfoPerFill.fillNumber() == 3);
+  assert(lhcInfoPerFill.bunchesInBeam1() == 10);
+  assert(lhcInfoPerFill.bunchesInBeam2() == 8);
+  assert(lhcInfoPerFill.collidingBunches() == 5);
+  assert(lhcInfoPerFill.targetBunches() == 4);
+  assert(lhcInfoPerFill.fillType() == lhcInfoPerFill.PROTONS);
+  assert(lhcInfoPerFill.particleTypeForBeam1() == lhcInfoPerFill.PROTON);
+  assert(lhcInfoPerFill.particleTypeForBeam2() == lhcInfoPerFill.PROTON);
+  assert(abs(lhcInfoPerFill.intensityForBeam1() - 1016.5) < EPS);
+  assert(abs(lhcInfoPerFill.intensityForBeam2() - 1096.66) < EPS);
+  assert(abs(lhcInfoPerFill.energy() - 7000) < EPS);
+  assert(abs(lhcInfoPerFill.delivLumi() - 2E-07) < EPS);
+  assert(abs(lhcInfoPerFill.recLumi() - 2E-07) < EPS);
+  assert(abs(lhcInfoPerFill.instLumi() - 0) < EPS);
+  assert(abs(lhcInfoPerFill.instLumiError() - 0) < EPS);
+  assert(lhcInfoPerFill.createTime() == 6561530930997627120);
+  assert(lhcInfoPerFill.beginTime() == 6561530930997627120);
+  assert(lhcInfoPerFill.endTime() == 6561530930997627120);
+  assert(lhcInfoPerFill.injectionScheme() == "None");
+  assert(lhcInfoPerFill.lumiPerBX().size() == 2);
+  assert(abs(lhcInfoPerFill.lumiPerBX()[0] - 0.000114139) < EPS);
+  assert(abs(lhcInfoPerFill.lumiPerBX()[1] - 0.000114139) < EPS);
+  assert(lhcInfoPerFill.lhcState() == "some lhcState");
+  assert(lhcInfoPerFill.lhcComment() == "some lhcComment");
+  assert(lhcInfoPerFill.ctppsStatus() == "some ctppsStatus");
+  edm::LogInfo("LHCInfoPerFillTester") << "LHCInfoPerFill retrieved:\n" << lhcInfoPerFill;
+}
+
+DEFINE_FWK_MODULE(LHCInfoPerFillTester);

CondTools/RunInfo/plugins/LHCInfoPerLSAnalyzer.cc

@@ -1,9 +1,12 @@
-#include "FWCore/Framework/interface/Frameworkfwd.h"
-#include "FWCore/Framework/interface/one/EDAnalyzer.h"
+#include "CondFormats/Common/interface/Time.h"
+#include "FWCore/Framework/interface/ESWatcher.h"
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/ESWatcher.h"
+#include "FWCore/Framework/interface/Frameworkfwd.h"
 #include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
 
 #include "CondFormats/RunInfo/interface/LHCInfoPerLS.h"
 #include "CondFormats/DataRecord/interface/LHCInfoPerLSRcd.h"
@@ -14,8 +17,14 @@
 
 class LHCInfoPerLSAnalyzer : public edm::one::EDAnalyzer<> {
 public:
-  explicit LHCInfoPerLSAnalyzer(const edm::ParameterSet&)
-      : tokenInfoPerLS_(esConsumes<LHCInfoPerLS, LHCInfoPerLSRcd>()) {}
+  explicit LHCInfoPerLSAnalyzer(const edm::ParameterSet& pset)
+      : tokenInfoPerLS_(esConsumes<LHCInfoPerLS, LHCInfoPerLSRcd>()),
+        csvFormat_(pset.getUntrackedParameter<bool>("csvFormat")),
+        header_(pset.getUntrackedParameter<bool>("header")),
+        iov_(pset.getUntrackedParameter<cond::Time_t>("iov")),
+        separator_(pset.getUntrackedParameter<std::string>("separator")) {}
+
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
 private:
   void beginJob() override {}
@@ -24,22 +33,39 @@ class LHCInfoPerLSAnalyzer : public edm::one::EDAnalyzer<> {
 
   edm::ESWatcher<LHCInfoPerLSRcd> infoPerLSWatcher_;
 
-  edm::ESGetToken<LHCInfoPerLS, LHCInfoPerLSRcd> tokenInfoPerLS_;
+  const edm::ESGetToken<LHCInfoPerLS, LHCInfoPerLSRcd> tokenInfoPerLS_;
+  const bool csvFormat_;
+  const bool header_;
+  const cond::Time_t iov_;
+  const std::string separator_;
 };
 
+void LHCInfoPerLSAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+  edm::ParameterSetDescription desc;
+  desc.addUntracked<bool>("csvFormat", false);
+  desc.addUntracked<bool>("header", false);
+  desc.addUntracked<std::string>("separator", ",");
+  desc.addUntracked<cond::Time_t>("iov", 0);
+  descriptions.add("LHCInfoPerLSAnalyzer", desc);
+}
+
 void LHCInfoPerLSAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
   // get InfoPerLS
   assert(infoPerLSWatcher_.check(iSetup));
   const LHCInfoPerLS& infoPerLS = iSetup.getData(tokenInfoPerLS_);
 
-  assert(infoPerLS.fillNumber() == 7066);
-  assert(infoPerLS.lumiSection() == 1);
-  assert(infoPerLS.crossingAngleX() == 170);
-  assert(infoPerLS.crossingAngleY() == 170);
-  assert(infoPerLS.betaStarX() == 11);
-  assert(infoPerLS.betaStarY() == 11);
-  assert(infoPerLS.runNumber() == 301765);
-  edm::LogInfo("LHCInfoPerLSAnalyzer") << "LHCInfoPerLS retrieved:\n" << infoPerLS;
+  if (csvFormat_) {
+    auto s = separator_;
+    if (header_) {
+      std::cout << "IOV" << s << "class" << s << "timestamp" << s << "runNumber" << s << "LS" << s << "xangleX" << s
+                << "xangleY" << s << "beta*X" << s << "beta*Y" << s << std::endl;
+    }
+    std::cout << iov_ << s << "LHCInfoPerLS" << s << iEvent.time().unixTime() << s << infoPerLS.runNumber() << s
+              << infoPerLS.lumiSection() << s << infoPerLS.crossingAngleX() << s << infoPerLS.crossingAngleY() << s
+              << infoPerLS.betaStarX() << s << infoPerLS.betaStarY() << s << std::endl;
+  } else {
+    std::cout << infoPerLS << std::endl;
+  }
 }
 
 DEFINE_FWK_MODULE(LHCInfoPerLSAnalyzer);

CondTools/RunInfo/plugins/LHCInfoPerLSTester.cc

@@ -0,0 +1,45 @@
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/ESWatcher.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+#include "CondFormats/RunInfo/interface/LHCInfoPerLS.h"
+#include "CondFormats/DataRecord/interface/LHCInfoPerLSRcd.h"
+
+#include <memory>
+#include <iostream>
+#include <cassert>
+
+class LHCInfoPerLSTester : public edm::one::EDAnalyzer<> {
+public:
+  explicit LHCInfoPerLSTester(const edm::ParameterSet&)
+      : tokenInfoPerLS_(esConsumes<LHCInfoPerLS, LHCInfoPerLSRcd>()) {}
+
+private:
+  void beginJob() override {}
+  void analyze(const edm::Event&, const edm::EventSetup&) override;
+  void endJob() override {}
+
+  edm::ESWatcher<LHCInfoPerLSRcd> infoPerLSWatcher_;
+
+  edm::ESGetToken<LHCInfoPerLS, LHCInfoPerLSRcd> tokenInfoPerLS_;
+};
+
+void LHCInfoPerLSTester::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
+  // get InfoPerLS
+  assert(infoPerLSWatcher_.check(iSetup));
+  const LHCInfoPerLS& infoPerLS = iSetup.getData(tokenInfoPerLS_);
+
+  assert(infoPerLS.fillNumber() == 7066);
+  assert(infoPerLS.lumiSection() == 1);
+  assert(infoPerLS.crossingAngleX() == 170);
+  assert(infoPerLS.crossingAngleY() == 170);
+  assert(infoPerLS.betaStarX() == 11);
+  assert(infoPerLS.betaStarY() == 11);
+  assert(infoPerLS.runNumber() == 301765);
+  edm::LogInfo("LHCInfoPerLSTester") << "LHCInfoPerLS retrieved:\n" << infoPerLS;
+}
+
+DEFINE_FWK_MODULE(LHCInfoPerLSTester);

CondTools/RunInfo/python/LHCInfoAnalyzer_cfg.py

@@ -0,0 +1,65 @@
+import sys
+
+import FWCore.ParameterSet.Config as cms
+import FWCore.ParameterSet.VarParsing as VarParsing
+process = cms.Process('test')
+
+options = VarParsing.VarParsing()
+options.register( 'source'
+                , 'sqlite_file:lhcinfo_pop_test.db' #default value
+                , VarParsing.VarParsing.multiplicity.singleton
+                , VarParsing.VarParsing.varType.string
+                , "Connection string to the DB where payloads are going to be read from"
+                  )
+options.register( 'tag'
+                , 'LHCInfo_PopCon_test'
+                , VarParsing.VarParsing.multiplicity.singleton
+                , VarParsing.VarParsing.varType.string
+                , "Tag to read from in source"
+                  )
+options.register( 'timestamp'
+                , 7133428598295232512
+                , VarParsing.VarParsing.multiplicity.singleton
+                , VarParsing.VarParsing.varType.int
+                , "Timestamp to which payload with relavant IOV will be read"
+                  )
+options.parseArguments()
+
+# minimum logging
+process.MessageLogger = cms.Service("MessageLogger",
+    cerr = cms.untracked.PSet(
+        enable = cms.untracked.bool(False)
+    ),
+    cout = cms.untracked.PSet(
+        enable = cms.untracked.bool(True),
+        threshold = cms.untracked.string('ERROR')
+    )
+)
+
+process.source = cms.Source('EmptyIOVSource',
+    timetype = cms.string('timestamp'),
+    firstValue = cms.uint64(options.timestamp),
+    lastValue = cms.uint64(options.timestamp),
+    interval = cms.uint64(1)
+)
+
+# load info from database
+process.load('CondCore.CondDB.CondDB_cfi')
+process.CondDB.connect= options.source # SQLite input
+
+process.PoolDBESSource = cms.ESSource('PoolDBESSource',
+    process.CondDB,
+    DumpStats = cms.untracked.bool(True),
+    toGet = cms.VPSet(
+        cms.PSet(
+            record = cms.string('LHCInfoRcd'),
+            tag = cms.string(options.tag)
+        )
+    )
+)
+
+process.LHCInfoAnalyzer = cms.EDAnalyzer('LHCInfoAnalyzer')
+
+process.path = cms.Path(
+    process.LHCInfoAnalyzer
+)