|
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
181
182
183
184
185
186
187
188
189
|
#include "DataFormats/Luminosity/interface/LumiDetails.h"
#include "FWCore/Utilities/interface/EDMException.h"
#include <cassert>
#include <iomanip>
#include <ostream>
std::vector<std::string> const LumiDetails::m_algoNames = {
// If in the future additional algorithm names are added,
// it is important that they be added at the end of the list.
// The Algos enum in LumiDetails.h also would need to be
// updated to keep the list of names in sync.
{"OCC1"},
{"OCC2"},
{"ET"},
{"PLT"}};
static std::vector<std::string> const s_dipalgoNames = {{"DIP"}};
LumiDetails::LumiDetails()
: m_lumiVersion("-1"),
m_algoToFirstIndex(kMaxNumAlgos + 1, 0),
m_allValues(),
m_allErrors(),
m_allQualities(),
m_beam1Intensities(),
m_beam2Intensities() {}
LumiDetails::LumiDetails(std::string const& lumiVersion)
: m_lumiVersion(lumiVersion),
m_algoToFirstIndex(kMaxNumAlgos + 1, 0),
m_allValues(),
m_allErrors(),
m_allQualities(),
m_beam1Intensities(),
m_beam2Intensities() {}
LumiDetails::~LumiDetails() {}
void LumiDetails::setLumiVersion(std::string const& lumiVersion) { m_lumiVersion = lumiVersion; }
std::string const& LumiDetails::lumiVersion() const { return m_lumiVersion; }
bool LumiDetails::isValid() const { return !m_allValues.empty(); }
void LumiDetails::fill(AlgoType algo,
std::vector<float> const& values,
std::vector<float> const& errors,
std::vector<short> const& qualities) {
checkAlgo(algo);
if (values.size() != errors.size() || values.size() != qualities.size() ||
m_algoToFirstIndex[algo] != m_algoToFirstIndex[algo + 1U]) {
throw edm::Exception(edm::errors::LogicError) << "Illegal input values passed to LumiDetails::fill.\n"
<< "The current implementation of LumiDetails only allows filling\n"
<< "vectors for each algorithm once and the input vectors must\n"
<< "all be the same size.\n";
}
m_allValues.insert(m_allValues.begin() + m_algoToFirstIndex[algo], values.begin(), values.end());
m_allErrors.insert(m_allErrors.begin() + m_algoToFirstIndex[algo], errors.begin(), errors.end());
m_allQualities.insert(m_allQualities.begin() + m_algoToFirstIndex[algo], qualities.begin(), qualities.end());
for (unsigned i = algo + 1U; i <= kMaxNumAlgos; ++i) {
m_algoToFirstIndex[i] += values.size();
}
}
void LumiDetails::fillBeamIntensities(std::vector<float> const& beam1Intensities,
std::vector<float> const& beam2Intensities) {
m_beam1Intensities = beam1Intensities;
m_beam2Intensities = beam2Intensities;
}
float LumiDetails::lumiValue(AlgoType algo, unsigned int bx) const {
checkAlgoAndBX(algo, bx);
return m_allValues[m_algoToFirstIndex[algo] + bx];
}
float LumiDetails::lumiError(AlgoType algo, unsigned int bx) const {
checkAlgoAndBX(algo, bx);
return m_allErrors[m_algoToFirstIndex[algo] + bx];
}
short LumiDetails::lumiQuality(AlgoType algo, unsigned int bx) const {
checkAlgoAndBX(algo, bx);
return m_allQualities[m_algoToFirstIndex[algo] + bx];
}
float LumiDetails::lumiBeam1Intensity(unsigned int bx) const { return m_beam1Intensities.at(bx); }
float LumiDetails::lumiBeam2Intensity(unsigned int bx) const { return m_beam2Intensities.at(bx); }
LumiDetails::ValueRange LumiDetails::lumiValuesForAlgo(AlgoType algo) const {
checkAlgo(algo);
return ValueRange(m_allValues.begin() + m_algoToFirstIndex[algo],
m_allValues.begin() + m_algoToFirstIndex[algo + 1U]);
}
LumiDetails::ErrorRange LumiDetails::lumiErrorsForAlgo(AlgoType algo) const {
checkAlgo(algo);
return ErrorRange(m_allErrors.begin() + m_algoToFirstIndex[algo],
m_allErrors.begin() + m_algoToFirstIndex[algo + 1U]);
}
LumiDetails::QualityRange LumiDetails::lumiQualitiesForAlgo(AlgoType algo) const {
checkAlgo(algo);
return QualityRange(m_allQualities.begin() + m_algoToFirstIndex[algo],
m_allQualities.begin() + m_algoToFirstIndex[algo + 1U]);
}
std::vector<float> const& LumiDetails::lumiBeam1Intensities() const { return m_beam1Intensities; }
std::vector<float> const& LumiDetails::lumiBeam2Intensities() const { return m_beam2Intensities; }
std::vector<std::string> const& LumiDetails::algoNames() {
assert(m_algoNames.size() == kMaxNumAlgos);
return m_algoNames;
}
std::vector<std::string> const& LumiDetails::dipalgoNames() { return s_dipalgoNames; }
bool LumiDetails::isProductEqual(LumiDetails const& lumiDetails) const {
if (m_lumiVersion == lumiDetails.m_lumiVersion && m_algoToFirstIndex == lumiDetails.m_algoToFirstIndex &&
m_allValues == lumiDetails.m_allValues && m_allErrors == lumiDetails.m_allErrors &&
m_allQualities == lumiDetails.m_allQualities && m_beam1Intensities == lumiDetails.m_beam1Intensities &&
m_beam2Intensities == lumiDetails.m_beam2Intensities) {
return true;
}
return false;
}
void LumiDetails::checkAlgo(AlgoType algo) const {
if (algo >= kMaxNumAlgos) {
throw edm::Exception(edm::errors::LogicError)
<< "Algorithm type argument out of range in a call to a function in LumiDetails\n";
}
}
void LumiDetails::checkAlgoAndBX(AlgoType algo, unsigned int bx) const {
checkAlgo(algo);
if (bx >= (m_algoToFirstIndex[algo + 1U] - m_algoToFirstIndex[algo])) {
throw edm::Exception(edm::errors::LogicError)
<< "Branch crossing argument out of range in call to a function in LumiDetails\n";
}
}
std::ostream& operator<<(std::ostream& s, LumiDetails const& lumiDetails) {
s << "\nDumping LumiDetails\n";
s << std::setw(12) << "lumi version " << lumiDetails.lumiVersion() << "\n";
std::vector<std::string>::const_iterator algo;
std::vector<std::string>::const_iterator algoEnd;
if (lumiDetails.lumiVersion() != std::string("DIP")) {
algo = lumiDetails.algoNames().begin();
algoEnd = lumiDetails.algoNames().end();
} else {
algo = lumiDetails.dipalgoNames().begin();
algoEnd = lumiDetails.dipalgoNames().end();
}
LumiDetails::AlgoType i = 0;
for (; algo != algoEnd; ++algo, ++i) {
std::vector<float>::const_iterator value = lumiDetails.lumiValuesForAlgo(i).first;
std::vector<float>::const_iterator valueEnd = lumiDetails.lumiValuesForAlgo(i).second;
std::vector<float>::const_iterator error = lumiDetails.lumiErrorsForAlgo(i).first;
std::vector<short>::const_iterator quality = lumiDetails.lumiQualitiesForAlgo(i).first;
s << "algorithm: " << *algo << "\n";
s << std::setw(12) << "value" << std::setw(12) << "error" << std::setw(12) << "quality"
<< "\n";
for (; value != valueEnd; ++value, ++error, ++quality) {
s << std::setw(12) << *value << std::setw(12) << *error << std::setw(12) << *quality << "\n";
}
s << "\n";
}
s << "beam 1 intensities:\n";
std::vector<float> const& beam1Intensities = lumiDetails.lumiBeam1Intensities();
for (std::vector<float>::const_iterator intensity = beam1Intensities.begin(), iEnd = beam1Intensities.end();
intensity != iEnd;
++intensity) {
s << *intensity << "\n";
}
s << "\nbeam 2 intensities:\n";
std::vector<float> const& beam2Intensities = lumiDetails.lumiBeam2Intensities();
for (std::vector<float>::const_iterator intensity = beam2Intensities.begin(), iEnd = beam2Intensities.end();
intensity != iEnd;
++intensity) {
s << *intensity << "\n";
}
s << "\n";
return s;
}
|