BeamSpot/plugins/BeamSpotOnlineFromOfflineConverter.cc

0001 // -*- C++ -*-
0002 //
0003 // Package:    CondTools/BeamSpot
0004 // Class:      BeamSpotOnlineFromOfflineConverter
0005 //
0006 /**\class BeamSpotOnlineFromOfflineConverter BeamSpotOnlineFromOfflineConverter.cc CondTools/BeamSpot/plugins/BeamSpotOnlineFromOfflineConverter.cc
0007
0008  Description: EDAnalyzer to create a BeamSpotOnlineHLTObjectsRcd from a BeamSpotObjectsRcd (inserting some parameters manually)
0009
0010  Implementation:
0011      [Notes on implementation]
0012 */
0013 //
0014 // Original Author:  Marco Musich
0015 //         Created:  Sat, 06 May 2023 21:10:00 GMT
0016 //
0017 //
0018
0019 // system include files
0020 #include <memory>
0021 #include <string>
0022 #include <fstream>
0023 #include <iostream>
0024 #include <ctime>
0025
0026 // user include files
0027 #include "CondCore/DBOutputService/interface/PoolDBOutputService.h"
0028 #include "CondFormats/BeamSpotObjects/interface/BeamSpotObjects.h"
0029 #include "CondFormats/BeamSpotObjects/interface/BeamSpotOnlineObjects.h"
0030 #include "CondFormats/DataRecord/interface/BeamSpotObjectsRcd.h"
0031 #include "CondFormats/DataRecord/interface/BeamSpotOnlineHLTObjectsRcd.h"
0032 #include "CondFormats/DataRecord/interface/BeamSpotOnlineLegacyObjectsRcd.h"
0033 #include "FWCore/Framework/interface/ESHandle.h"
0034 #include "FWCore/Framework/interface/Event.h"
0035 #include "FWCore/Framework/interface/EventSetup.h"
0036 #include "FWCore/Framework/interface/Frameworkfwd.h"
0037 #include "FWCore/Framework/interface/MakerMacros.h"
0038 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0039 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0040 #include "FWCore/ServiceRegistry/interface/Service.h"
0041 #include "FWCore/Utilities/interface/InputTag.h"
0042
0043 //
0044 // class declaration
0045 //
0046
0047 class BeamSpotOnlineFromOfflineConverter : public edm::one::EDAnalyzer<> {
0048 public:
0049   explicit BeamSpotOnlineFromOfflineConverter(const edm::ParameterSet&);
0050   ~BeamSpotOnlineFromOfflineConverter() override = default;
0051
0052   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0053   cond::Time_t pack(uint32_t, uint32_t);
0054
0055 private:
0056   void analyze(const edm::Event&, const edm::EventSetup&) override;
0057
0058   // ----------member data ---------------------------
0059   const edm::ESGetToken<BeamSpotObjects, BeamSpotObjectsRcd> bsToken_;
0060
0061   // parameters that can't be copied from the BeamSpotObject
0062   const int lastAnalyzedLumi_, lastAnalyzedRun_, lastAnalyzedFill_;
0063   const int numTracks_, numPVs_, numUsedEvents_, numMaxPVs_;
0064   const float meanPVs_, meanPVError_, rmsPV_, rmsPVError_;
0065   const std::string startTime_, endTime_, lumiRange_;
0066
0067   // IoV-structure
0068   const bool fIsHLT_;
0069   uint32_t fIOVStartRun_;
0070   uint32_t fIOVStartLumi_;
0071   cond::Time_t fnewSince_;
0072   bool fuseNewSince_;
0073 };
0074
0075 //
0076 // constructors and destructor
0077 //
0078 BeamSpotOnlineFromOfflineConverter::BeamSpotOnlineFromOfflineConverter(const edm::ParameterSet& iConfig)
0079     : bsToken_(esConsumes()),
0080       lastAnalyzedLumi_(iConfig.getParameter<double>("lastAnalyzedLumi")),
0081       lastAnalyzedRun_(iConfig.getParameter<double>("lastAnalyzedRun")),
0082       lastAnalyzedFill_(iConfig.getParameter<double>("lastAnalyzedFill")),
0083       numTracks_(iConfig.getParameter<int>("numTracks")),
0084       numPVs_(iConfig.getParameter<int>("numPVs")),
0085       numUsedEvents_(iConfig.getParameter<int>("numUsedEvents")),
0086       numMaxPVs_(iConfig.getParameter<int>("numMaxPVs")),
0087       meanPVs_(iConfig.getParameter<double>("meanPVs")),
0088       meanPVError_(iConfig.getParameter<double>("meanPVError")),
0089       rmsPV_(iConfig.getParameter<double>("rmsPVs")),
0090       rmsPVError_(iConfig.getParameter<double>("rmsPVError")),
0091       startTime_(iConfig.getParameter<std::string>("startTime")),
0092       endTime_(iConfig.getParameter<std::string>("endTime")),
0093       lumiRange_(iConfig.getParameter<std::string>("lumiRange")),
0094       fIsHLT_(iConfig.getParameter<bool>("isHLT")) {
0095   if (iConfig.exists("IOVStartRun") && iConfig.exists("IOVStartLumi")) {
0096     fIOVStartRun_ = iConfig.getUntrackedParameter<uint32_t>("IOVStartRun");
0097     fIOVStartLumi_ = iConfig.getUntrackedParameter<uint32_t>("IOVStartLumi");
0098     fnewSince_ = BeamSpotOnlineFromOfflineConverter::pack(fIOVStartRun_, fIOVStartLumi_);
0099     fuseNewSince_ = true;
0100     edm::LogPrint("BeamSpotOnlineFromOfflineConverter") << "useNewSince = True";
0101   } else {
0102     fuseNewSince_ = false;
0103     edm::LogPrint("BeamSpotOnlineFromOfflineConverter") << "useNewSince = False";
0104   }
0105 }
0106
0107 //
0108 // member functions
0109 //
0110
0111 // ------------ Create a since object (cond::Time_t) by packing Run and LS (both uint32_t)  ------------
0112 cond::Time_t BeamSpotOnlineFromOfflineConverter::pack(uint32_t fIOVStartRun, uint32_t fIOVStartLumi) {
0113   return ((uint64_t)fIOVStartRun << 32 | fIOVStartLumi);
0114 }
0115
0116 // ------------ method called for each event  ------------
0117 void BeamSpotOnlineFromOfflineConverter::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0118   const std::string fLabel = (fIsHLT_) ? "BeamSpotOnlineHLTObjectsRcd" : "BeamSpotOnlineLegacyObjectsRcd";
0119   const BeamSpotObjects* inputSpot = &iSetup.getData(bsToken_);
0120
0121   BeamSpotOnlineObjects abeam;
0122   abeam.copyFromBeamSpotObject(*inputSpot);
0123   abeam.setLastAnalyzedLumi(lastAnalyzedLumi_);
0124   abeam.setLastAnalyzedRun(lastAnalyzedRun_);
0125   abeam.setLastAnalyzedFill(lastAnalyzedFill_);
0126   abeam.setStartTimeStamp(std::time(nullptr));
0127   abeam.setEndTimeStamp(std::time(nullptr));
0128   abeam.setNumTracks(numTracks_);
0129   abeam.setNumPVs(numPVs_);
0130   abeam.setUsedEvents(numUsedEvents_);
0131   abeam.setMaxPVs(numMaxPVs_);
0132   abeam.setMeanPV(meanPVs_);
0133   abeam.setMeanErrorPV(meanPVError_);
0134   abeam.setRmsPV(rmsPV_);
0135   abeam.setRmsErrorPV(rmsPVError_);
0136   abeam.setStartTime(startTime_);
0137   abeam.setEndTime(endTime_);
0138   abeam.setLumiRange(lumiRange_);
0139
0140   // Set the creation time of the payload to the current time
0141   auto creationTime =
0142       std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
0143   abeam.setCreationTime(creationTime);
0144
0145   edm::LogPrint("BeamSpotOnlineFromOfflineConverter") << " Writing results to DB...";
0146   edm::LogPrint("BeamSpotOnlineFromOfflineConverter") << abeam;
0147
0148   edm::Service<cond::service::PoolDBOutputService> poolDbService;
0149   if (poolDbService.isAvailable()) {
0150     edm::LogPrint("BeamSpotOnlineFromOfflineConverter") << "poolDBService available";
0151     if (poolDbService->isNewTagRequest(fLabel)) {
0152       edm::LogPrint("BeamSpotOnlineFromOfflineConverter") << "new tag requested";
0153       if (fuseNewSince_) {
0154         edm::LogPrint("BeamSpotOnlineFromOfflineConverter") << "Using a new Since: " << fnewSince_;
0155         poolDbService->createOneIOV<BeamSpotOnlineObjects>(abeam, fnewSince_, fLabel);
0156       } else
0157         poolDbService->createOneIOV<BeamSpotOnlineObjects>(abeam, poolDbService->beginOfTime(), fLabel);
0158     } else {
0159       edm::LogPrint("BeamSpotOnlineFromOfflineConverter") << "no new tag requested";
0160       if (fuseNewSince_) {
0161         edm::LogPrint("BeamSpotOnlineFromOfflineConverter") << "Using a new Since: " << fnewSince_;
0162         poolDbService->appendOneIOV<BeamSpotOnlineObjects>(abeam, fnewSince_, fLabel);
0163       } else
0164         poolDbService->appendOneIOV<BeamSpotOnlineObjects>(abeam, poolDbService->currentTime(), fLabel);
0165     }
0166   }
0167   edm::LogPrint("BeamSpotOnlineFromOfflineConverter") << "[BeamSpotOnlineFromOfflineConverter] analyze done \n";
0168 }
0169
0170 // ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
0171 void BeamSpotOnlineFromOfflineConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0172   edm::ParameterSetDescription desc;
0173   desc.add<bool>("isHLT", true);
0174   desc.addOptionalUntracked<uint32_t>("IOVStartRun", 1);
0175   desc.addOptionalUntracked<uint32_t>("IOVStartLumi", 1);
0176   desc.add<double>("lastAnalyzedLumi", 1000);
0177   desc.add<double>("lastAnalyzedRun", 1);
0178   desc.add<double>("lastAnalyzedFill", -999);
0179   desc.add<int>("numTracks", 0);
0180   desc.add<int>("numPVs", 0);
0181   desc.add<int>("numUsedEvents", 0);
0182   desc.add<int>("numMaxPVs", 0);
0183   desc.add<double>("meanPVs", 0.);
0184   desc.add<double>("meanPVError", 0.);
0185   desc.add<double>("rmsPVs", 0.);
0186   desc.add<double>("rmsPVError", 0.);
0187   desc.add<std::string>("startTime", std::string(""));
0188   desc.add<std::string>("endTime", std::string(""));
0189   desc.add<std::string>("lumiRange", std::string(""));
0190   descriptions.addWithDefaultLabel(desc);
0191 }
0192
0193 //define this as a plug-in
0194 DEFINE_FWK_MODULE(BeamSpotOnlineFromOfflineConverter);