File indexing completed on 2025-03-10 23:53:30
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010 #include "DataFormats/Common/interface/Handle.h"
0011 #include "DataFormats/Histograms/interface/DQMToken.h"
0012 #include "DataFormats/Histograms/interface/MEtoEDMFormat.h"
0013 #include "DataFormats/Provenance/interface/Provenance.h"
0014 #include "FWCore/Framework/interface/ESHandle.h"
0015 #include "FWCore/Framework/interface/Event.h"
0016 #include "FWCore/Framework/interface/EventSetup.h"
0017 #include "FWCore/Framework/interface/Frameworkfwd.h"
0018 #include "FWCore/Framework/interface/LuminosityBlock.h"
0019 #include "FWCore/Framework/interface/MakerMacros.h"
0020 #include "FWCore/Framework/interface/Run.h"
0021 #include "FWCore/Framework/interface/one/EDProducer.h"
0022 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0023 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0024 #include "FWCore/Framework/interface/GetterOfProducts.h"
0025 #include "FWCore/Framework/interface/ProcessMatch.h"
0026
0027
0028 #include "DQMServices/Core/interface/DQMStore.h"
0029 #include "FWCore/ServiceRegistry/interface/Service.h"
0030
0031 #include "classlib/utils/StringList.h"
0032 #include "classlib/utils/StringOps.h"
0033
0034
0035 #include <iostream>
0036 #include <cstdlib>
0037 #include <string>
0038 #include <memory>
0039 #include <vector>
0040 #include <map>
0041 #include <cassert>
0042 #include <cstdint>
0043
0044 #include "TString.h"
0045 #include "TH1F.h"
0046 #include "TH1S.h"
0047 #include "TH1D.h"
0048 #include "TH1I.h"
0049 #include "TH2F.h"
0050 #include "TH2S.h"
0051 #include "TH2D.h"
0052 #include "TH2I.h"
0053 #include "TH2Poly.h"
0054 #include "TH3F.h"
0055 #include "TProfile.h"
0056 #include "TProfile2D.h"
0057 #include "TObjString.h"
0058
0059 namespace meedm {
0060 struct Void {};
0061 }
0062
0063
0064
0065
0066 class MEtoEDMConverter : public edm::one::EDProducer<edm::RunCache<meedm::Void>,
0067 edm::LuminosityBlockCache<meedm::Void>,
0068 edm::EndLuminosityBlockProducer,
0069 edm::EndRunProducer,
0070 edm::one::SharedResources> {
0071 public:
0072 typedef dqm::legacy::DQMStore DQMStore;
0073 typedef dqm::legacy::MonitorElement MonitorElement;
0074
0075 explicit MEtoEDMConverter(const edm::ParameterSet&);
0076 ~MEtoEDMConverter() override;
0077 void beginJob() override;
0078 void produce(edm::Event&, const edm::EventSetup&) override;
0079 std::shared_ptr<meedm::Void> globalBeginRun(edm::Run const&, const edm::EventSetup&) const override;
0080 void globalEndRun(edm::Run const&, const edm::EventSetup&) override;
0081 void endRunProduce(edm::Run&, const edm::EventSetup&) override;
0082 void endLuminosityBlockProduce(edm::LuminosityBlock&, const edm::EventSetup&) override;
0083 void globalEndLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override {}
0084 std::shared_ptr<meedm::Void> globalBeginLuminosityBlock(edm::LuminosityBlock const&,
0085 edm::EventSetup const&) const override;
0086
0087 template <class T>
0088 void putData(DQMStore::IGetter& g, T& iPutTo, bool iLumiOnly, uint32_t run, uint32_t lumi);
0089
0090 using TagList = std::vector<uint32_t>;
0091
0092 private:
0093 std::string fName;
0094 int verbosity;
0095 int frequency;
0096 std::string path;
0097
0098
0099 std::map<int, int> iCount;
0100 edm::GetterOfProducts<DQMToken> lumigetter_;
0101 edm::GetterOfProducts<DQMToken> rungetter_;
0102
0103 };
0104
0105 using namespace lat;
0106
0107 MEtoEDMConverter::MEtoEDMConverter(const edm::ParameterSet& iPSet) : fName(""), verbosity(0), frequency(0) {
0108 std::string MsgLoggerCat = "MEtoEDMConverter_MEtoEDMConverter";
0109
0110
0111 fName = iPSet.getUntrackedParameter<std::string>("Name", "MEtoEDMConverter");
0112 verbosity = iPSet.getUntrackedParameter<int>("Verbosity", 0);
0113 frequency = iPSet.getUntrackedParameter<int>("Frequency", 50);
0114 path = iPSet.getUntrackedParameter<std::string>("MEPathToSave");
0115
0116
0117 verbosity %= 10;
0118
0119
0120 if (verbosity >= 0) {
0121 edm::LogInfo(MsgLoggerCat) << "\n===============================\n"
0122 << "Initialized as EDProducer with parameter values:\n"
0123 << " Name = " << fName << "\n"
0124 << " Verbosity = " << verbosity << "\n"
0125 << " Frequency = " << frequency << "\n"
0126 << " Path = " << path << "\n"
0127 << "===============================\n";
0128 }
0129
0130 std::string sName;
0131
0132
0133
0134 sName = fName + "Run";
0135 produces<MEtoEDM<TH1F>, edm::Transition::EndRun>(sName);
0136 produces<MEtoEDM<TH1S>, edm::Transition::EndRun>(sName);
0137 produces<MEtoEDM<TH1D>, edm::Transition::EndRun>(sName);
0138 produces<MEtoEDM<TH1I>, edm::Transition::EndRun>(sName);
0139 produces<MEtoEDM<TH2F>, edm::Transition::EndRun>(sName);
0140 produces<MEtoEDM<TH2S>, edm::Transition::EndRun>(sName);
0141 produces<MEtoEDM<TH2D>, edm::Transition::EndRun>(sName);
0142 produces<MEtoEDM<TH2I>, edm::Transition::EndRun>(sName);
0143 produces<MEtoEDM<TH2Poly>, edm::Transition::EndRun>(sName);
0144 produces<MEtoEDM<TH3F>, edm::Transition::EndRun>(sName);
0145 produces<MEtoEDM<TProfile>, edm::Transition::EndRun>(sName);
0146 produces<MEtoEDM<TProfile2D>, edm::Transition::EndRun>(sName);
0147 produces<MEtoEDM<double>, edm::Transition::EndRun>(sName);
0148 produces<MEtoEDM<long long>, edm::Transition::EndRun>(sName);
0149 produces<MEtoEDM<TString>, edm::Transition::EndRun>(sName);
0150
0151 sName = fName + "Lumi";
0152 produces<MEtoEDM<TH1F>, edm::Transition::EndLuminosityBlock>(sName);
0153 produces<MEtoEDM<TH1S>, edm::Transition::EndLuminosityBlock>(sName);
0154 produces<MEtoEDM<TH1D>, edm::Transition::EndLuminosityBlock>(sName);
0155 produces<MEtoEDM<TH1I>, edm::Transition::EndLuminosityBlock>(sName);
0156 produces<MEtoEDM<TH2F>, edm::Transition::EndLuminosityBlock>(sName);
0157 produces<MEtoEDM<TH2S>, edm::Transition::EndLuminosityBlock>(sName);
0158 produces<MEtoEDM<TH2D>, edm::Transition::EndLuminosityBlock>(sName);
0159 produces<MEtoEDM<TH2I>, edm::Transition::EndLuminosityBlock>(sName);
0160 produces<MEtoEDM<TH2Poly>, edm::Transition::EndLuminosityBlock>(sName);
0161 produces<MEtoEDM<TH3F>, edm::Transition::EndLuminosityBlock>(sName);
0162 produces<MEtoEDM<TProfile>, edm::Transition::EndLuminosityBlock>(sName);
0163 produces<MEtoEDM<TProfile2D>, edm::Transition::EndLuminosityBlock>(sName);
0164 produces<MEtoEDM<double>, edm::Transition::EndLuminosityBlock>(sName);
0165 produces<MEtoEDM<long long>, edm::Transition::EndLuminosityBlock>(sName);
0166 produces<MEtoEDM<TString>, edm::Transition::EndLuminosityBlock>(sName);
0167
0168 lumigetter_ = edm::GetterOfProducts<DQMToken>(edm::ProcessMatch("*"), this, edm::InLumi);
0169 rungetter_ = edm::GetterOfProducts<DQMToken>(edm::ProcessMatch("*"), this, edm::InRun);
0170 callWhenNewProductsRegistered([this](edm::ProductDescription const& bd) {
0171 this->lumigetter_(bd);
0172 this->rungetter_(bd);
0173 });
0174 usesResource("DQMStore");
0175
0176 static_assert(sizeof(int64_t) == sizeof(long long), "type int64_t is not the same length as long long");
0177 }
0178
0179 MEtoEDMConverter::~MEtoEDMConverter() = default;
0180
0181 void MEtoEDMConverter::beginJob() {}
0182
0183 std::shared_ptr<meedm::Void> MEtoEDMConverter::globalBeginRun(edm::Run const& iRun,
0184 const edm::EventSetup& iSetup) const {
0185 return std::shared_ptr<meedm::Void>();
0186 }
0187
0188 void MEtoEDMConverter::globalEndRun(edm::Run const& iRun, const edm::EventSetup& iSetup) {}
0189
0190 void MEtoEDMConverter::endRunProduce(edm::Run& iRun, const edm::EventSetup& iSetup) {
0191 DQMStore* store = edm::Service<DQMStore>().operator->();
0192 store->meBookerGetter([&](DQMStore::IBooker& b, DQMStore::IGetter& g) { putData(g, iRun, false, iRun.run(), 0); });
0193 }
0194
0195 std::shared_ptr<meedm::Void> MEtoEDMConverter::globalBeginLuminosityBlock(edm::LuminosityBlock const&,
0196 edm::EventSetup const&) const {
0197 return std::shared_ptr<meedm::Void>();
0198 }
0199
0200 void MEtoEDMConverter::endLuminosityBlockProduce(edm::LuminosityBlock& iLumi, const edm::EventSetup& iSetup) {
0201 DQMStore* store = edm::Service<DQMStore>().operator->();
0202 store->meBookerGetter([&](DQMStore::IBooker& b, DQMStore::IGetter& g) {
0203 putData(g, iLumi, true, iLumi.run(), iLumi.id().luminosityBlock());
0204 });
0205 }
0206
0207 template <class T>
0208 void MEtoEDMConverter::putData(DQMStore::IGetter& iGetter, T& iPutTo, bool iLumiOnly, uint32_t run, uint32_t lumi) {
0209 std::string MsgLoggerCat = "MEtoEDMConverter_putData";
0210
0211 if (verbosity > 0)
0212 edm::LogInfo(MsgLoggerCat) << "\nStoring MEtoEDM dataformat histograms.";
0213
0214
0215 std::vector<MonitorElement*>::iterator mmi, mme;
0216 std::vector<MonitorElement*> items(iGetter.getAllContents(path, run, lumi));
0217
0218 unsigned int n1F = 0;
0219 unsigned int n1S = 0;
0220 unsigned int n1D = 0;
0221 unsigned int n1I = 0;
0222 unsigned int n2F = 0;
0223 unsigned int n2S = 0;
0224 unsigned int n2D = 0;
0225 unsigned int n2I = 0;
0226 unsigned int n2P = 0;
0227 unsigned int n3F = 0;
0228 unsigned int nProf = 0;
0229 unsigned int nProf2 = 0;
0230 unsigned int nDouble = 0;
0231 unsigned int nInt64 = 0;
0232 unsigned int nString = 0;
0233
0234 for (mmi = items.begin(), mme = items.end(); mmi != mme; ++mmi) {
0235 MonitorElement* me = *mmi;
0236
0237
0238
0239 if (iLumiOnly && !me->getLumiFlag())
0240 continue;
0241 if (!iLumiOnly && me->getLumiFlag())
0242 continue;
0243
0244 switch (me->kind()) {
0245 case MonitorElement::Kind::INT:
0246 ++nInt64;
0247 break;
0248
0249 case MonitorElement::Kind::REAL:
0250 ++nDouble;
0251 break;
0252
0253 case MonitorElement::Kind::STRING:
0254 ++nString;
0255 break;
0256
0257 case MonitorElement::Kind::TH1F:
0258 ++n1F;
0259 break;
0260
0261 case MonitorElement::Kind::TH1S:
0262 ++n1S;
0263 break;
0264
0265 case MonitorElement::Kind::TH1D:
0266 ++n1D;
0267 break;
0268
0269 case MonitorElement::Kind::TH1I:
0270 ++n1I;
0271 break;
0272
0273 case MonitorElement::Kind::TH2F:
0274 ++n2F;
0275 break;
0276
0277 case MonitorElement::Kind::TH2S:
0278 ++n2S;
0279 break;
0280
0281 case MonitorElement::Kind::TH2D:
0282 ++n2D;
0283 break;
0284
0285 case MonitorElement::Kind::TH2I:
0286 ++n2I;
0287 break;
0288
0289 case MonitorElement::Kind::TH2Poly:
0290 ++n2P;
0291 break;
0292
0293 case MonitorElement::Kind::TH3F:
0294 ++n3F;
0295 break;
0296
0297 case MonitorElement::Kind::TPROFILE:
0298 ++nProf;
0299 break;
0300
0301 case MonitorElement::Kind::TPROFILE2D:
0302 ++nProf2;
0303 break;
0304
0305 default:
0306 edm::LogError(MsgLoggerCat) << "ERROR: The DQM object '" << me->getFullname()
0307 << "' is neither a ROOT object nor a recognised "
0308 << "simple object.\n";
0309 continue;
0310 }
0311 }
0312
0313 std::unique_ptr<MEtoEDM<long long> > pOutInt(new MEtoEDM<long long>(nInt64));
0314 std::unique_ptr<MEtoEDM<double> > pOutDouble(new MEtoEDM<double>(nDouble));
0315 std::unique_ptr<MEtoEDM<TString> > pOutString(new MEtoEDM<TString>(nString));
0316 std::unique_ptr<MEtoEDM<TH1F> > pOut1(new MEtoEDM<TH1F>(n1F));
0317 std::unique_ptr<MEtoEDM<TH1S> > pOut1s(new MEtoEDM<TH1S>(n1S));
0318 std::unique_ptr<MEtoEDM<TH1D> > pOut1d(new MEtoEDM<TH1D>(n1D));
0319 std::unique_ptr<MEtoEDM<TH1I> > pOut1i(new MEtoEDM<TH1I>(n1I));
0320 std::unique_ptr<MEtoEDM<TH2F> > pOut2(new MEtoEDM<TH2F>(n2F));
0321 std::unique_ptr<MEtoEDM<TH2S> > pOut2s(new MEtoEDM<TH2S>(n2S));
0322 std::unique_ptr<MEtoEDM<TH2D> > pOut2d(new MEtoEDM<TH2D>(n2D));
0323 std::unique_ptr<MEtoEDM<TH2I> > pOut2i(new MEtoEDM<TH2I>(n2I));
0324 std::unique_ptr<MEtoEDM<TH2Poly> > pOut2p(new MEtoEDM<TH2Poly>(n2P));
0325 std::unique_ptr<MEtoEDM<TH3F> > pOut3(new MEtoEDM<TH3F>(n3F));
0326 std::unique_ptr<MEtoEDM<TProfile> > pOutProf(new MEtoEDM<TProfile>(nProf));
0327 std::unique_ptr<MEtoEDM<TProfile2D> > pOutProf2(new MEtoEDM<TProfile2D>(nProf2));
0328
0329 for (mmi = items.begin(), mme = items.end(); mmi != mme; ++mmi) {
0330 MonitorElement* me = *mmi;
0331
0332
0333
0334
0335 assert(iLumiOnly == me->getLumiFlag());
0336
0337
0338 switch (me->kind()) {
0339 case MonitorElement::Kind::INT:
0340 pOutInt->putMEtoEdmObject(me->getFullname(), me->getIntValue());
0341 break;
0342
0343 case MonitorElement::Kind::REAL:
0344 pOutDouble->putMEtoEdmObject(me->getFullname(), me->getFloatValue());
0345 break;
0346
0347 case MonitorElement::Kind::STRING:
0348 pOutString->putMEtoEdmObject(me->getFullname(), me->getStringValue());
0349 break;
0350
0351 case MonitorElement::Kind::TH1F:
0352 pOut1->putMEtoEdmObject(me->getFullname(), *me->getTH1F());
0353 break;
0354
0355 case MonitorElement::Kind::TH1S:
0356 pOut1s->putMEtoEdmObject(me->getFullname(), *me->getTH1S());
0357 break;
0358
0359 case MonitorElement::Kind::TH1D:
0360 pOut1d->putMEtoEdmObject(me->getFullname(), *me->getTH1D());
0361 break;
0362
0363 case MonitorElement::Kind::TH1I:
0364 pOut1i->putMEtoEdmObject(me->getFullname(), *me->getTH1I());
0365 break;
0366
0367 case MonitorElement::Kind::TH2F:
0368 pOut2->putMEtoEdmObject(me->getFullname(), *me->getTH2F());
0369 break;
0370
0371 case MonitorElement::Kind::TH2S:
0372 pOut2s->putMEtoEdmObject(me->getFullname(), *me->getTH2S());
0373 break;
0374
0375 case MonitorElement::Kind::TH2D:
0376 pOut2d->putMEtoEdmObject(me->getFullname(), *me->getTH2D());
0377 break;
0378
0379 case MonitorElement::Kind::TH2I:
0380 pOut2i->putMEtoEdmObject(me->getFullname(), *me->getTH2I());
0381 break;
0382
0383 case MonitorElement::Kind::TH2Poly:
0384 pOut2p->putMEtoEdmObject(me->getFullname(), *me->getTH2Poly());
0385 break;
0386
0387 case MonitorElement::Kind::TH3F:
0388 pOut3->putMEtoEdmObject(me->getFullname(), *me->getTH3F());
0389 break;
0390
0391 case MonitorElement::Kind::TPROFILE:
0392 pOutProf->putMEtoEdmObject(me->getFullname(), *me->getTProfile());
0393 break;
0394
0395 case MonitorElement::Kind::TPROFILE2D:
0396 pOutProf2->putMEtoEdmObject(me->getFullname(), *me->getTProfile2D());
0397 break;
0398
0399 default:
0400 edm::LogError(MsgLoggerCat) << "ERROR: The DQM object '" << me->getFullname()
0401 << "' is neither a ROOT object nor a recognised "
0402 << "simple object.\n";
0403 continue;
0404 }
0405
0406 }
0407
0408 std::string sName;
0409
0410 if (iLumiOnly) {
0411 sName = fName + "Lumi";
0412 } else {
0413 sName = fName + "Run";
0414 }
0415
0416
0417 iPutTo.put(std::move(pOutInt), sName);
0418 iPutTo.put(std::move(pOutDouble), sName);
0419 iPutTo.put(std::move(pOutString), sName);
0420 iPutTo.put(std::move(pOut1), sName);
0421 iPutTo.put(std::move(pOut1s), sName);
0422 iPutTo.put(std::move(pOut1d), sName);
0423 iPutTo.put(std::move(pOut2), sName);
0424 iPutTo.put(std::move(pOut2s), sName);
0425 iPutTo.put(std::move(pOut2d), sName);
0426 iPutTo.put(std::move(pOut2i), sName);
0427 iPutTo.put(std::move(pOut2p), sName);
0428 iPutTo.put(std::move(pOut3), sName);
0429 iPutTo.put(std::move(pOutProf), sName);
0430 iPutTo.put(std::move(pOutProf2), sName);
0431 }
0432
0433 void MEtoEDMConverter::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {}
0434
0435 #include "FWCore/PluginManager/interface/ModuleDef.h"
0436 #include "FWCore/Framework/interface/MakerMacros.h"
0437 DEFINE_FWK_MODULE(MEtoEDMConverter);