|
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
|
/****************************************************************************
* Authors:
* Jan Kaspar (jan.kaspar@gmail.com)
* Helena Malbouisson
* Clemencia Mora Herrera
* Christopher Misan
****************************************************************************/
#include "CalibPPS/ESProducers/interface/CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "CondFormats/PPSObjects/interface/CTPPSRPAlignmentCorrectionsMethods.h"
#include <map>
#include <set>
//----------------------------------------------------------------------------------------------------
CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon::CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon(
const edm::ParameterSet &pSet)
: verbosity(pSet.getUntrackedParameter<unsigned int>("verbosity", 0)) {
std::vector<std::string> measuredFiles;
for (const auto &f : pSet.getParameter<std::vector<std::string> >("MeasuredFiles"))
measuredFiles.push_back(edm::FileInPath(f).fullPath());
PrepareSequence("Measured", acsMeasured, measuredFiles);
std::vector<std::string> realFiles;
for (const auto &f : pSet.getParameter<std::vector<std::string> >("RealFiles"))
realFiles.push_back(edm::FileInPath(f).fullPath());
PrepareSequence("Real", acsReal, realFiles);
std::vector<std::string> misalignedFiles;
for (const auto &f : pSet.getParameter<std::vector<std::string> >("MisalignedFiles"))
misalignedFiles.push_back(edm::FileInPath(f).fullPath());
PrepareSequence("Misaligned", acsMisaligned, misalignedFiles);
}
//----------------------------------------------------------------------------------------------------
CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon::~CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon() {}
//----------------------------------------------------------------------------------------------------
CTPPSRPAlignmentCorrectionsDataSequence CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon::Merge(
const std::vector<CTPPSRPAlignmentCorrectionsDataSequence> &seqs) const {
// find interval boundaries
std::map<edm::EventID, std::vector<std::pair<bool, const CTPPSRPAlignmentCorrectionsData *> > > bounds;
for (const auto &seq : seqs) {
for (const auto &p : seq) {
const edm::ValidityInterval &iov = p.first;
const CTPPSRPAlignmentCorrectionsData *corr = &p.second;
const edm::EventID &event_first = iov.first().eventID();
bounds[event_first].emplace_back(std::pair<bool, const CTPPSRPAlignmentCorrectionsData *>(true, corr));
const edm::EventID &event_after = nextLS(iov.last().eventID());
bounds[event_after].emplace_back(std::pair<bool, const CTPPSRPAlignmentCorrectionsData *>(false, corr));
}
}
// build correction sums per interval
std::set<const CTPPSRPAlignmentCorrectionsData *> accumulator;
CTPPSRPAlignmentCorrectionsDataSequence result;
for (std::map<edm::EventID, std::vector<std::pair<bool, const CTPPSRPAlignmentCorrectionsData *> > >::const_iterator
tit = bounds.begin();
tit != bounds.end();
++tit) {
for (const auto &cit : tit->second) {
bool add = cit.first;
const CTPPSRPAlignmentCorrectionsData *corr = cit.second;
if (add)
accumulator.insert(corr);
else
accumulator.erase(corr);
}
auto tit_next = tit;
tit_next++;
if (tit_next == bounds.end())
break;
const edm::EventID &event_first = tit->first;
const edm::EventID &event_last = previousLS(tit_next->first);
if (verbosity) {
edm::LogInfo("PPS") << " first="
<< CTPPSRPAlignmentCorrectionsMethods::iovValueToString(edm::IOVSyncValue(event_first))
<< ", last="
<< CTPPSRPAlignmentCorrectionsMethods::iovValueToString(edm::IOVSyncValue(event_last))
<< ": alignment blocks " << accumulator.size();
}
CTPPSRPAlignmentCorrectionsData corr_sum;
for (auto sit : accumulator)
corr_sum.addCorrections(*sit);
result.insert(edm::ValidityInterval(edm::IOVSyncValue(event_first), edm::IOVSyncValue(event_last)), corr_sum);
}
return result;
}
//----------------------------------------------------------------------------------------------------
void CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon::PrepareSequence(const std::string &label,
CTPPSRPAlignmentCorrectionsDataSequence &seq,
const std::vector<std::string> &files) const {
if (verbosity)
edm::LogInfo("PPS") << "PrepareSequence(" << label << ")";
std::vector<CTPPSRPAlignmentCorrectionsDataSequence> sequences;
sequences.reserve(files.size());
for (const auto &file : files)
sequences.emplace_back(CTPPSRPAlignmentCorrectionsMethods::loadFromXML(file));
seq = Merge(sequences);
}
//----------------------------------------------------------------------------------------------------
edm::EventID CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon::previousLS(const edm::EventID &src) {
if (src.run() == edm::EventID::maxRunNumber() && src.luminosityBlock() == edm::EventID::maxLuminosityBlockNumber())
return src;
if (src.luminosityBlock() == 0)
return edm::EventID(src.run() - 1, edm::EventID::maxLuminosityBlockNumber(), src.event());
return edm::EventID(src.run(), src.luminosityBlock() - 1, src.event());
}
//----------------------------------------------------------------------------------------------------
edm::EventID CTPPSRPAlignmentCorrectionsDataESSourceXMLCommon::nextLS(const edm::EventID &src) {
if (src.luminosityBlock() == edm::EventID::maxLuminosityBlockNumber()) {
if (src.run() == edm::EventID::maxRunNumber())
return src;
return edm::EventID(src.run() + 1, 0, src.event());
}
return edm::EventID(src.run(), src.luminosityBlock() + 1, src.event());
}
|