|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
// -*- C++ -*-
//
// Package: DummyReadDQMStore
// Class: DummyReadDQMStore
//
/**\class DummyReadDQMStore DummyReadDQMStore.cc DQMServices/DummyReadDQMStore/src/DummyReadDQMStore.cc
Description: [one line class summary]
Implementation:
[Notes on implementation]
*/
//
// Original Author: Christopher Jones
// Created: Fri Apr 29 18:05:50 CDT 2011
//
//
#include <memory>
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/one/EDAnalyzer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DQMServices/Core/interface/DQMStore.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
namespace {
typedef dqm::legacy::MonitorElement MonitorElement;
typedef dqm::legacy::DQMStore DQMStore;
class ReaderBase {
public:
virtual ~ReaderBase() = default;
virtual void read(int run, int lumi) = 0;
};
class TH1Reader : public ReaderBase {
public:
TH1Reader(const edm::ParameterSet& iPSet, DQMStore& iStore, bool iSetLumiFlag)
: m_store(&iStore),
m_element(nullptr),
m_runs(iPSet.getUntrackedParameter<std::vector<int> >("runs")),
m_lumis(iPSet.getUntrackedParameter<std::vector<int> >("lumis")),
m_means(iPSet.getUntrackedParameter<std::vector<double> >("means")),
m_entries(iPSet.getUntrackedParameter<std::vector<double> >("entries")) {
assert(m_means.size() == m_entries.size());
std::string extension;
if (iSetLumiFlag) {
extension = "_lumi";
}
m_name = iPSet.getUntrackedParameter<std::string>("name") + extension;
}
void read(int run, int lumi) override {
double expected_mean = -1, expected_entries = -1;
for (unsigned int i = 0; i < m_runs.size(); i++) {
if (m_runs[i] == run && m_lumis[i] == lumi) {
expected_mean = m_means[i];
expected_entries = m_entries[i];
}
}
assert(expected_entries != -1 || !"Unexpected run/lumi!");
m_element = m_store->get(m_name);
if (nullptr == m_element) {
throw cms::Exception("MissingElement") << "The element: " << m_name << " was not found";
}
TH1* hist = m_element->getTH1();
if (hist->GetEntries() != expected_entries) {
throw cms::Exception("WrongEntries")
<< "The element: " << m_name << " for run " << run << " lumi " << lumi << " was expected to have "
<< expected_entries << " entries but instead has " << hist->GetEntries();
}
if (hist->GetMean() != expected_mean) {
throw cms::Exception("WrongEntries")
<< "The element: " << m_name << " for run " << run << " lumi " << lumi << " was expected to have "
<< expected_mean << " mean but instead has " << hist->GetMean();
}
}
private:
std::string m_name;
DQMStore* m_store;
MonitorElement* m_element;
std::vector<int> m_runs;
std::vector<int> m_lumis;
std::vector<double> m_means;
std::vector<double> m_entries;
};
} // namespace
class DummyReadDQMStore : public edm::one::EDAnalyzer<edm::one::WatchRuns, edm::one::WatchLuminosityBlocks> {
public:
explicit DummyReadDQMStore(const edm::ParameterSet&);
static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
private:
void analyze(const edm::Event&, const edm::EventSetup&) override;
void beginRun(edm::Run const&, edm::EventSetup const&) override;
void endRun(edm::Run const&, edm::EventSetup const&) override;
void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
// ----------member data ---------------------------
std::vector<std::shared_ptr<ReaderBase> > m_runReaders;
std::vector<std::shared_ptr<ReaderBase> > m_lumiReaders;
};
DummyReadDQMStore::DummyReadDQMStore(const edm::ParameterSet& iConfig) {
edm::Service<DQMStore> dstore;
typedef std::vector<edm::ParameterSet> PSets;
const PSets& runElements = iConfig.getUntrackedParameter<std::vector<edm::ParameterSet> >("runElements");
m_runReaders.reserve(runElements.size());
for (PSets::const_iterator it = runElements.begin(), itEnd = runElements.end(); it != itEnd; ++it) {
switch (it->getUntrackedParameter<unsigned int>("type", 1)) {
case 1:
m_runReaders.push_back(std::shared_ptr<ReaderBase>(new TH1Reader(*it, *dstore, false)));
break;
case 2:
m_runReaders.push_back(std::shared_ptr<ReaderBase>(new TH1Reader(*it, *dstore, false)));
break;
}
}
const PSets& lumiElements = iConfig.getUntrackedParameter<std::vector<edm::ParameterSet> >("lumiElements");
m_lumiReaders.reserve(lumiElements.size());
for (PSets::const_iterator it = lumiElements.begin(), itEnd = lumiElements.end(); it != itEnd; ++it) {
switch (it->getUntrackedParameter<unsigned int>("type", 1)) {
case 1:
m_lumiReaders.push_back(std::shared_ptr<ReaderBase>(new TH1Reader(*it, *dstore, true)));
break;
case 2:
m_lumiReaders.push_back(std::shared_ptr<ReaderBase>(new TH1Reader(*it, *dstore, true)));
break;
}
}
}
void DummyReadDQMStore::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) {}
void DummyReadDQMStore::beginRun(edm::Run const&, edm::EventSetup const&) {}
void DummyReadDQMStore::endRun(edm::Run const& run, edm::EventSetup const&) {
for (std::vector<std::shared_ptr<ReaderBase> >::iterator it = m_runReaders.begin(), itEnd = m_runReaders.end();
it != itEnd;
++it) {
(*it)->read(run.run(), 0);
}
}
void DummyReadDQMStore::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) {}
void DummyReadDQMStore::endLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const&) {
for (std::vector<std::shared_ptr<ReaderBase> >::iterator it = m_lumiReaders.begin(), itEnd = m_lumiReaders.end();
it != itEnd;
++it) {
(*it)->read(lumi.run(), lumi.luminosityBlock());
}
}
void DummyReadDQMStore::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
//The following says we do not know what parameters are allowed so do no validation
// Please change this to state exactly what you do use, even if it is no parameters
edm::ParameterSetDescription desc;
desc.setUnknown();
descriptions.addDefault(desc);
}
DEFINE_FWK_MODULE(DummyReadDQMStore);
|