File indexing completed on 2022-07-10 22:32:56
0001 #ifndef CommonTools_ConditionDBWriter_ConditionDBWriter_h
0002 #define CommonTools_ConditionDBWriter_ConditionDBWriter_h
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047
0048
0049
0050
0051
0052
0053
0054
0055
0056
0057
0058
0059
0060
0061
0062
0063
0064
0065
0066
0067
0068
0069
0070
0071
0072
0073
0074
0075
0076
0077
0078
0079
0080
0081
0082
0083
0084
0085
0086
0087
0088
0089
0090
0091
0092
0093
0094
0095
0096
0097
0098
0099
0100
0101
0102
0103
0104
0105
0106
0107
0108
0109
0110
0111
0112
0113
0114
0115
0116
0117
0118
0119
0120
0121
0122
0123
0124
0125
0126
0127 #include <memory>
0128 #include <string>
0129 #include <cstdlib>
0130
0131
0132 #include "FWCore/Framework/interface/Frameworkfwd.h"
0133 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0134 #include "FWCore/Framework/interface/Run.h"
0135 #include "FWCore/Framework/interface/ESHandle.h"
0136 #include "FWCore/ServiceRegistry/interface/Service.h"
0137 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0138 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0139 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0140 #include "CondCore/DBOutputService/interface/PoolDBOutputService.h"
0141 #include "CommonTools/UtilAlgos/interface/TFileService.h"
0142
0143 #include "FWCore/Utilities/interface/Exception.h"
0144
0145
0146 #include "FWCore/Framework/interface/Event.h"
0147 #include "DataFormats/Common/interface/Handle.h"
0148
0149 template <class T>
0150 class ConditionDBWriter
0151 : public edm::one::EDAnalyzer<edm::one::WatchRuns, edm::one::WatchLuminosityBlocks, edm::one::SharedResources> {
0152 public:
0153 explicit ConditionDBWriter(const edm::ParameterSet &iConfig)
0154 : minRunRange_(1 << 31),
0155 maxRunRange_(0),
0156 LumiBlockMode_(false),
0157 RunMode_(false),
0158 JobMode_(false),
0159 AlgoDrivenMode_(false),
0160 Time_(0),
0161 setSinceTime_(false),
0162 firstRun_(true) {
0163 edm::LogInfo("ConditionDBWriter::ConditionDBWriter()") << std::endl;
0164 SinceAppendMode_ = iConfig.getParameter<bool>("SinceAppendMode");
0165 std::string IOVMode = iConfig.getParameter<std::string>("IOVMode");
0166 if (IOVMode == std::string("Job"))
0167 JobMode_ = true;
0168 else if (IOVMode == std::string("Run"))
0169 RunMode_ = true;
0170 else if (IOVMode == std::string("LumiBlock"))
0171 LumiBlockMode_ = true;
0172 else if (IOVMode == std::string("AlgoDriven"))
0173 AlgoDrivenMode_ = true;
0174 else
0175 edm::LogError(
0176 "ConditionDBWriter::ConditionDBWriter(): ERROR - unknown IOV interval write mode...will not store anything "
0177 "on the DB")
0178 << std::endl;
0179 Record_ = iConfig.getParameter<std::string>("Record");
0180 doStore_ = iConfig.getParameter<bool>("doStoreOnDB");
0181 timeFromEndRun_ = iConfig.getUntrackedParameter<bool>("TimeFromEndRun", false);
0182 timeFromStartOfRunRange_ = iConfig.getUntrackedParameter<bool>("TimeFromStartOfRunRange", false);
0183
0184 if (!SinceAppendMode_)
0185 edm::LogError("ConditionDBWriter::endJob(): ERROR - only SinceAppendMode support!!!!");
0186 }
0187
0188 ~ConditionDBWriter() override { edm::LogInfo("ConditionDBWriter::~ConditionDBWriter()") << std::endl; }
0189
0190
0191 static void fillPSetDescription(edm::ParameterSetDescription &desc) {
0192 desc.add<bool>("SinceAppendMode");
0193 desc.add<std::string>("IOVMode");
0194 desc.add<std::string>("Record");
0195 desc.add<bool>("doStoreOnDB");
0196 desc.addUntracked<bool>("TimeFromEndRun", false);
0197 desc.addUntracked<bool>("TimeFromStartOfRunRange", false);
0198 }
0199
0200 private:
0201
0202
0203 virtual std::unique_ptr<T> getNewObject() = 0;
0204
0205
0206
0207
0208 virtual void algoBeginJob(const edm::EventSetup &){};
0209
0210 virtual void algoBeginRun(const edm::Run &, const edm::EventSetup &){};
0211
0212 virtual void algoBeginLuminosityBlock(const edm::LuminosityBlock &, const edm::EventSetup &){};
0213
0214 virtual void algoAnalyze(const edm::Event &, const edm::EventSetup &){};
0215
0216 virtual void algoEndRun(const edm::Run &, const edm::EventSetup &){};
0217
0218 virtual void algoEndJob(){};
0219
0220 void beginJob() override {}
0221
0222 void beginRun(const edm::Run &run, const edm::EventSetup &es) override {
0223 if (firstRun_) {
0224 edm::LogInfo("ConditionDBWriter::beginJob") << std::endl;
0225 if ((JobMode_ || AlgoDrivenMode_) && SinceAppendMode_)
0226 setSinceTime_ = true;
0227 algoBeginJob(es);
0228 firstRun_ = false;
0229 }
0230
0231 if (run.id().run() < minRunRange_)
0232 minRunRange_ = run.id().run();
0233 if (run.id().run() > maxRunRange_)
0234 maxRunRange_ = run.id().run();
0235
0236 edm::LogInfo("ConditionDBWriter::beginRun") << std::endl;
0237 if (RunMode_ && SinceAppendMode_)
0238 setSinceTime_ = true;
0239 algoBeginRun(run, es);
0240 }
0241
0242 void beginLuminosityBlock(const edm::LuminosityBlock &lumiBlock, const edm::EventSetup &iSetup) override {
0243 edm::LogInfo("ConditionDBWriter::beginLuminosityBlock") << std::endl;
0244 if (LumiBlockMode_ && SinceAppendMode_)
0245 setSinceTime_ = true;
0246 algoBeginLuminosityBlock(lumiBlock, iSetup);
0247 }
0248
0249 void analyze(const edm::Event &event, const edm::EventSetup &iSetup) override {
0250 if (setSinceTime_) {
0251 setTime();
0252 setSinceTime_ = false;
0253 }
0254 algoAnalyze(event, iSetup);
0255 }
0256
0257 void endLuminosityBlock(const edm::LuminosityBlock &lumiBlock, const edm::EventSetup &es) override {
0258 edm::LogInfo("ConditionDBWriter::endLuminosityBlock") << std::endl;
0259 algoEndLuminosityBlock(lumiBlock, es);
0260
0261 if (LumiBlockMode_) {
0262 std::unique_ptr<T> objPointer = getNewObject();
0263
0264 if (objPointer) {
0265 storeOnDb(objPointer);
0266 } else {
0267 edm::LogError(
0268 "ConditionDBWriter::endLuminosityblock(): ERROR - requested to store on DB on a Lumi Block based interval, "
0269 "but received null pointer...will not store anything on the DB")
0270 << std::endl;
0271 }
0272 }
0273 }
0274
0275 virtual void algoEndLuminosityBlock(const edm::LuminosityBlock &, const edm::EventSetup &){};
0276
0277 void endRun(const edm::Run &run, const edm::EventSetup &es) override {
0278 edm::LogInfo("ConditionDBWriter::endRun") << std::endl;
0279
0280 algoEndRun(run, es);
0281
0282 if (RunMode_) {
0283 std::unique_ptr<T> objPointer = getNewObject();
0284
0285 if (objPointer) {
0286 if (timeFromEndRun_)
0287 Time_ = run.id().run();
0288 storeOnDb(objPointer);
0289 } else {
0290 edm::LogError(
0291 "ConditionDBWriter::endRun(): ERROR - requested to store on DB on a Run based interval, but received null "
0292 "pointer...will not store anything on the DB")
0293 << std::endl;
0294 }
0295 }
0296 }
0297
0298 void endJob() override {
0299 edm::LogInfo("ConditionDBWriter::endJob") << std::endl;
0300
0301 algoEndJob();
0302
0303 if (JobMode_) {
0304 std::unique_ptr<T> objPointer = getNewObject();
0305
0306 if (objPointer) {
0307 storeOnDb(objPointer);
0308 }
0309
0310 else {
0311 edm::LogError(
0312 "ConditionDBWriter::endJob(): ERROR - requested to store on DB on a Job based interval, but received null "
0313 "pointer...will not store anything on the DB")
0314 << std::endl;
0315 }
0316 }
0317 }
0318
0319 void storeOnDb(std::unique_ptr<T> &objPointer) {
0320 edm::LogInfo("ConditionDBWriter::storeOnDb ") << std::endl;
0321
0322 setSinceTime_ = true;
0323
0324 if (!objPointer) {
0325 edm::LogError("ConditionDBWriter: Pointer to object has not been set...storing no data on DB");
0326 return;
0327 }
0328
0329
0330 if (!doStore_)
0331 return;
0332 edm::Service<cond::service::PoolDBOutputService> mydbservice;
0333 if (!mydbservice.isAvailable()) {
0334 edm::LogError("ConditionDBWriter") << "PoolDBOutputService is unavailable" << std::endl;
0335 return;
0336 }
0337
0338 cond::Time_t since =
0339 (mydbservice->isNewTagRequest(Record_) && !timeFromEndRun_) ? mydbservice->beginOfTime() : Time_;
0340
0341
0342 if (timeFromStartOfRunRange_)
0343 since = minRunRange_;
0344
0345 edm::LogInfo("ConditionDBWriter") << "appending a new object to tag " << Record_ << " in since mode " << std::endl;
0346
0347 mydbservice->writeOneIOV<T>(*objPointer, since, Record_);
0348 }
0349
0350 void setTime() {
0351 edm::Service<cond::service::PoolDBOutputService> mydbservice;
0352
0353 if (mydbservice.isAvailable()) {
0354 Time_ = mydbservice->currentTime();
0355 edm::LogInfo("ConditionDBWriter::setTime: time set to ") << Time_ << std::endl;
0356 } else {
0357 edm::LogError("ConditionDBWriter::setTime(): PoolDBOutputService is not available...cannot set current time")
0358 << std::endl;
0359 }
0360 }
0361
0362 protected:
0363
0364
0365 void storeOnDbNow() {
0366 if (AlgoDrivenMode_) {
0367 setSinceTime_ = true;
0368
0369 std::unique_ptr<T> objPointer = getNewObject();
0370
0371 if (!objPointer) {
0372 edm::LogError(
0373 "ConditionDBWriter::storeOnDbNow: ERROR - requested to store on DB a new object (module configuration is "
0374 "algo driven based IOV), but received NULL pointer...will not store anything on the DB")
0375 << std::endl;
0376 return;
0377 } else {
0378 storeOnDb(objPointer);
0379 }
0380
0381 } else {
0382 edm::LogError(
0383 "ConditionDBWriter::storeOnDbNow(): ERROR - received a direct request from concrete algorithm to store on DB "
0384 "a new object, but module configuration is not to store on DB on an algo driven based interval...will not "
0385 "store anything on the DB")
0386 << std::endl;
0387 return;
0388 }
0389 }
0390
0391
0392
0393 cond::Time_t timeOfLastIOV() { return Time_; }
0394
0395
0396 void setDoStore(const bool doStore) { doStore_ = doStore; }
0397
0398 private:
0399 unsigned int minRunRange_;
0400 unsigned int maxRunRange_;
0401
0402 bool SinceAppendMode_;
0403
0404 bool LumiBlockMode_;
0405 bool RunMode_;
0406 bool JobMode_;
0407 bool AlgoDrivenMode_;
0408 bool doStore_;
0409
0410 std::string Record_;
0411 cond::Time_t
0412 Time_;
0413
0414 bool setSinceTime_;
0415
0416 bool firstRun_;
0417
0418 bool timeFromEndRun_;
0419 bool timeFromStartOfRunRange_;
0420 };
0421
0422 #endif