Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-03-10 23:53:30 

0001 /** \class MEtoEDMConverter
0002  *
0003  *  Class to take dqm monitor elements and convert into a
0004  *  ROOT dataformat stored in Run tree of edm file
0005  *
0006  *  \author M. Strang SUNY-Buffalo
0007  */
0008 
0009 // framework & common header files
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 //DQM services
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 // helper files
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 }  // namespace meedm
0062 
0063 //Using RunCache and LuminosityBlockCache tells the framework the module is able to
0064 // allow multiple concurrent Runs and LuminosityBlocks.
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   // private statistics information
0099   std::map<int, int> iCount;
0100   edm::GetterOfProducts<DQMToken> lumigetter_;
0101   edm::GetterOfProducts<DQMToken> rungetter_;
0102 
0103 };  // end class declaration
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   // get information from parameter set
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   // use value of first digit to determine default output level (inclusive)
0116   // 0 is none, 1 is basic, 2 is fill output, 3 is gather output
0117   verbosity %= 10;
0118 
0119   // print out Parameter Set information being used
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   // create persistent objects
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   // extract ME information into vectors
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     // store only flagged ME at endLumi transition, and Run-based
0238     // histo at endRun transition
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     // store only flagged ME at endLumi transition, and Run-based
0333     // histo at endRun transition
0334     // DQMStore should only hand out matching MEs
0335     assert(iLumiOnly == me->getLumiFlag());
0336 
0337     // get monitor elements
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   }  // end loop through monitor elements
0407 
0408   std::string sName;
0409 
0410   if (iLumiOnly) {
0411     sName = fName + "Lumi";
0412   } else {
0413     sName = fName + "Run";
0414   }
0415 
0416   // produce objects to put in events
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);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!