File indexing completed on 2023-05-06 02:46:16
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014 #include <algorithm>
0015 #include <iostream>
0016 #include <memory>
0017
0018 #include <map>
0019 #include <memory>
0020 #include <string>
0021 #include <vector>
0022
0023 #include "TFile.h"
0024 #include "TTree.h"
0025 #include "TString.h"
0026 #include "TH1.h"
0027 #include "TH2.h"
0028 #include "TProfile.h"
0029
0030 #include "oneapi/tbb/task_arena.h"
0031
0032
0033 #include "FWCore/Framework/interface/GetterOfProducts.h"
0034 #include "FWCore/Framework/interface/one/OutputModule.h"
0035 #include "FWCore/Framework/interface/RunForOutput.h"
0036 #include "FWCore/Framework/interface/LuminosityBlockForOutput.h"
0037 #include "FWCore/Framework/interface/TypeMatch.h"
0038 #include "DQMServices/Core/interface/DQMStore.h"
0039 #include "FWCore/ServiceRegistry/interface/Service.h"
0040 #include "FWCore/Framework/interface/MakerMacros.h"
0041 #include "FWCore/MessageLogger/interface/JobReport.h"
0042 #include "FWCore/Utilities/interface/BranchType.h"
0043 #include "FWCore/Utilities/interface/Digest.h"
0044 #include "FWCore/Utilities/interface/GlobalIdentifier.h"
0045
0046 #include "DataFormats/Provenance/interface/ProcessHistory.h"
0047 #include "DataFormats/Provenance/interface/ProcessHistoryID.h"
0048 #include "DataFormats/Provenance/interface/ProcessHistoryRegistry.h"
0049 #include "FWCore/ParameterSet/interface/Registry.h"
0050
0051 #include "DataFormats/Histograms/interface/DQMToken.h"
0052
0053 #include "format.h"
0054
0055 namespace {
0056 typedef dqm::legacy::MonitorElement MonitorElement;
0057 typedef dqm::legacy::DQMStore DQMStore;
0058
0059 class TreeHelperBase {
0060 public:
0061 TreeHelperBase() : m_wasFilled(false), m_firstIndex(0), m_lastIndex(0) {}
0062 virtual ~TreeHelperBase() {}
0063 void fill(MonitorElement* iElement) {
0064 doFill(iElement);
0065 if (m_wasFilled) {
0066 ++m_lastIndex;
0067 }
0068 m_wasFilled = true;
0069 }
0070 bool wasFilled() const { return m_wasFilled; }
0071 void getRangeAndReset(ULong64_t& iFirstIndex, ULong64_t& iLastIndex) {
0072 iFirstIndex = m_firstIndex;
0073 iLastIndex = m_lastIndex;
0074 m_wasFilled = false;
0075 m_firstIndex = m_lastIndex + 1;
0076 m_lastIndex = m_firstIndex;
0077 }
0078
0079 private:
0080 virtual void doFill(MonitorElement*) = 0;
0081 bool m_wasFilled;
0082 ULong64_t m_firstIndex;
0083 ULong64_t m_lastIndex;
0084 };
0085
0086 template <class T>
0087 class TreeHelper : public TreeHelperBase {
0088 public:
0089 TreeHelper(TTree* iTree, std::string* iFullNameBufferPtr)
0090 : m_tree(iTree), m_flagBuffer(0), m_fullNameBufferPtr(iFullNameBufferPtr) {
0091 setup();
0092 }
0093 void doFill(MonitorElement* iElement) override {
0094 *m_fullNameBufferPtr = iElement->getFullname();
0095 m_flagBuffer = 0;
0096 m_bufferPtr = dynamic_cast<T*>(iElement->getRootObject());
0097 assert(nullptr != m_bufferPtr);
0098
0099 tbb::this_task_arena::isolate([&] { m_tree->Fill(); });
0100 }
0101
0102 private:
0103 void setup() {
0104 m_tree->Branch(kFullNameBranch, &m_fullNameBufferPtr);
0105 m_tree->Branch(kFlagBranch, &m_flagBuffer);
0106
0107 m_bufferPtr = nullptr;
0108 m_tree->Branch(kValueBranch, &m_bufferPtr, 128 * 1024, 0);
0109 }
0110 TTree* m_tree;
0111 uint32_t m_flagBuffer;
0112 std::string* m_fullNameBufferPtr;
0113 T* m_bufferPtr;
0114 };
0115
0116 class IntTreeHelper : public TreeHelperBase {
0117 public:
0118 IntTreeHelper(TTree* iTree, std::string* iFullNameBufferPtr)
0119 : m_tree(iTree), m_flagBuffer(0), m_fullNameBufferPtr(iFullNameBufferPtr) {
0120 setup();
0121 }
0122
0123 void doFill(MonitorElement* iElement) override {
0124 *m_fullNameBufferPtr = iElement->getFullname();
0125 m_flagBuffer = 0;
0126 m_buffer = iElement->getIntValue();
0127 tbb::this_task_arena::isolate([&] { m_tree->Fill(); });
0128 }
0129
0130 private:
0131 void setup() {
0132 m_tree->Branch(kFullNameBranch, &m_fullNameBufferPtr);
0133 m_tree->Branch(kFlagBranch, &m_flagBuffer);
0134 m_tree->Branch(kValueBranch, &m_buffer);
0135 }
0136 TTree* m_tree;
0137 uint32_t m_flagBuffer;
0138 std::string* m_fullNameBufferPtr;
0139 Long64_t m_buffer;
0140 };
0141
0142 class FloatTreeHelper : public TreeHelperBase {
0143 public:
0144 FloatTreeHelper(TTree* iTree, std::string* iFullNameBufferPtr)
0145 : m_tree(iTree), m_flagBuffer(0), m_fullNameBufferPtr(iFullNameBufferPtr) {
0146 setup();
0147 }
0148 void doFill(MonitorElement* iElement) override {
0149 *m_fullNameBufferPtr = iElement->getFullname();
0150 m_flagBuffer = 0;
0151 m_buffer = iElement->getFloatValue();
0152 tbb::this_task_arena::isolate([&] { m_tree->Fill(); });
0153 }
0154
0155 private:
0156 void setup() {
0157 m_tree->Branch(kFullNameBranch, &m_fullNameBufferPtr);
0158 m_tree->Branch(kFlagBranch, &m_flagBuffer);
0159 m_tree->Branch(kValueBranch, &m_buffer);
0160 }
0161
0162 TTree* m_tree;
0163 uint32_t m_flagBuffer;
0164 std::string* m_fullNameBufferPtr;
0165 double m_buffer;
0166 };
0167
0168 class StringTreeHelper : public TreeHelperBase {
0169 public:
0170 StringTreeHelper(TTree* iTree, std::string* iFullNameBufferPtr)
0171 : m_tree(iTree), m_flagBuffer(0), m_fullNameBufferPtr(iFullNameBufferPtr), m_bufferPtr(&m_buffer) {
0172 setup();
0173 }
0174 void doFill(MonitorElement* iElement) override {
0175 *m_fullNameBufferPtr = iElement->getFullname();
0176 m_flagBuffer = 0;
0177 m_buffer = iElement->getStringValue();
0178 tbb::this_task_arena::isolate([&] { m_tree->Fill(); });
0179 }
0180
0181 private:
0182 void setup() {
0183 m_tree->Branch(kFullNameBranch, &m_fullNameBufferPtr);
0184 m_tree->Branch(kFlagBranch, &m_flagBuffer);
0185 m_tree->Branch(kValueBranch, &m_bufferPtr);
0186 }
0187
0188 TTree* m_tree;
0189 uint32_t m_flagBuffer;
0190 std::string* m_fullNameBufferPtr;
0191 std::string m_buffer;
0192 std::string* m_bufferPtr;
0193 };
0194
0195 }
0196
0197 namespace edm {
0198 class ModuleCallingContext;
0199 }
0200
0201 class DQMRootOutputModule : public edm::one::OutputModule<> {
0202 public:
0203 explicit DQMRootOutputModule(edm::ParameterSet const& pset);
0204 void beginJob() override;
0205 ~DQMRootOutputModule() override;
0206 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0207
0208 private:
0209 void write(edm::EventForOutput const& e) override;
0210 void writeLuminosityBlock(edm::LuminosityBlockForOutput const&) override;
0211 void writeRun(edm::RunForOutput const&) override;
0212 bool isFileOpen() const override;
0213 void openFile(edm::FileBlock const&) override;
0214 void reallyCloseFile() override;
0215
0216 void startEndFile();
0217 void finishEndFile();
0218 std::string m_fileName;
0219 std::string m_logicalFileName;
0220 std::unique_ptr<TFile> m_file;
0221 std::vector<std::shared_ptr<TreeHelperBase> > m_treeHelpers;
0222
0223 unsigned int m_run;
0224 unsigned int m_lumi;
0225 unsigned int m_type;
0226 unsigned int m_presentHistoryIndex;
0227 ULong64_t m_beginTime;
0228 ULong64_t m_endTime;
0229 ULong64_t m_firstIndex;
0230 ULong64_t m_lastIndex;
0231 unsigned int m_filterOnRun;
0232
0233 std::string m_fullNameBuffer;
0234 std::string* m_fullNameBufferPtr;
0235 std::map<unsigned int, unsigned int> m_dqmKindToTypeIndex;
0236 TTree* m_indicesTree;
0237
0238 std::vector<edm::ProcessHistoryID> m_seenHistories;
0239 edm::ProcessHistoryRegistry m_processHistoryRegistry;
0240 edm::JobReport::Token m_jrToken;
0241
0242 edm::GetterOfProducts<DQMToken> m_getterOfProductsLumi;
0243 edm::GetterOfProducts<DQMToken> m_getterOfProductsRun;
0244 };
0245
0246
0247
0248
0249
0250 static TreeHelperBase* makeHelper(unsigned int iTypeIndex, TTree* iTree, std::string* iFullNameBufferPtr) {
0251 switch (iTypeIndex) {
0252 case kIntIndex:
0253 return new IntTreeHelper(iTree, iFullNameBufferPtr);
0254 case kFloatIndex:
0255 return new FloatTreeHelper(iTree, iFullNameBufferPtr);
0256 case kStringIndex:
0257 return new StringTreeHelper(iTree, iFullNameBufferPtr);
0258 case kTH1FIndex:
0259 return new TreeHelper<TH1F>(iTree, iFullNameBufferPtr);
0260 case kTH1SIndex:
0261 return new TreeHelper<TH1S>(iTree, iFullNameBufferPtr);
0262 case kTH1DIndex:
0263 return new TreeHelper<TH1D>(iTree, iFullNameBufferPtr);
0264 case kTH1IIndex:
0265 return new TreeHelper<TH1I>(iTree, iFullNameBufferPtr);
0266 case kTH2FIndex:
0267 return new TreeHelper<TH2F>(iTree, iFullNameBufferPtr);
0268 case kTH2SIndex:
0269 return new TreeHelper<TH2S>(iTree, iFullNameBufferPtr);
0270 case kTH2DIndex:
0271 return new TreeHelper<TH2D>(iTree, iFullNameBufferPtr);
0272 case kTH2IIndex:
0273 return new TreeHelper<TH2I>(iTree, iFullNameBufferPtr);
0274 case kTH3FIndex:
0275 return new TreeHelper<TH3F>(iTree, iFullNameBufferPtr);
0276 case kTProfileIndex:
0277 return new TreeHelper<TProfile>(iTree, iFullNameBufferPtr);
0278 case kTProfile2DIndex:
0279 return new TreeHelper<TProfile2D>(iTree, iFullNameBufferPtr);
0280 }
0281 assert(false);
0282 return nullptr;
0283 }
0284
0285
0286
0287
0288
0289
0290
0291
0292 DQMRootOutputModule::DQMRootOutputModule(edm::ParameterSet const& pset)
0293 : edm::one::OutputModuleBase::OutputModuleBase(pset),
0294 edm::one::OutputModule<>(pset),
0295 m_fileName(pset.getUntrackedParameter<std::string>("fileName")),
0296 m_logicalFileName(pset.getUntrackedParameter<std::string>("logicalFileName")),
0297 m_file(nullptr),
0298 m_treeHelpers(kNIndicies, std::shared_ptr<TreeHelperBase>()),
0299 m_presentHistoryIndex(0),
0300 m_filterOnRun(pset.getUntrackedParameter<unsigned int>("filterOnRun")),
0301 m_fullNameBufferPtr(&m_fullNameBuffer),
0302 m_indicesTree(nullptr),
0303 m_getterOfProductsLumi(edm::TypeMatch(), this, edm::InLumi),
0304 m_getterOfProductsRun(edm::TypeMatch(), this, edm::InRun) {
0305
0306
0307
0308
0309
0310
0311
0312 callWhenNewProductsRegistered([this](edm::BranchDescription const& bd) {
0313 m_getterOfProductsLumi(bd);
0314 m_getterOfProductsRun(bd);
0315 });
0316 }
0317
0318
0319
0320
0321
0322
0323 void DQMRootOutputModule::beginJob() {}
0324
0325 DQMRootOutputModule::~DQMRootOutputModule() {}
0326
0327
0328
0329
0330
0331
0332
0333
0334
0335
0336
0337
0338
0339
0340
0341
0342 bool DQMRootOutputModule::isFileOpen() const { return nullptr != m_file.get(); }
0343
0344 void DQMRootOutputModule::openFile(edm::FileBlock const&) {
0345
0346
0347 m_file = std::make_unique<TFile>(m_fileName.c_str(),
0348 "RECREATE",
0349 "1"
0350 );
0351
0352 edm::Service<edm::JobReport> jr;
0353 cms::Digest branchHash;
0354 std::string guid{edm::createGlobalIdentifier()};
0355 std::transform(guid.begin(), guid.end(), guid.begin(), (int (*)(int))std::toupper);
0356
0357 m_file->WriteObject(&guid, kCmsGuid);
0358 m_jrToken = jr->outputFileOpened(m_fileName,
0359 m_logicalFileName,
0360 std::string(),
0361 "DQMRootOutputModule",
0362 description().moduleLabel(),
0363 guid,
0364 std::string(),
0365 branchHash.digest().toString(),
0366 std::vector<std::string>());
0367
0368 m_indicesTree = new TTree(kIndicesTree, kIndicesTree);
0369 m_indicesTree->Branch(kRunBranch, &m_run);
0370 m_indicesTree->Branch(kLumiBranch, &m_lumi);
0371 m_indicesTree->Branch(kProcessHistoryIndexBranch, &m_presentHistoryIndex);
0372 m_indicesTree->Branch(kBeginTimeBranch, &m_beginTime);
0373 m_indicesTree->Branch(kEndTimeBranch, &m_endTime);
0374 m_indicesTree->Branch(kTypeBranch, &m_type);
0375 m_indicesTree->Branch(kFirstIndex, &m_firstIndex);
0376 m_indicesTree->Branch(kLastIndex, &m_lastIndex);
0377 m_indicesTree->SetDirectory(m_file.get());
0378
0379 unsigned int i = 0;
0380 for (std::vector<std::shared_ptr<TreeHelperBase> >::iterator it = m_treeHelpers.begin(), itEnd = m_treeHelpers.end();
0381 it != itEnd;
0382 ++it, ++i) {
0383
0384 TTree* tree = new TTree(kTypeNames[i], kTypeNames[i]);
0385 *it = std::shared_ptr<TreeHelperBase>(makeHelper(i, tree, m_fullNameBufferPtr));
0386 tree->SetDirectory(m_file.get());
0387 }
0388
0389 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::INT] = kIntIndex;
0390 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::REAL] = kFloatIndex;
0391 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::STRING] = kStringIndex;
0392 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH1F] = kTH1FIndex;
0393 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH1S] = kTH1SIndex;
0394 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH1D] = kTH1DIndex;
0395 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH1I] = kTH1IIndex;
0396 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH2F] = kTH2FIndex;
0397 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH2S] = kTH2SIndex;
0398 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH2D] = kTH2DIndex;
0399 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH2I] = kTH2IIndex;
0400 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH3F] = kTH3FIndex;
0401 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TPROFILE] = kTProfileIndex;
0402 m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TPROFILE2D] = kTProfile2DIndex;
0403 }
0404
0405 void DQMRootOutputModule::write(edm::EventForOutput const&) {}
0406
0407 void DQMRootOutputModule::writeLuminosityBlock(edm::LuminosityBlockForOutput const& iLumi) {
0408
0409 edm::Service<DQMStore> dstore;
0410 m_run = iLumi.id().run();
0411 m_lumi = iLumi.id().value();
0412 m_beginTime = iLumi.beginTime().value();
0413 m_endTime = iLumi.endTime().value();
0414 bool shouldWrite = (m_filterOnRun == 0 || (m_filterOnRun != 0 && m_filterOnRun == m_run));
0415
0416 if (!shouldWrite)
0417 return;
0418 std::vector<MonitorElement*> items(dstore->getAllContents("", m_run, m_lumi));
0419 for (std::vector<MonitorElement*>::iterator it = items.begin(), itEnd = items.end(); it != itEnd; ++it) {
0420 assert((*it)->getScope() == MonitorElementData::Scope::LUMI);
0421 std::map<unsigned int, unsigned int>::iterator itFound = m_dqmKindToTypeIndex.find((int)(*it)->kind());
0422 assert(itFound != m_dqmKindToTypeIndex.end());
0423 m_treeHelpers[itFound->second]->fill(*it);
0424 }
0425
0426 const edm::ProcessHistoryID& id = iLumi.processHistoryID();
0427 std::vector<edm::ProcessHistoryID>::iterator itFind = std::find(m_seenHistories.begin(), m_seenHistories.end(), id);
0428 if (itFind == m_seenHistories.end()) {
0429 m_processHistoryRegistry.registerProcessHistory(iLumi.processHistory());
0430 m_presentHistoryIndex = m_seenHistories.size();
0431 m_seenHistories.push_back(id);
0432 } else {
0433 m_presentHistoryIndex = itFind - m_seenHistories.begin();
0434 }
0435
0436
0437 bool storedLumiIndex = false;
0438 unsigned int typeIndex = 0;
0439 for (std::vector<std::shared_ptr<TreeHelperBase> >::iterator it = m_treeHelpers.begin(), itEnd = m_treeHelpers.end();
0440 it != itEnd;
0441 ++it, ++typeIndex) {
0442 if ((*it)->wasFilled()) {
0443 m_type = typeIndex;
0444 (*it)->getRangeAndReset(m_firstIndex, m_lastIndex);
0445 storedLumiIndex = true;
0446 tbb::this_task_arena::isolate([&] { m_indicesTree->Fill(); });
0447 }
0448 }
0449 if (not storedLumiIndex) {
0450
0451
0452 m_type = kNoTypesStored;
0453 m_firstIndex = 0;
0454 m_lastIndex = 0;
0455 tbb::this_task_arena::isolate([&] { m_indicesTree->Fill(); });
0456 }
0457
0458 edm::Service<edm::JobReport> jr;
0459 jr->reportLumiSection(m_jrToken, m_run, m_lumi);
0460 }
0461
0462 void DQMRootOutputModule::writeRun(edm::RunForOutput const& iRun) {
0463
0464 edm::Service<DQMStore> dstore;
0465 m_run = iRun.id().run();
0466 m_lumi = 0;
0467 m_beginTime = iRun.beginTime().value();
0468 m_endTime = iRun.endTime().value();
0469 bool shouldWrite = (m_filterOnRun == 0 || (m_filterOnRun != 0 && m_filterOnRun == m_run));
0470
0471 if (!shouldWrite)
0472 return;
0473
0474 std::vector<MonitorElement*> items(dstore->getAllContents("", m_run, 0));
0475 for (std::vector<MonitorElement*>::iterator it = items.begin(), itEnd = items.end(); it != itEnd; ++it) {
0476 assert((*it)->getScope() == MonitorElementData::Scope::RUN);
0477 std::map<unsigned int, unsigned int>::iterator itFound = m_dqmKindToTypeIndex.find((int)(*it)->kind());
0478 assert(itFound != m_dqmKindToTypeIndex.end());
0479 m_treeHelpers[itFound->second]->fill(*it);
0480 }
0481
0482 const edm::ProcessHistoryID& id = iRun.processHistoryID();
0483 std::vector<edm::ProcessHistoryID>::iterator itFind = std::find(m_seenHistories.begin(), m_seenHistories.end(), id);
0484 if (itFind == m_seenHistories.end()) {
0485 m_processHistoryRegistry.registerProcessHistory(iRun.processHistory());
0486 m_presentHistoryIndex = m_seenHistories.size();
0487 m_seenHistories.push_back(id);
0488 } else {
0489 m_presentHistoryIndex = itFind - m_seenHistories.begin();
0490 }
0491
0492
0493 unsigned int typeIndex = 0;
0494 for (std::vector<std::shared_ptr<TreeHelperBase> >::iterator it = m_treeHelpers.begin(), itEnd = m_treeHelpers.end();
0495 it != itEnd;
0496 ++it, ++typeIndex) {
0497 if ((*it)->wasFilled()) {
0498 m_type = typeIndex;
0499 (*it)->getRangeAndReset(m_firstIndex, m_lastIndex);
0500 tbb::this_task_arena::isolate([&] { m_indicesTree->Fill(); });
0501 }
0502 }
0503
0504 edm::Service<edm::JobReport> jr;
0505 jr->reportRunNumber(m_jrToken, m_run);
0506 }
0507
0508 void DQMRootOutputModule::reallyCloseFile() {
0509 startEndFile();
0510 finishEndFile();
0511 }
0512
0513 void DQMRootOutputModule::startEndFile() {
0514
0515
0516 m_file->cd();
0517 TDirectory* metaDataDirectory = m_file->mkdir(kMetaDataDirectory);
0518
0519
0520 TTree* processHistoryTree = new TTree(kProcessHistoryTree, kProcessHistoryTree);
0521 processHistoryTree->SetDirectory(metaDataDirectory);
0522
0523 unsigned int index = 0;
0524 processHistoryTree->Branch(kPHIndexBranch, &index);
0525 std::string processName;
0526 processHistoryTree->Branch(kProcessConfigurationProcessNameBranch, &processName);
0527 std::string parameterSetID;
0528 processHistoryTree->Branch(kProcessConfigurationParameterSetIDBranch, ¶meterSetID);
0529 std::string releaseVersion;
0530 processHistoryTree->Branch(kProcessConfigurationReleaseVersion, &releaseVersion);
0531 std::string passID;
0532 processHistoryTree->Branch(kProcessConfigurationPassID, &passID);
0533
0534 for (std::vector<edm::ProcessHistoryID>::iterator it = m_seenHistories.begin(), itEnd = m_seenHistories.end();
0535 it != itEnd;
0536 ++it) {
0537 const edm::ProcessHistory* history = m_processHistoryRegistry.getMapped(*it);
0538 assert(nullptr != history);
0539 index = 0;
0540 for (edm::ProcessHistory::collection_type::const_iterator itPC = history->begin(), itPCEnd = history->end();
0541 itPC != itPCEnd;
0542 ++itPC, ++index) {
0543 processName = itPC->processName();
0544 releaseVersion = itPC->releaseVersion();
0545 passID = itPC->passID();
0546 parameterSetID = itPC->parameterSetID().compactForm();
0547 tbb::this_task_arena::isolate([&] { processHistoryTree->Fill(); });
0548 }
0549 }
0550
0551
0552 TTree* parameterSetsTree = new TTree(kParameterSetTree, kParameterSetTree);
0553 parameterSetsTree->SetDirectory(metaDataDirectory);
0554 std::string blob;
0555 parameterSetsTree->Branch(kParameterSetBranch, &blob);
0556
0557 edm::pset::Registry* psr = edm::pset::Registry::instance();
0558 assert(nullptr != psr);
0559 for (edm::pset::Registry::const_iterator it = psr->begin(), itEnd = psr->end(); it != itEnd; ++it) {
0560 blob.clear();
0561 it->second.toString(blob);
0562 tbb::this_task_arena::isolate([&] { parameterSetsTree->Fill(); });
0563 }
0564 }
0565
0566 void DQMRootOutputModule::finishEndFile() {
0567
0568 m_file->Write();
0569 m_file->Close();
0570 edm::Service<edm::JobReport> jr;
0571 jr->outputFileClosed(m_jrToken);
0572 }
0573
0574
0575
0576
0577
0578
0579
0580
0581 void DQMRootOutputModule::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0582 edm::ParameterSetDescription desc;
0583
0584 desc.addUntracked<std::string>("fileName");
0585 desc.addUntracked<std::string>("logicalFileName", "");
0586 desc.addUntracked<unsigned int>("filterOnRun", 0)
0587 ->setComment("Only write the run with this run number. 0 means write all runs.");
0588 desc.addOptionalUntracked<int>("splitLevel", 99)
0589 ->setComment("UNUSED Only here to allow older configurations written for PoolOutputModule to work.");
0590 const std::vector<std::string> keep = {"drop *", "keep DQMToken_*_*_*"};
0591 edm::one::OutputModule<>::fillDescription(desc, keep);
0592
0593 edm::ParameterSetDescription dataSet;
0594 dataSet.setAllowAnything();
0595 desc.addUntracked<edm::ParameterSetDescription>("dataset", dataSet)
0596 ->setComment("PSet is only used by Data Operations and not by this module.");
0597
0598 descriptions.addDefault(desc);
0599 }
0600
0601 DEFINE_FWK_MODULE(DQMRootOutputModule);