File indexing completed on 2023-05-16 00:57:40
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020 #include <memory>
0021 #include <string>
0022 #include <fstream>
0023 #include <iostream>
0024 #include <ctime>
0025
0026
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
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
0059 const edm::ESGetToken<BeamSpotObjects, BeamSpotObjectsRcd> bsToken_;
0060
0061
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
0068 const bool fIsHLT_;
0069 uint32_t fIOVStartRun_;
0070 uint32_t fIOVStartLumi_;
0071 cond::Time_t fnewSince_;
0072 bool fuseNewSince_;
0073 };
0074
0075
0076
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
0109
0110
0111
0112 cond::Time_t BeamSpotOnlineFromOfflineConverter::pack(uint32_t fIOVStartRun, uint32_t fIOVStartLumi) {
0113 return ((uint64_t)fIOVStartRun << 32 | fIOVStartLumi);
0114 }
0115
0116
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
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
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
0194 DEFINE_FWK_MODULE(BeamSpotOnlineFromOfflineConverter);