Belle II Software development
KLMCalibrationChecker.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/* Own header. */
10#include <klm/calibration/KLMCalibrationChecker.h>
11
12/* KLM headers. */
13#include <klm/dataobjects/bklm/BKLMElementNumbers.h>
14#include <klm/dataobjects/eklm/EKLMElementNumbers.h>
15#include <klm/dataobjects/KLMChannelIndex.h>
16#include <klm/dbobjects/bklm/BKLMAlignment.h>
17#include <klm/dbobjects/eklm/EKLMAlignment.h>
18#include <klm/dbobjects/eklm/EKLMSegmentAlignment.h>
19#include <klm/dbobjects/KLMStripEfficiency.h>
20#include <klm/dbobjects/KLMTimeCableDelay.h>
21#include <klm/dbobjects/KLMTimeConstants.h>
22
23/* Belle II headers. */
24#include <framework/database/Database.h>
25#include <framework/database/DBStore.h>
26#include <framework/database/Configuration.h>
27#include <framework/datastore/DataStore.h>
28
29/* ROOT include. */
30#include <TCanvas.h>
31#include <TFile.h>
32#include <TH1F.h>
33#include <TString.h>
34#include <TTree.h>
35
36using namespace Belle2;
37
38KLMCalibrationChecker::KLMCalibrationChecker() :
39 m_experiment(0),
40 m_run(0),
41 m_ElementNumbers(&(KLMElementNumbers::Instance()))
42{
43}
44
45KLMCalibrationChecker::~KLMCalibrationChecker()
46{
47}
48
49void KLMCalibrationChecker::setExperimentRun(int experiment, int run)
50{
51 m_experiment = experiment;
52 m_run = run;
53 if (m_EventMetaData.isValid()) {
54 m_EventMetaData->setExperiment(experiment);
55 m_EventMetaData->setRun(run);
56 }
57}
58
59void KLMCalibrationChecker::initializeDatabase()
60{
61 /* Mimic a module initialization. */
62 DataStore::Instance().setInitializeActive(true);
63 m_EventMetaData.registerInDataStore();
64 DataStore::Instance().setInitializeActive(false);
65 if (!m_EventMetaData.isValid())
66 m_EventMetaData.construct(1, m_run, m_experiment);
67 /* Database instance and configuration. */
68 DBStore& dbStore = DBStore::Instance();
69 dbStore.update();
70 dbStore.updateEvent();
71 auto& dbConfiguration = Conditions::Configuration::getInstance();
72 if ((m_testingPayloadName != "") and (m_GlobalTagName == ""))
73 dbConfiguration.prependTestingPayloadLocation(m_testingPayloadName);
74 else if ((m_testingPayloadName == "") and (m_GlobalTagName != ""))
75 dbConfiguration.prependGlobalTag(m_GlobalTagName);
76 else
77 B2FATAL("Setting both testing payload and Global Tag or setting no one of them.");
78}
79
80void KLMCalibrationChecker::resetDatabase()
81{
82 /* Reset both DataStore and Database. */
83 DataStore::Instance().reset();
84 Database::Instance().reset(false);
85 DBStore::Instance().reset(false);
86}
87
88void KLMCalibrationChecker::checkAlignment()
89{
90 /* Initialize the database. */
91 initializeDatabase();
92 /* Now we can read the payload. */
93 DBObjPtr<BKLMAlignment> bklmAlignment;
94 DBObjPtr<EKLMAlignment> eklmAlignment;
95 DBObjPtr<EKLMSegmentAlignment> eklmSegmentAlignment;
96 DBObjPtr<BKLMAlignment> bklmAlignmentErrors("BKLMAlignment_ERRORS");
97 DBObjPtr<EKLMAlignment> eklmAlignmentErrors("EKLMAlignment_ERRORS");
98 DBObjPtr<EKLMSegmentAlignment> eklmSegmentAlignmentErrors("EKLMSegmentAlignment_ERRORS");
99 DBObjPtr<BKLMAlignment> bklmAlignmentCorrections("BKLMAlignment_CORRECTIONS");
100 DBObjPtr<EKLMAlignment> eklmAlignmentCorrections("EKLMAlignment_CORRECTIONS");
101 DBObjPtr<EKLMSegmentAlignment> eklmSegmentAlignmentCorrections("EKLMSegmentAlignment_CORRECTIONS");
102 if (!bklmAlignment.isValid() ||
103 !eklmAlignment.isValid() ||
104 !eklmSegmentAlignment.isValid() ||
105 !bklmAlignmentErrors.isValid() ||
106 !eklmAlignmentErrors.isValid() ||
107 !eklmSegmentAlignmentErrors.isValid() ||
108 !bklmAlignmentCorrections.isValid() ||
109 !eklmAlignmentCorrections.isValid() ||
110 !eklmSegmentAlignmentCorrections.isValid())
111 B2FATAL("Alignment data are not valid.");
112 if (m_GlobalTagName != "") {
113 printPayloadInformation(bklmAlignment);
114 printPayloadInformation(eklmAlignment);
115 printPayloadInformation(eklmSegmentAlignment);
116 printPayloadInformation(bklmAlignmentErrors);
117 printPayloadInformation(eklmAlignmentErrors);
118 printPayloadInformation(eklmSegmentAlignmentErrors);
119 printPayloadInformation(bklmAlignmentCorrections);
120 printPayloadInformation(eklmAlignmentCorrections);
121 printPayloadInformation(eklmSegmentAlignmentCorrections);
122 }
123 /* Create trees with alignment results. */
124 int section, sector, layer, plane, segment, param;
125 float value, correction, error;
126 TFile* alignmentResults = new TFile(m_AlignmentResultsFile.c_str(),
127 "recreate");
128 TTree* bklmModuleTree = new TTree("bklm_module",
129 "BKLM module alignment data.");
130 bklmModuleTree->Branch("experiment", &m_experiment, "experiment/I");
131 bklmModuleTree->Branch("run", &m_run, "run/I");
132 bklmModuleTree->Branch("section", &section, "section/I");
133 bklmModuleTree->Branch("sector", &sector, "sector/I");
134 bklmModuleTree->Branch("layer", &layer, "layer/I");
135 bklmModuleTree->Branch("param", &param, "param/I");
136 bklmModuleTree->Branch("value", &value, "value/F");
137 bklmModuleTree->Branch("correction", &correction, "correction/F");
138 bklmModuleTree->Branch("error", &error, "error/F");
139 TTree* eklmModuleTree = new TTree("eklm_module",
140 "EKLM module alignment data.");
141 eklmModuleTree->Branch("experiment", &m_experiment, "experiment/I");
142 eklmModuleTree->Branch("run", &m_run, "run/I");
143 eklmModuleTree->Branch("section", &section, "section/I");
144 eklmModuleTree->Branch("sector", &sector, "sector/I");
145 eklmModuleTree->Branch("layer", &layer, "layer/I");
146 eklmModuleTree->Branch("param", &param, "param/I");
147 eklmModuleTree->Branch("value", &value, "value/F");
148 eklmModuleTree->Branch("correction", &correction, "correction/F");
149 eklmModuleTree->Branch("error", &error, "error/F");
150 TTree* eklmSegmentTree = new TTree("eklm_segment",
151 "EKLM segment alignment data.");
152 eklmSegmentTree->Branch("experiment", &m_experiment, "experiment/I");
153 eklmSegmentTree->Branch("run", &m_run, "run/I");
154 eklmSegmentTree->Branch("section", &section, "section/I");
155 eklmSegmentTree->Branch("sector", &sector, "sector/I");
156 eklmSegmentTree->Branch("layer", &layer, "layer/I");
157 eklmSegmentTree->Branch("plane", &plane, "plane/I");
158 eklmSegmentTree->Branch("segment", &segment, "segment/I");
159 eklmSegmentTree->Branch("param", &param, "param/I");
160 eklmSegmentTree->Branch("value", &value, "value/F");
161 eklmSegmentTree->Branch("correction", &correction, "correction/F");
162 eklmSegmentTree->Branch("error", &error, "error/F");
163 const KLMAlignmentData* alignment, *alignmentError, *alignmentCorrection;
164 KLMAlignmentData zeroAlignment(0, 0, 0, 0, 0, 0);
165 KLMChannelIndex klmModules(KLMChannelIndex::c_IndexLevelLayer);
166 for (KLMChannelIndex& klmModule : klmModules) {
167 KLMModuleNumber module = klmModule.getKLMModuleNumber();
168 if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM) {
169 alignment = bklmAlignment->getModuleAlignment(module);
170 alignmentError = bklmAlignmentErrors->getModuleAlignment(module);
171 alignmentCorrection =
172 bklmAlignmentCorrections->getModuleAlignment(module);
173 } else {
174 alignment = eklmAlignment->getModuleAlignment(module);
175 alignmentError = eklmAlignmentErrors->getModuleAlignment(module);
176 alignmentCorrection =
177 eklmAlignmentCorrections->getModuleAlignment(module);
178 }
179 if (alignment == nullptr)
180 B2FATAL("Incomplete KLM alignment data.");
181 if ((alignmentError == nullptr) && (alignmentCorrection == nullptr)) {
182 B2WARNING("Alignment is not determined for KLM module."
183 << LogVar("Module", module));
184 alignmentError = &zeroAlignment;
185 alignmentCorrection = &zeroAlignment;
186 } else if ((alignmentError == nullptr) ||
187 (alignmentCorrection == nullptr)) {
188 B2FATAL("Inconsistent undtermined parameters.");
189 }
190 section = klmModule.getSection();
191 sector = klmModule.getSector();
192 layer = klmModule.getLayer();
193 param = KLMAlignmentData::c_DeltaU;
194 value = alignment->getDeltaU();
195 error = alignmentError->getDeltaU();
196 correction = alignmentCorrection->getDeltaU();
197 if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
198 bklmModuleTree->Fill();
199 else
200 eklmModuleTree->Fill();
201 /* cppcheck-suppress redundantAssignment */
202 param = KLMAlignmentData::c_DeltaV;
203 /* cppcheck-suppress redundantAssignment */
204 value = alignment->getDeltaV();
205 /* cppcheck-suppress redundantAssignment */
206 error = alignmentError->getDeltaV();
207 /* cppcheck-suppress redundantAssignment */
208 correction = alignmentCorrection->getDeltaV();
209 if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
210 bklmModuleTree->Fill();
211 else
212 eklmModuleTree->Fill();
213 /* cppcheck-suppress redundantAssignment */
214 param = KLMAlignmentData::c_DeltaW;
215 /* cppcheck-suppress redundantAssignment */
216 value = alignment->getDeltaW();
217 /* cppcheck-suppress redundantAssignment */
218 error = alignmentError->getDeltaW();
219 /* cppcheck-suppress redundantAssignment */
220 correction = alignmentCorrection->getDeltaW();
221 if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
222 bklmModuleTree->Fill();
223 else
224 eklmModuleTree->Fill();
225 /* cppcheck-suppress redundantAssignment */
226 param = KLMAlignmentData::c_DeltaAlpha;
227 /* cppcheck-suppress redundantAssignment */
228 value = alignment->getDeltaAlpha();
229 /* cppcheck-suppress redundantAssignment */
230 error = alignmentError->getDeltaAlpha();
231 /* cppcheck-suppress redundantAssignment */
232 correction = alignmentCorrection->getDeltaAlpha();
233 if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
234 bklmModuleTree->Fill();
235 else
236 eklmModuleTree->Fill();
237 /* cppcheck-suppress redundantAssignment */
238 param = KLMAlignmentData::c_DeltaBeta;
239 /* cppcheck-suppress redundantAssignment */
240 value = alignment->getDeltaBeta();
241 /* cppcheck-suppress redundantAssignment */
242 error = alignmentError->getDeltaBeta();
243 /* cppcheck-suppress redundantAssignment */
244 correction = alignmentCorrection->getDeltaBeta();
245 if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
246 bklmModuleTree->Fill();
247 else
248 eklmModuleTree->Fill();
249 /* cppcheck-suppress redundantAssignment */
250 param = KLMAlignmentData::c_DeltaGamma;
251 /* cppcheck-suppress redundantAssignment */
252 value = alignment->getDeltaGamma();
253 /* cppcheck-suppress redundantAssignment */
254 error = alignmentError->getDeltaGamma();
255 /* cppcheck-suppress redundantAssignment */
256 correction = alignmentCorrection->getDeltaGamma();
257 if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM)
258 bklmModuleTree->Fill();
259 else
260 eklmModuleTree->Fill();
261 }
262 KLMChannelIndex eklmSegments(KLMChannelIndex::c_IndexLevelStrip);
263 KLMChannelIndex eklmSegment(KLMChannelIndex::c_IndexLevelStrip);
264 eklmSegment = eklmSegments.beginEKLM();
265 eklmSegment.useEKLMSegments();
266 for (; eklmSegment != eklmSegments.endEKLM(); ++eklmSegment) {
267 int eklmSegmentNumber = eklmSegment.getEKLMSegmentNumber();
268 alignment = eklmSegmentAlignment->getSegmentAlignment(eklmSegmentNumber);
269 alignmentError =
270 eklmSegmentAlignmentErrors->getSegmentAlignment(eklmSegmentNumber);
271 alignmentCorrection =
272 eklmSegmentAlignmentCorrections->getSegmentAlignment(eklmSegmentNumber);
273 if (alignment == nullptr)
274 B2FATAL("Incomplete KLM alignment data.");
275 if ((alignmentError == nullptr) && (alignmentCorrection == nullptr)) {
276 /*
277 * The segment alignment is not determined now.
278 * TODO: If it will be turned on in the future, add a warning here.
279 */
280 alignmentError = &zeroAlignment;
281 alignmentCorrection = &zeroAlignment;
282 } else if ((alignmentError == nullptr) ||
283 (alignmentCorrection == nullptr)) {
284 B2FATAL("Inconsistent undtermined parameters.");
285 }
286 section = eklmSegment.getSection();
287 sector = eklmSegment.getSector();
288 layer = eklmSegment.getLayer();
289 plane = eklmSegment.getPlane();
290 segment = eklmSegment.getStrip();
291 param = KLMAlignmentData::c_DeltaU;
292 value = alignment->getDeltaU();
293 error = alignmentError->getDeltaU();
294 correction = alignmentCorrection->getDeltaU();
295 eklmSegmentTree->Fill();
296 /* cppcheck-suppress redundantAssignment */
297 param = KLMAlignmentData::c_DeltaV;
298 /* cppcheck-suppress redundantAssignment */
299 value = alignment->getDeltaV();
300 /* cppcheck-suppress redundantAssignment */
301 error = alignmentError->getDeltaV();
302 /* cppcheck-suppress redundantAssignment */
303 correction = alignmentCorrection->getDeltaV();
304 eklmSegmentTree->Fill();
305 /* cppcheck-suppress redundantAssignment */
306 param = KLMAlignmentData::c_DeltaW;
307 /* cppcheck-suppress redundantAssignment */
308 value = alignment->getDeltaW();
309 /* cppcheck-suppress redundantAssignment */
310 error = alignmentError->getDeltaW();
311 /* cppcheck-suppress redundantAssignment */
312 correction = alignmentCorrection->getDeltaW();
313 eklmSegmentTree->Fill();
314 /* cppcheck-suppress redundantAssignment */
315 param = KLMAlignmentData::c_DeltaAlpha;
316 /* cppcheck-suppress redundantAssignment */
317 value = alignment->getDeltaAlpha();
318 /* cppcheck-suppress redundantAssignment */
319 error = alignmentError->getDeltaAlpha();
320 /* cppcheck-suppress redundantAssignment */
321 correction = alignmentCorrection->getDeltaAlpha();
322 eklmSegmentTree->Fill();
323 /* cppcheck-suppress redundantAssignment */
324 param = KLMAlignmentData::c_DeltaBeta;
325 /* cppcheck-suppress redundantAssignment */
326 value = alignment->getDeltaBeta();
327 /* cppcheck-suppress redundantAssignment */
328 error = alignmentError->getDeltaBeta();
329 /* cppcheck-suppress redundantAssignment */
330 correction = alignmentCorrection->getDeltaBeta();
331 eklmSegmentTree->Fill();
332 /* cppcheck-suppress redundantAssignment */
333 param = KLMAlignmentData::c_DeltaGamma;
334 /* cppcheck-suppress redundantAssignment */
335 value = alignment->getDeltaGamma();
336 /* cppcheck-suppress redundantAssignment */
337 error = alignmentError->getDeltaGamma();
338 /* cppcheck-suppress redundantAssignment */
339 correction = alignmentCorrection->getDeltaGamma();
340 eklmSegmentTree->Fill();
341 }
342 bklmModuleTree->Write();
343 eklmModuleTree->Write();
344 eklmSegmentTree->Write();
345 delete bklmModuleTree;
346 delete eklmModuleTree;
347 delete eklmSegmentTree;
348 delete alignmentResults;
349 /* Reset the database. Needed to avoid mess if we call this method multiple times with different GTs. */
350 resetDatabase();
351}
352
353void KLMCalibrationChecker::checkStripEfficiency()
354{
355 /* Initialize the database. */
356 initializeDatabase();
357 /* Now we can read the payload. */
358 DBObjPtr<KLMStripEfficiency> stripEfficiency;
359 if (!stripEfficiency.isValid())
360 B2FATAL("Strip efficiency data are not valid.");
361 if (m_GlobalTagName != "")
362 printPayloadInformation(stripEfficiency);
363 /* Create trees with strip efficiency measurement results. */
364 int subdetector, section, sector, layer, plane;
365 float efficiency, error;
366 TFile* stripEfficiencyResults =
367 new TFile(m_StripEfficiencyResultsFile.c_str(), "recreate");
368 TTree* efficiencyTree = new TTree("efficiency", "KLM strip efficiency data.");
369 efficiencyTree->Branch("experiment", &m_experiment, "experiment/I");
370 efficiencyTree->Branch("run", &m_run, "run/I");
371 efficiencyTree->Branch("subdetector", &subdetector, "subdetector/I");
372 efficiencyTree->Branch("section", &section, "section/I");
373 efficiencyTree->Branch("sector", &sector, "sector/I");
374 efficiencyTree->Branch("layer", &layer, "layer/I");
375 efficiencyTree->Branch("plane", &plane, "plane/I");
376 efficiencyTree->Branch("efficiency", &efficiency, "efficiency/F");
377 efficiencyTree->Branch("error", &error, "error/F");
378 KLMChannelIndex klmPlanes(KLMChannelIndex::c_IndexLevelPlane);
379 for (KLMChannelIndex& klmPlane : klmPlanes) {
380 subdetector = klmPlane.getSubdetector();
381 section = klmPlane.getSection();
382 sector = klmPlane.getSector();
383 layer = klmPlane.getLayer();
384 plane = klmPlane.getPlane();
385 KLMChannelNumber channel = m_ElementNumbers->channelNumber(
386 subdetector, section, sector, layer, plane, 1);
387 efficiency = stripEfficiency->getEfficiency(channel);
388 error = stripEfficiency->getEfficiencyError(channel);
389 efficiencyTree->Fill();
390 }
391 efficiencyTree->Write();
392 delete efficiencyTree;
393 delete stripEfficiencyResults;
394 /* Reset the database. Needed to avoid mess if we call this method multiple times with different GTs. */
395 resetDatabase();
396}
397
398void KLMCalibrationChecker::createStripEfficiencyHistograms()
399{
400 /* Initialize the database. */
401 initializeDatabase();
402 /* Now we can read the payload. */
403 DBObjPtr<KLMStripEfficiency> stripEfficiency;
404 if (not stripEfficiency.isValid())
405 B2FATAL("Strip efficiency data are not valid.");
406 if (m_GlobalTagName != "")
407 printPayloadInformation(stripEfficiency);
408 /* Finally, loop over KLM sectors to check the efficiency. */
409 KLMChannelIndex klmSectors(KLMChannelIndex::c_IndexLevelSector);
410 TCanvas* canvas = new TCanvas();
411 for (KLMChannelIndex& klmSector : klmSectors) {
412 int subdetector = klmSector.getSubdetector();
413 int section = klmSector.getSection();
414 int sector = klmSector.getSector();
415 /* Setup the histogram. */
416 TH1F* hist = new TH1F("plane_histogram", "", 30, 0.5, 30.5);
417 hist->GetYaxis()->SetTitle("Efficiency");
418 hist->SetMinimum(0.4);
419 hist->SetMaximum(1.);
420 hist->SetMarkerStyle(20);
421 hist->SetMarkerSize(0.5);
422 TString title;
423 if (subdetector == KLMElementNumbers::c_BKLM) {
424 if (section == BKLMElementNumbers::c_BackwardSection)
425 title.Form("BKLM backward sector %d", sector);
426 else
427 title.Form("BKLM forward sector %d", sector);
428 hist->SetTitle(title.Data());
429 hist->GetXaxis()->SetTitle("(Layer - 1) * 2 + plane + 1");
430 for (int layer = 1; layer <= BKLMElementNumbers::getMaximalLayerNumber(); layer++) {
431 for (int plane = 0; plane <= BKLMElementNumbers::getMaximalPlaneNumber(); plane++) {
432 int bin = (layer - 1) * 2 + plane + 1;
433 float efficiency = stripEfficiency->getBarrelEfficiency(section, sector, layer, plane, 2);
434 float efficiencyError = stripEfficiency->getBarrelEfficiencyError(section, sector, layer, plane, 2);
435 hist->SetBinContent(bin, efficiency);
436 hist->SetBinError(bin, efficiencyError);
437 }
438 }
439 } else {
440 if (section == EKLMElementNumbers::c_BackwardSection) {
441 hist->SetBins(24, 0.5, 24.5);
442 title.Form("EKLM backward sector %d", sector);
443 } else {
444 hist->SetBins(28, 0.5, 28.5);
445 title.Form("EKLM forward sector %d", sector);
446 }
447 hist->SetTitle(title.Data());
448 hist->GetXaxis()->SetTitle("(Layer - 1) * 2 + plane");
449 const EKLMElementNumbers* elementNumbersEKLM = &(EKLMElementNumbers::Instance());
450 for (int layer = 1; layer <= elementNumbersEKLM->getMaximalDetectorLayerNumber(section); layer++) {
451 for (int plane = 1; plane <= EKLMElementNumbers::getMaximalPlaneNumber(); plane++) {
452 int bin = (layer - 1) * 2 + plane;
453 float efficiency = stripEfficiency->getEndcapEfficiency(section, sector, layer, plane, 2);
454 float efficiencyError = stripEfficiency->getEndcapEfficiencyError(section, sector, layer, plane, 2);
455 hist->SetBinContent(bin, efficiency);
456 hist->SetBinError(bin, efficiencyError);
457 }
458 }
459 }
460 hist->Draw("e");
461 TString name;
462 name.Form("efficiency_subdetector_%d_section_%d_sector_%d.pdf", subdetector, section, sector);
463 canvas->Print(name.Data());
464 canvas->Update();
465 delete hist;
466 }
467 delete canvas;
468 /* Reset the database. Needed to avoid mess if we call this method multiple times with different GTs. */
469 resetDatabase();
470}
471
472
473void KLMCalibrationChecker::checkTimeCableDelay()
474{
475 /* Initialize the database. */
476 initializeDatabase();
477 /* Now we can read the payload. */
478 DBObjPtr<KLMTimeCableDelay> timeCableDelay;
479 if (!timeCableDelay.isValid())
480 B2FATAL("Time Cable delay data are not valid.");
481 if (m_GlobalTagName != "")
482 printPayloadInformation(timeCableDelay);
483 /* Create trees with time cable delay measurement results. */
484 int subdetector, section, sector, layer, plane, strip, channelNumber;
485 double timeDelay;
486 TFile* timeCableDelayResults =
487 new TFile(m_TimeCableDelayResultsFile.c_str(), "recreate");
488 TTree* cableDelayTree = new TTree("cabledelay", "KLM timecabledelay data");
489 cableDelayTree->Branch("experiment", &m_experiment, "experiment/I");
490 cableDelayTree->Branch("run", &m_run, "run/I");
491 cableDelayTree->Branch("subdetector", &subdetector, "subdetector/I");
492 cableDelayTree->Branch("section", &section, "section/I");
493 cableDelayTree->Branch("sector", &sector, "sector/I");
494 cableDelayTree->Branch("layer", &layer, "layer/I");
495 cableDelayTree->Branch("plane", &plane, "plane/I");
496 cableDelayTree->Branch("strip", &strip, "strip/I");
497 cableDelayTree->Branch("channelNumber", &channelNumber, "channelNumber/I");
498 cableDelayTree->Branch("timeDelay", &timeDelay, "timeDelay/D");
499 KLMChannelIndex klmStrips(KLMChannelIndex::c_IndexLevelStrip);
500 for (KLMChannelIndex& klmStrip : klmStrips) {
501 subdetector = klmStrip.getSubdetector();
502 section = klmStrip.getSection();
503 sector = klmStrip.getSector();
504 layer = klmStrip.getLayer();
505 plane = klmStrip.getPlane();
506 strip = klmStrip.getStrip();
507 KLMChannelNumber channel = m_ElementNumbers->channelNumber(
508 subdetector, section, sector, layer, plane, strip);
509 timeDelay = timeCableDelay->getTimeDelay(channel);
510 channelNumber = m_ElementNumbers->channelNumber(subdetector, section, sector, layer, plane, strip);
511 cableDelayTree->Fill();
512 }
513 cableDelayTree->Write();
514 delete cableDelayTree;
515 delete timeCableDelayResults;
516 /* Reset the database. Needed to avoid mess if we call this method multiple times with different GTs. */
517 resetDatabase();
518}
519
520void KLMCalibrationChecker::checkTimeConstants()
521{
522 /* Initialize the database. */
523 initializeDatabase();
524 /* Now we can read the payload. */
525 DBObjPtr<KLMTimeConstants> timeConstants;
526 if (!timeConstants.isValid())
527 B2FATAL("Time Constants data are not valid.");
528 if (m_GlobalTagName != "")
529 printPayloadInformation(timeConstants);
530 /* Create trees with time constant measurement results. */
531 int subdetector, section, sector, layer, plane, strip, module, channelNumber;
532 float delayEKLM, delayBKLM, delayRPCPhi, delayRPCZ;
533 TFile* timeConstantsResults =
534 new TFile(m_TimeConstantsResultsFile.c_str(), "recreate");
535 TTree* constantsTree = new TTree("constants", "KLM timeConstants data");
536 constantsTree->Branch("experiment", &m_experiment, "experiment/I");
537 constantsTree->Branch("run", &m_run, "run/I");
538 constantsTree->Branch("subdetector", &subdetector, "subdetector/I");
539 constantsTree->Branch("section", &section, "section/I");
540 constantsTree->Branch("sector", &sector, "sector/I");
541 constantsTree->Branch("layer", &layer, "layer/I");
542 constantsTree->Branch("plane", &plane, "plane/I");
543 constantsTree->Branch("strip", &strip, "strip/I");
544 constantsTree->Branch("module", &module, "module/I");
545 constantsTree->Branch("channelNumber", &channelNumber, "channelNumber/I");
546 constantsTree->Branch("delayEKLM", &delayEKLM, "delayEKLM/F");
547 constantsTree->Branch("delayBKLM", &delayBKLM, "delayBKLM/F");
548 constantsTree->Branch("delayRPCPhi", &delayRPCPhi, "delayRPCPhi/F");
549 constantsTree->Branch("delayRPCZ", &delayRPCZ, "delayRPCZ/F");
550 KLMChannelIndex klmStrips(KLMChannelIndex::c_IndexLevelStrip);
551 for (KLMChannelIndex& klmStrip : klmStrips) {
552 subdetector = klmStrip.getSubdetector();
553 section = klmStrip.getSection();
554 sector = klmStrip.getSector();
555 layer = klmStrip.getLayer();
556 plane = klmStrip.getPlane();
557 strip = klmStrip.getStrip();
558 channelNumber = m_ElementNumbers->channelNumber(subdetector, section, sector, layer, plane, strip);
559 module = m_ElementNumbers->moduleNumber(subdetector, section, sector, layer);
560 delayEKLM = timeConstants->getDelay(KLMTimeConstants::c_EKLM);
561 delayBKLM = timeConstants->getDelay(KLMTimeConstants::c_BKLM);
562 delayRPCPhi = timeConstants->getDelay(KLMTimeConstants::c_RPCPhi);
563 delayRPCZ = timeConstants->getDelay(KLMTimeConstants::c_RPCZ);
564 constantsTree->Fill();
565 }
566 constantsTree->Write();
567 delete constantsTree;
568 delete timeConstantsResults;
569 /* Reset the database. Needed to avoid mess if we call this method multiple times with different GTs. */
570 resetDatabase();
571}
Belle2::BKLMElementNumbers::getMaximalLayerNumber
static constexpr int getMaximalLayerNumber()
Get maximal layer number (1-based).
Definition: BKLMElementNumbers.h:247
Belle2::BKLMElementNumbers::getMaximalPlaneNumber
static constexpr int getMaximalPlaneNumber()
Get maximal plane number (0-based).
Definition: BKLMElementNumbers.h:255
Belle2::Conditions::Configuration::getInstance
static Configuration & getInstance()
Get a reference to the instance which will be used when the Database is initialized.
Belle2::DBAccessorBase::isValid
bool isValid() const
Check whether a valid object was obtained from the database.
Definition: DBAccessorBase.h:72
Belle2::DBObjPtr
Class for accessing objects in the database.
Definition: DBObjPtr.h:21
Belle2::DBStore
Singleton class to cache database objects.
Definition: DBStore.h:31
Belle2::DataStore::Instance
static DataStore & Instance()
Instance of singleton Store.
Definition: DataStore.cc:54
Belle2::DataStore::setInitializeActive
void setInitializeActive(bool active)
Setter for m_initializeActive.
Definition: DataStore.cc:94
Belle2::DataStore::reset
void reset(EDurability durability)
Frees memory occupied by data store items and removes all objects from the map.
Definition: DataStore.cc:86
Belle2::EKLMElementNumbers
EKLM element numbers.
Definition: EKLMElementNumbers.h:24
Belle2::EKLMElementNumbers::getMaximalDetectorLayerNumber
int getMaximalDetectorLayerNumber(int section) const
Get maximal detector layer number.
Definition: EKLMElementNumbers.cc:277
Belle2::EKLMElementNumbers::Instance
static const EKLMElementNumbers & Instance()
Instantiation.
Definition: EKLMElementNumbers.cc:18
Belle2::EKLMElementNumbers::getMaximalPlaneNumber
static constexpr int getMaximalPlaneNumber()
Get maximal plane number.
Definition: EKLMElementNumbers.h:303
Belle2::KLMAlignmentData
KLM Alignment data.
Definition: KLMAlignmentData.h:23
Belle2::KLMAlignmentData::getDeltaU
float getDeltaU() const
Get shift in U.
Definition: KLMAlignmentData.h:77
Belle2::KLMAlignmentData::getDeltaV
float getDeltaV() const
Get shift in V.
Definition: KLMAlignmentData.h:94
Belle2::KLMAlignmentData::c_DeltaAlpha
@ c_DeltaAlpha
Rotation in alpha.
Definition: KLMAlignmentData.h:42
Belle2::KLMAlignmentData::c_DeltaBeta
@ c_DeltaBeta
Rotation in beta.
Definition: KLMAlignmentData.h:45
Belle2::KLMAlignmentData::c_DeltaU
@ c_DeltaU
Shift in U (EKLM: local X).
Definition: KLMAlignmentData.h:33
Belle2::KLMAlignmentData::c_DeltaGamma
@ c_DeltaGamma
Rotation in gamma (EKLM: rotation in local plane).
Definition: KLMAlignmentData.h:48
Belle2::KLMAlignmentData::c_DeltaV
@ c_DeltaV
Shift in V (EKLM: local Y).
Definition: KLMAlignmentData.h:36
Belle2::KLMAlignmentData::getDeltaW
float getDeltaW() const
Get shift in W.
Definition: KLMAlignmentData.h:111
Belle2::KLMAlignmentData::getDeltaGamma
float getDeltaGamma() const
Get rotation in alpha.
Definition: KLMAlignmentData.h:162
Belle2::KLMAlignmentData::getDeltaAlpha
float getDeltaAlpha() const
Get rotation in alpha.
Definition: KLMAlignmentData.h:128
Belle2::KLMAlignmentData::getDeltaBeta
float getDeltaBeta() const
Get rotation in alpha.
Definition: KLMAlignmentData.h:145
Belle2::KLMCalibrationChecker::checkTimeCableDelay
void checkTimeCableDelay()
Check time cable delay.
Definition: KLMCalibrationChecker.cc:473
Belle2::KLMCalibrationChecker::checkTimeConstants
void checkTimeConstants()
Check time constants.
Definition: KLMCalibrationChecker.cc:520
Belle2::KLMCalibrationChecker::checkStripEfficiency
void checkStripEfficiency()
Check strip efficiency.
Definition: KLMCalibrationChecker.cc:353
Belle2::KLMCalibrationChecker::resetDatabase
void resetDatabase()
Reset the database.
Definition: KLMCalibrationChecker.cc:80
Belle2::KLMCalibrationChecker::initializeDatabase
void initializeDatabase()
Initialize the database.
Definition: KLMCalibrationChecker.cc:59
Belle2::KLMCalibrationChecker::setExperimentRun
void setExperimentRun(int experiment, int run)
Set experiment and run numbers.
Definition: KLMCalibrationChecker.cc:49
Belle2::KLMCalibrationChecker::checkAlignment
void checkAlignment()
Check alignment.
Definition: KLMCalibrationChecker.cc:88
Belle2::KLMCalibrationChecker::m_ElementNumbers
const KLMElementNumbers * m_ElementNumbers
Element numbers.
Definition: KLMCalibrationChecker.h:178
Belle2::KLMCalibrationChecker::m_GlobalTagName
std::string m_GlobalTagName
Global Tag name.
Definition: KLMCalibrationChecker.h:163
Belle2::KLMCalibrationChecker::m_AlignmentResultsFile
std::string m_AlignmentResultsFile
Output file for alignment results.
Definition: KLMCalibrationChecker.h:166
Belle2::KLMCalibrationChecker::m_testingPayloadName
std::string m_testingPayloadName
Testing payload location.
Definition: KLMCalibrationChecker.h:160
Belle2::KLMCalibrationChecker::m_TimeCableDelayResultsFile
std::string m_TimeCableDelayResultsFile
Output file for time cable delay results.
Definition: KLMCalibrationChecker.h:172
Belle2::KLMCalibrationChecker::m_StripEfficiencyResultsFile
std::string m_StripEfficiencyResultsFile
Output file for alignment results.
Definition: KLMCalibrationChecker.h:169
Belle2::KLMCalibrationChecker::m_TimeConstantsResultsFile
std::string m_TimeConstantsResultsFile
Output file for time constants results.
Definition: KLMCalibrationChecker.h:175
Belle2::KLMCalibrationChecker::createStripEfficiencyHistograms
void createStripEfficiencyHistograms()
Create strip efficiency histograms.
Definition: KLMCalibrationChecker.cc:398
Belle2::KLMCalibrationChecker::printPayloadInformation
void printPayloadInformation(DBObjPtr< T > &dbObject)
Print payload information.
Definition: KLMCalibrationChecker.h:144
Belle2::KLMCalibrationChecker::m_EventMetaData
StoreObjPtr< EventMetaData > m_EventMetaData
Event metadata.
Definition: KLMCalibrationChecker.h:181
Belle2::KLMChannelIndex
KLM channel index.
Definition: KLMChannelIndex.h:23
Belle2::KLMChannelIndex::endEKLM
KLMChannelIndex & endEKLM()
Last channel for EKLM.
Definition: KLMChannelIndex.cc:209
Belle2::KLMChannelIndex::getLayer
int getLayer() const
Get layer.
Definition: KLMChannelIndex.h:130
Belle2::KLMChannelIndex::getSection
int getSection() const
Get section.
Definition: KLMChannelIndex.h:114
Belle2::KLMChannelIndex::getPlane
int getPlane() const
Get plane.
Definition: KLMChannelIndex.h:138
Belle2::KLMChannelIndex::getStrip
int getStrip() const
Get strip.
Definition: KLMChannelIndex.h:146
Belle2::KLMChannelIndex::getEKLMSegmentNumber
int getEKLMSegmentNumber() const
Get EKLM segment number.
Definition: KLMChannelIndex.cc:181
Belle2::KLMChannelIndex::getSector
int getSector() const
Get sector.
Definition: KLMChannelIndex.h:122
Belle2::KLMChannelIndex::useEKLMSegments
void useEKLMSegments(bool useSegments=true)
Iterate over EKLM segments instead of strips.
Definition: KLMChannelIndex.cc:115
Belle2::KLMChannelIndex::beginEKLM
KLMChannelIndex beginEKLM()
First channel for EKLM.
Definition: KLMChannelIndex.cc:203
Belle2::KLMElementNumbers
KLM element numbers.
Definition: KLMElementNumbers.h:28
Belle2::KLMElementNumbers::channelNumber
KLMChannelNumber channelNumber(int subdetector, int section, int sector, int layer, int plane, int strip) const
Get channel number.
Definition: KLMElementNumbers.cc:35
Belle2::KLMElementNumbers::moduleNumber
KLMModuleNumber moduleNumber(int subdetector, int section, int sector, int layer) const
Get module number.
Definition: KLMElementNumbers.cc:156
Belle2::KLMTimeConstants::c_BKLM
@ c_BKLM
BKLM scintillator.
Definition: KLMTimeConstants.h:36
Belle2::KLMTimeConstants::c_EKLM
@ c_EKLM
EKLM scintillator.
Definition: KLMTimeConstants.h:33
LogVar
Class to store variables with their name which were sent to the logging service.
Definition: LogVariableStream.h:24
Belle2::DBStore::reset
void reset(bool keepEntries=false)
Invalidate all payloads.
Definition: DBStore.cc:177
Belle2::Database::Instance
static Database & Instance()
Instance of a singleton Database.
Definition: Database.cc:42
Belle2::DBStore::Instance
static DBStore & Instance()
Instance of a singleton DBStore.
Definition: DBStore.cc:28
Belle2::DBStore::updateEvent
void updateEvent()
Updates all intra-run dependent objects.
Definition: DBStore.cc:142
Belle2::DBStore::update
void update()
Updates all objects that are outside their interval of validity.
Definition: DBStore.cc:79
Belle2::Database::reset
static void reset(bool keepConfig=false)
Reset the database instance.
Definition: Database.cc:50
Belle2::KLMChannelNumber
uint16_t KLMChannelNumber
Channel number.
Definition: KLMElementNumberDefinitions.h:36
Belle2::KLMModuleNumber
uint16_t KLMModuleNumber
Module number.
Definition: KLMElementNumberDefinitions.h:30
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17