Belle II Software development
TOPPhotonYieldsAlgorithm.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include <top/calibration/TOPPhotonYieldsAlgorithm.h>
10#include <top/geometry/TOPGeometryPar.h>
11#include <top/dbobjects/TOPCalPhotonYields.h>
12#include <top/dbobjects/TOPCalChannelRQE.h>
13#include <top/dbobjects/TOPCalTOFCorrection.h>
14#include <TROOT.h>
15#include <TFile.h>
16#include <TProfile.h>
17#include <string>
18
19using namespace std;
20
21namespace Belle2 {
26 namespace TOP {
27
28 TOPPhotonYieldsAlgorithm::TOPPhotonYieldsAlgorithm():
29 CalibrationAlgorithm("TOPPhotonYieldsCollector")
30 {
31 setDescription("Calibration algorithm for photon pixel yields aimed for PMT ageing studies, for RQE calibration "
32 "and for finding optically decoupled PMT's");
33 }
34
35
36 CalibrationAlgorithm::EResult TOPPhotonYieldsAlgorithm::calibrate()
37 {
38 gROOT->SetBatch();
39
40 // IoV for getting geometry payloads - they differ only between Run1 and Run2
41
42 const auto& expRun = getRunList();
43 updateDBObjPtrs(1, expRun[0].second, expRun[0].first);
44
45 // geometry parameters
46
47 auto* topgp = TOPGeometryPar::Instance();
48 if (not topgp->isValid()) topgp->Initialize();
49 if (not topgp->isValid()) {
50 B2ERROR("TOPPhotonYieldsAlgorithm: cannot initialize geometry parameters");
51 return c_Failure;
52 }
53
54 // construct file name and open output root file for storing merged histograms
55
56 string expNo = to_string(expRun[0].first);
57 while (expNo.length() < 4) expNo.insert(0, "0");
58 string runNo = to_string(expRun[0].second);
59 while (runNo.length() < 5) runNo.insert(0, "0");
60 string outputFileName = "photonYields-e" + expNo + "-r" + runNo + ".root";
61 auto* file = TFile::Open(outputFileName.c_str(), "recreate");
62
63 // create some additional histograms for monitoring of RQE calibration
64
65 auto* h_rqe = new TH1F("RQE", "RQE distribution; RQE; entries/bin", 100, 0, m_maxRQE);
66 auto* h_err = new TH1F("RQEerr", "RQE uncertainty distribution; RQE uncertainty; entries/bin", 100, 0, m_maxErrorRQE);
67
68 // get basic histograms
69
70 auto numTracks = getObjectPtr<TH1F>("numTracks");
71 if (not numTracks) {
72 B2ERROR("TOPPhotonYieldsAlgorithm: histogram 'numTracks' not found");
73 file->Close();
74 return c_Failure;
75 }
76 numTracks->Write();
77
78 auto timeStamp = getObjectPtr<TProfile>("timeStamp");
79 if (not timeStamp) {
80 B2ERROR("TOPPhotonYieldsAlgorithm: histogram 'timeStamp' not found");
81 file->Close();
82 return c_Failure;
83 }
84 timeStamp->Write();
85
86 // construct DB objects for storing the results and set the time stamp
87
88 auto* dbPhotonYields = new TOPCalPhotonYields();
89 dbPhotonYields->setTimeStamp(timeStamp->GetBinContent(1), timeStamp->GetBinError(1));
90 auto* dbRQE = new TOPCalChannelRQE();
91
92 // for each slot determine photon pixel yields, equalized alpha ratio and RQE, and store them in DB objects
93
94 int numModules = numTracks->GetNbinsX();
95 for (int slot = 1; slot <= numModules; slot++) {
96 string slotName = (slot < 10) ? "_0" + to_string(slot) : "_" + to_string(slot);
97
98 auto signalHits = getObjectPtr<TH1F>("signalHits" + slotName);
99 if (not signalHits) {
100 B2ERROR("TOPPhotonYieldsAlgorithm: histogram 'signalHits' for slot " << slot << " not found");
101 file->Close();
102 delete dbPhotonYields;
103 delete dbRQE;
104 return c_Failure;
105 }
106 signalHits->Write();
107
108 auto bkgHits = getObjectPtr<TH1F>("bkgHits" + slotName);
109 if (not bkgHits) {
110 B2ERROR("TOPPhotonYieldsAlgorithm: histogram 'bkgHits' for slot " << slot << " not found");
111 file->Close();
112 delete dbPhotonYields;
113 delete dbRQE;
114 return c_Failure;
115 }
116 bkgHits->Write();
117
118 auto effectiveSignalHits = getObjectPtr<TH1F>("effectiveSignalHits" + slotName);
119 if (not effectiveSignalHits) {
120 B2ERROR("TOPPhotonYieldsAlgorithm: histogram 'effectiveSignalHits' for slot " << slot << " not found");
121 file->Close();
122 delete dbPhotonYields;
123 delete dbRQE;
124 return c_Failure;
125 }
126 effectiveSignalHits->Write();
127
128 auto activePixels = getObjectPtr<TH1F>("activePixels" + slotName);
129 if (not activePixels) {
130 B2ERROR("TOPPhotonYieldsAlgorithm: histogram 'activePixels' for slot " << slot << " not found");
131 file->Close();
132 delete dbPhotonYields;
133 delete dbRQE;
134 return c_Failure;
135 }
136 activePixels->Write();
137
138 auto alphaLow = getObjectPtr<TH1F>("alphaLow" + slotName);
139 if (not alphaLow) {
140 B2ERROR("TOPPhotonYieldsAlgorithm: histogram 'alphaLow' for slot " << slot << " not found");
141 file->Close();
142 delete dbPhotonYields;
143 delete dbRQE;
144 return c_Failure;
145 }
146 alphaLow->Sumw2();
147 alphaLow->Write();
148
149 auto alphaHigh = getObjectPtr<TH1F>("alphaHigh" + slotName);
150 if (not alphaHigh) {
151 B2ERROR("TOPPhotonYieldsAlgorithm: histogram 'alphaHigh' for slot " << slot << " not found");
152 file->Close();
153 delete dbPhotonYields;
154 delete dbRQE;
155 return c_Failure;
156 }
157 alphaHigh->Sumw2();
158 alphaHigh->Write();
159
160 auto pulseHeights = getObjectPtr<TH2F>("pulseHeights" + slotName);
161 if (not pulseHeights) {
162 B2ERROR("TOPPhotonYieldsAlgorithm: histogram 'pulseHeights' for slot " << slot << " not found");
163 file->Close();
164 delete dbPhotonYields;
165 delete dbRQE;
166 return c_Failure;
167 }
168 pulseHeights->Write();
169
170 auto muonZ = getObjectPtr<TH1F>("muonZ" + slotName);
171 if (not muonZ) {
172 B2ERROR("TOPPhotonYieldsAlgorithm: histogram 'muonZ' for slot " << slot << " not found");
173 file->Close();
174 delete dbPhotonYields;
175 delete dbRQE;
176 return c_Failure;
177 }
178 muonZ->Write();
179
180 auto* photonYields = static_cast<TH1F*>(signalHits->Clone("tmp1"));
181 photonYields->Add(signalHits.get(), bkgHits.get(), 1, -1); // subtract background
182 for (int bin = 1; bin <= activePixels->GetNbinsX(); bin++) activePixels->SetBinError(bin, 0);
183 photonYields->Divide(activePixels.get()); // normalize
184
185 auto* bkgYields = static_cast<TH1F*>(bkgHits->Clone("tmp2"));
186 bkgYields->Divide(activePixels.get()); // normalize
187
188 auto* alphaRatio = static_cast<TH1F*>(alphaHigh->Clone("tmp2"));
189 alphaRatio->Divide(alphaHigh.get(), alphaLow.get());
190 equalize(alphaRatio);
191
192 dbPhotonYields->set(slot, photonYields, bkgYields, alphaRatio, activePixels.get(), pulseHeights.get(), muonZ.get());
193
194 effectiveSignalHits->Sumw2();
195 effectiveSignalHits->Divide(activePixels.get()); // normalize
196 const auto& channelMapper = topgp->getChannelMapper();
197 for (int row = 0; row < 8; row++) {
198 double muonCorr = getMuonCorrection(muonZ.get(), row);
199 for (int col = 0; col < 64; col++) {
200 int pixelID = row * 64 + col + 1;
201 double mcYield = getNominalYield(slot, row, col) * topgp->getRelativePDEonMC(slot, pixelID) * muonCorr;
202 if (mcYield == 0) continue; // this should not happen
203 double rqe = effectiveSignalHits->GetBinContent(pixelID) / mcYield;
204 double err = effectiveSignalHits->GetBinError(pixelID) / mcYield;
205 if (rqe == 0) continue; // pixel dead or masked-out
206 h_rqe->Fill(rqe);
207 h_err->Fill(err);
208 if (rqe > m_maxRQE or err > m_maxErrorRQE) continue; // bad calibration, do not save it in payload
209 unsigned channel = channelMapper.getChannel(pixelID);
210 dbRQE->setRQE(slot, channel, rqe);
211 }
212 }
213
214 delete photonYields;
215 delete bkgYields;
216 delete alphaRatio;
217 }
218 h_rqe->Write();
219 h_err->Write();
220
221 auto tofCorrections = getObjectPtr<TProfile>("tofCorrections");
222 if (not tofCorrections) {
223 B2ERROR("TOPPhotonYieldsAlgorithm: histogram 'tofCorrections' not found");
224 file->Close();
225 delete dbPhotonYields;
226 delete dbRQE;
227 return c_Failure;
228 }
229 tofCorrections->Write();
230 file->Close();
231
232 auto* dbTOFCorrections = new TOPCalTOFCorrection();
233 dbTOFCorrections->set(tofCorrections.get());
234
235 saveCalibration(dbPhotonYields);
236 saveCalibration(dbRQE);
237 saveCalibration(dbTOFCorrections);
238
239 return c_OK;
240 }
241
242
243 double TOPPhotonYieldsAlgorithm::getEqualizingValue(int bin)
244 {
245 // these constants are determined from fits to MC
246 const double a[] = {1.50301, 1.16907, 1.00912, 0.943571, 0.889658, 0.93418, 1.01846, 0.953715};
247 const double b[] = {-1.02531, -0.111269, 0.0731595, -0.121119, -0.79083, -1.00261, -1.41012, -1.23368};
248 const double c[] = {8.47995, 3.18639, 1.9513, 2.58279, 4.79672, 5.5659, 7.558, 6.71336};
249 const double d[] = {1.49743, 1.17224, 1.02211, 0.928502, 0.829334, 0.849355, 0.921871, 0.850427};
250
251 int row = (bin - 1) / 64;
252 if (row < 0 or row > 7) return 1;
253
254 int col = (bin - 1) % 64 + 1;
255 if (col == 1 or col == 64) return d[row];
256
257 double x = (col - 32.5) / 64.;
258 return a[row] + b[row] * pow(x, 2) + c[row] * pow(x, 4);
259 }
260
261
262 void TOPPhotonYieldsAlgorithm::equalize(TH1F* h)
263 {
264 for (int bin = 1; bin <= h->GetNbinsX(); bin++) {
265 double s = getEqualizingValue(bin);
266 h->SetBinContent(bin, h->GetBinContent(bin) / s);
267 h->SetBinError(bin, h->GetBinError(bin) / s);
268 }
269 }
270
271
272 double TOPPhotonYieldsAlgorithm::getNominalYield(int slot, int row, int col)
273 {
274 // these constants are determined from fits to MC
275 const double par[8][4] = {{0.0404913, -2.10514e-07, -1.01752e-08, 1.00656e-11},
276 {0.0406668, -3.045e-06, -3.77908e-09, 6.4395e-12},
277 {0.041261, -1.18e-06, -7.12563e-09, 8.68068e-12},
278 {0.0439403, -1.38318e-06, -4.55235e-09, 6.7621e-12},
279 {0.04622, 2.92406e-06, -1.4338e-08, 1.43519e-11},
280 {0.0469347, 1.30621e-06, -1.10208e-08, 1.23847e-11},
281 {0.0476307, 7.59058e-07, -1.1142e-08, 1.28852e-11},
282 {0.0410036, 1.2299e-06, -1.26732e-08, 1.32523e-11}
283 };
284 const double slot_sf[16] = {1.0296, 1.00401, 0.980722, 0.997997, 1.01303, 1.00586, 0.993214, 0.978076,
285 0.981156, 0.992147, 0.999084, 0.964364, 1.00546, 1.02583, 1.01906, 1.01039
286 };
287
288 if (slot < 1 or slot > 16) return 0;
289 if (row < 0 or row > 7) return 0;
290
291 double x = col - 31.5;
292 x *= x;
293 const double* p = par[row];
294
295 return (p[0] + p[1] * x + p[2] * x * x + p[3] * x * x * x) * slot_sf[slot - 1];
296 }
297
298
299 double TOPPhotonYieldsAlgorithm::getMuonCorrection(const TH1F* h_mu, int row)
300 {
301 // these constants are determined from MC
302 const double numFot[8][100] = {{
303 2.35, 3.41, 5.22, 5.57, 4.26, 4.47, 6.13, 5.01, 4.93, 6.35, 5.07, 5.71, 4.88, 4.98, 4.56, 4.06,
304 3.86, 3.38, 2.69, 2.11, 1.8, 1.44, 0.99, 0.52, 0.32, 0.26, 0.27, 0.28, 0.29, 0.36, 0.63, 1.0,
305 1.29, 1.53, 1.89, 2.38, 2.76, 3.05, 3.34, 3.63, 3.79, 4.04, 4.2, 4.33, 4.3, 4.13, 4.0, 3.86,
306 3.72, 3.62, 3.39, 3.14, 2.89, 2.68, 2.54, 2.44, 2.37, 2.31, 2.2, 2.09, 1.89, 1.88, 1.82, 1.76,
307 1.7, 1.71, 1.71, 1.74, 1.7, 1.73, 1.67, 1.62, 1.49, 1.45, 1.44, 1.45, 1.36, 1.38, 1.35, 1.4,
308 1.42, 1.46, 1.45, 1.47, 1.36, 1.24, 1.24, 1.34, 1.35, 1.33, 1.27, 1.29, 1.38, 1.53, 1.69, 1.75,
309 1.77, 1.78, 1.75, 0.66
310 },
311 {
312 2.41, 3.37, 5.34, 4.54, 3.28, 4.59, 4.64, 3.62, 4.89, 4.22, 4.52, 4.75, 4.94, 4.58, 4.28, 4.21,
313 3.54, 3.09, 2.82, 2.63, 2.46, 2.17, 1.92, 1.54, 1.07, 0.52, 0.35, 0.41, 0.66, 1.05, 1.35, 1.6,
314 1.82, 1.99, 2.12, 2.32, 2.57, 2.98, 3.25, 3.48, 3.59, 3.65, 3.55, 3.39, 3.3, 3.23, 3.2, 3.17,
315 3.18, 3.19, 3.17, 3.19, 3.17, 3.06, 2.84, 2.68, 2.5, 2.39, 2.25, 2.15, 1.97, 1.93, 1.89, 1.77,
316 1.71, 1.73, 1.73, 1.77, 1.74, 1.72, 1.68, 1.63, 1.54, 1.51, 1.51, 1.46, 1.38, 1.38, 1.4, 1.41,
317 1.45, 1.49, 1.49, 1.55, 1.46, 1.33, 1.36, 1.41, 1.49, 1.51, 1.53, 1.72, 2.04, 2.42, 2.69, 3.01,
318 3.13, 3.13, 3.02, 1.37
319 },
320 {
321 2.61, 3.9, 4.86, 3.35, 3.08, 4.39, 3.66, 3.21, 4.28, 3.04, 3.95, 3.33, 3.71, 3.47, 3.49, 3.4,
322 3.1, 2.95, 2.95, 2.88, 2.69, 2.54, 2.39, 2.22, 1.97, 1.75, 1.49, 1.38, 1.47, 1.64, 1.79, 1.91,
323 2.03, 2.13, 2.23, 2.31, 2.39, 2.47, 2.61, 2.74, 2.7, 2.64, 2.67, 2.65, 2.66, 2.74, 2.74, 2.77,
324 2.81, 2.81, 2.88, 2.93, 2.97, 3.01, 3.11, 3.14, 3.1, 2.97, 2.8, 2.54, 2.25, 2.23, 2.12, 2.01,
325 1.97, 1.93, 1.91, 1.91, 1.88, 1.87, 1.86, 1.83, 1.7, 1.63, 1.62, 1.63, 1.54, 1.56, 1.55, 1.6,
326 1.64, 1.75, 1.8, 1.96, 2.08, 2.26, 2.38, 2.59, 2.79, 2.91, 2.99, 3.14, 3.52, 3.73, 3.95, 4.1,
327 4.13, 4.01, 3.86, 1.78
328 },
329 {
330 3.16, 4.53, 3.66, 2.69, 3.28, 3.9, 3.01, 3.16, 3.17, 2.91, 3.2, 2.18, 2.72, 2.11, 2.32, 2.58,
331 2.89, 3.11, 3.31, 3.25, 3.16, 3.02, 2.89, 2.87, 3.07, 3.27, 3.27, 3.18, 2.75, 2.37, 2.22, 2.26,
332 2.35, 2.42, 2.5, 2.53, 2.36, 2.12, 1.8, 1.63, 1.65, 1.8, 1.99, 2.06, 2.21, 2.24, 2.36, 2.45,
333 2.51, 2.55, 2.64, 2.7, 2.77, 2.83, 2.88, 2.97, 3.08, 3.16, 3.24, 3.22, 3.15, 2.94, 2.73, 2.51,
334 2.38, 2.34, 2.27, 2.2, 2.22, 2.16, 2.15, 2.07, 2.02, 1.94, 1.89, 1.94, 1.95, 2.0, 2.2, 2.45,
335 2.76, 3.01, 3.28, 3.55, 3.54, 3.71, 3.68, 3.88, 3.96, 4.05, 4.08, 4.26, 4.47, 4.7, 4.74, 4.88,
336 4.86, 4.81, 4.52, 2.24
337 },
338 {
339 4.53, 2.88, 1.1, 2.47, 3.57, 2.03, 1.38, 2.58, 1.56, 1.4, 1.42, 1.52, 1.54, 1.64, 1.76, 1.85,
340 1.96, 2.12, 2.29, 2.57, 2.98, 3.48, 3.95, 4.43, 4.82, 4.95, 5.01, 4.85, 4.75, 4.21, 3.53, 2.93,
341 2.45, 2.02, 1.82, 1.6, 1.45, 1.29, 1.19, 1.07, 0.92, 0.84, 0.77, 0.73, 0.81, 1.04, 1.33, 1.55,
342 1.76, 1.88, 2.05, 2.13, 2.2, 2.35, 2.37, 2.49, 2.55, 2.67, 2.76, 2.9, 2.96, 3.05, 3.1, 3.16,
343 3.34, 3.34, 3.46, 3.49, 3.69, 3.69, 3.83, 3.91, 3.99, 4.14, 4.14, 4.22, 4.37, 4.42, 4.55, 4.55,
344 4.74, 4.9, 5.06, 5.11, 5.27, 5.28, 5.34, 5.34, 5.37, 5.56, 5.59, 5.68, 5.78, 5.87, 5.96, 6.22,
345 6.29, 6.11, 5.57, 2.84
346 },
347 {
348 3.6, 1.42, 0.89, 2.24, 2.72, 1.27, 1.14, 1.17, 1.22, 1.23, 1.34, 1.32, 1.44, 1.49, 1.59, 1.71,
349 1.79, 1.93, 2.11, 2.32, 2.58, 2.9, 3.46, 4.3, 5.16, 5.49, 5.58, 5.52, 5.22, 4.48, 3.44, 2.69,
350 2.18, 1.86, 1.6, 1.39, 1.2, 1.03, 0.92, 0.82, 0.73, 0.65, 0.62, 0.57, 0.54, 0.52, 0.54, 0.73,
351 1.04, 1.34, 1.55, 1.7, 1.84, 1.98, 2.04, 2.2, 2.31, 2.39, 2.51, 2.61, 2.71, 2.79, 2.93, 3.12,
352 3.42, 3.78, 4.14, 4.5, 4.77, 5.02, 5.23, 5.49, 5.58, 5.61, 5.56, 5.55, 5.44, 5.44, 5.42, 5.49,
353 5.54, 5.63, 5.76, 5.94, 5.99, 6.04, 5.96, 6.05, 6.15, 6.15, 6.23, 6.32, 6.42, 6.44, 6.6, 6.83,
354 6.93, 6.9, 6.15, 3.12
355 },
356 {
357 2.05, 0.84, 0.9, 1.14, 1.09, 0.99, 1.08, 1.12, 1.15, 1.21, 1.23, 1.3, 1.36, 1.42, 1.53, 1.58,
358 1.68, 1.84, 2.07, 2.3, 2.59, 2.87, 3.33, 3.96, 4.66, 5.27, 5.7, 5.58, 5.04, 4.32, 3.37, 2.71,
359 2.29, 1.9, 1.54, 1.25, 1.0, 0.86, 0.75, 0.68, 0.61, 0.55, 0.53, 0.5, 0.47, 0.45, 0.44, 0.44,
360 0.47, 0.57, 0.76, 1.04, 1.29, 1.55, 1.7, 1.82, 1.94, 2.1, 2.23, 2.49, 2.74, 3.14, 3.43, 3.86,
361 4.12, 4.48, 4.74, 4.91, 5.16, 5.35, 5.57, 5.79, 5.99, 6.16, 6.33, 6.49, 6.61, 6.69, 6.75, 6.72,
362 6.7, 6.69, 6.71, 6.64, 6.73, 6.79, 6.89, 6.75, 6.85, 6.86, 6.99, 6.98, 7.06, 7.03, 7.08, 7.35,
363 7.44, 7.31, 6.48, 3.32
364 },
365 {
366 0.54, 0.54, 0.66, 0.66, 0.68, 0.77, 0.79, 0.82, 0.92, 0.9, 0.93, 1.0, 1.01, 1.07, 1.13, 1.19,
367 1.25, 1.42, 1.54, 1.78, 2.0, 2.31, 2.7, 3.22, 3.6, 3.68, 3.64, 3.68, 3.78, 3.6, 2.83, 2.27,
368 1.83, 1.43, 1.1, 0.89, 0.72, 0.58, 0.49, 0.45, 0.43, 0.39, 0.37, 0.33, 0.34, 0.32, 0.32, 0.31,
369 0.34, 0.32, 0.33, 0.36, 0.43, 0.62, 0.83, 1.07, 1.37, 1.74, 2.14, 2.55, 2.88, 3.24, 3.47, 3.74,
370 4.01, 4.29, 4.52, 4.74, 4.91, 5.1, 5.31, 5.46, 5.62, 5.84, 5.97, 6.14, 6.26, 6.41, 6.52, 6.62,
371 6.78, 6.82, 6.98, 7.03, 7.0, 6.99, 7.0, 6.84, 6.85, 6.65, 6.59, 6.49, 6.44, 6.31, 6.12, 6.05,
372 6.05, 6.01, 5.23, 2.58
373 }
374 };
375 const double nfotMC[8] = {2.5503, 2.5504, 2.6065, 2.7892, 2.9729, 3.0088, 3.045, 2.6138};
376
377 if (row < 0 or row > 7) return 0;
378
379 if (h_mu->GetNbinsX() != 100 or h_mu->GetXaxis()->GetXmin() != -130 or h_mu->GetXaxis()->GetXmax() != 130) {
380 B2ERROR("Histogram " << h_mu->GetTitle() << ": wrong number of bins or wrong range, no yield corrections possible");
381 return 0;
382 }
383
384 const double* nFot = numFot[row];
385 double nfot = 0;
386 double suma = 0;
387 for (int i = 0; i < 100; i++) {
388 double binContent = h_mu->GetBinContent(i + 1);
389 nfot += nFot[i] * binContent;
390 suma += binContent;
391 }
392 if (suma != 0) nfot /= suma;
393
394 return nfot / nfotMC[row];
395 }
396
397 } // end namespace TOP
399} // end namespace Belle2
Belle2::CalibrationAlgorithm::saveCalibration
void saveCalibration(TClonesArray *data, const std::string &name)
Store DBArray payload with given name with default IOV.
Definition CalibrationAlgorithm.cc:297
Belle2::CalibrationAlgorithm::updateDBObjPtrs
static void updateDBObjPtrs(const unsigned int event, const int run, const int experiment)
Updates any DBObjPtrs by calling update(event) for DBStore.
Definition CalibrationAlgorithm.cc:405
Belle2::CalibrationAlgorithm::setDescription
void setDescription(const std::string &description)
Set algorithm description (in constructor)
Definition CalibrationAlgorithm.h:321
Belle2::CalibrationAlgorithm::getRunList
const std::vector< Calibration::ExpRun > & getRunList() const
Get the list of runs for which calibration is called.
Definition CalibrationAlgorithm.h:266
Belle2::CalibrationAlgorithm::EResult
EResult
The result of calibration.
Definition CalibrationAlgorithm.h:40
Belle2::CalibrationAlgorithm::c_OK
@ c_OK
Finished successfully =0 in Python.
Definition CalibrationAlgorithm.h:41
Belle2::CalibrationAlgorithm::CalibrationAlgorithm
CalibrationAlgorithm(const std::string &collectorModuleName)
Constructor - sets the prefix for collected objects (won't be accesses until execute(....
Definition CalibrationAlgorithm.h:140
Belle2::TOPCalChannelRQE
Class to store relative quantum efficiency of channels w.r.t initial one measured in PMT QA QE is exp...
Definition TOPCalChannelRQE.h:24
Belle2::TOPCalPhotonYields
Class to store photon pixel yields for PMT ageing studies, and equalized alpha ratios for finding opt...
Definition TOPCalPhotonYields.h:26
Belle2::TOPCalTOFCorrection
Time-of-flight corrections as a function of ExtHit z-coordinate expressed in a TOP module frame.
Definition TOPCalTOFCorrection.h:24
Belle2::TOP::TOPGeometryPar::Instance
static TOPGeometryPar * Instance()
Static method to obtain the pointer to its instance.
Definition TOPGeometryPar.cc:42
Belle2::TOP::TOPPhotonYieldsAlgorithm::equalize
static void equalize(TH1F *h)
Equalize alpha ratio histogram.
Definition TOPPhotonYieldsAlgorithm.cc:262
Belle2::TOP::TOPPhotonYieldsAlgorithm::m_maxErrorRQE
double m_maxErrorRQE
maximal error on RQE required for good calibration
Definition TOPPhotonYieldsAlgorithm.h:80
Belle2::TOP::TOPPhotonYieldsAlgorithm::calibrate
virtual EResult calibrate() final
algorithm implementation
Definition TOPPhotonYieldsAlgorithm.cc:36
Belle2::TOP::TOPPhotonYieldsAlgorithm::getEqualizingValue
static double getEqualizingValue(int bin)
Returns equalizing value for alpha ratio.
Definition TOPPhotonYieldsAlgorithm.cc:243
Belle2::TOP::TOPPhotonYieldsAlgorithm::getMuonCorrection
static double getMuonCorrection(const TH1F *h_mu, int row)
Returns photon yield correction factor according to muon local-z distribution.
Definition TOPPhotonYieldsAlgorithm.cc:299
Belle2::TOP::TOPPhotonYieldsAlgorithm::getNominalYield
static double getNominalYield(int slot, int row, int col)
Returns photon yield of nominal QE for given slot and pixel.
Definition TOPPhotonYieldsAlgorithm.cc:272
Belle2::TOP::TOPPhotonYieldsAlgorithm::m_maxRQE
double m_maxRQE
maximal RQE required for good calibration
Definition TOPPhotonYieldsAlgorithm.h:79
Belle2::CalibrationAlgorithm::getObjectPtr
std::shared_ptr< T > getObjectPtr(const std::string &name, const std::vector< Calibration::ExpRun > &requestedRuns)
Get calibration data object by name and list of runs, the Merge function will be called to generate t...
Definition CalibrationAlgorithm.h:414
Belle2
Abstract base class for different kinds of events.
Definition MillepedeAlgorithm.h:17
std
STL namespace.