Belle II Software  release-06-01-15
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 include. */
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 
21 /* Belle II headers. */
22 #include <framework/database/Database.h>
23 #include <framework/database/DBStore.h>
24 #include <framework/database/Configuration.h>
25 #include <framework/datastore/DataStore.h>
26 
27 /* ROOT include. */
28 #include <TCanvas.h>
29 #include <TFile.h>
30 #include <TH1F.h>
31 #include <TString.h>
32 #include <TTree.h>
33 
34 using namespace Belle2;
35 
36 KLMCalibrationChecker::KLMCalibrationChecker() :
37  m_experiment(0),
38  m_run(0),
39  m_ElementNumbers(&(KLMElementNumbers::Instance()))
40 {
41 }
42 
43 KLMCalibrationChecker::~KLMCalibrationChecker()
44 {
45 }
46 
47 void KLMCalibrationChecker::setExperimentRun(int experiment, int run)
48 {
49  m_experiment = experiment;
50  m_run = run;
51  if (m_EventMetaData.isValid()) {
52  m_EventMetaData->setExperiment(experiment);
53  m_EventMetaData->setRun(run);
54  }
55 }
56 
57 void KLMCalibrationChecker::initializeDatabase()
58 {
59  /* Mimic a module initialization. */
60  DataStore::Instance().setInitializeActive(true);
61  m_EventMetaData.registerInDataStore();
62  DataStore::Instance().setInitializeActive(false);
63  if (!m_EventMetaData.isValid())
64  m_EventMetaData.construct(1, m_run, m_experiment);
65  /* Database instance and configuration. */
66  DBStore& dbStore = DBStore::Instance();
67  dbStore.update();
68  dbStore.updateEvent();
69  auto& dbConfiguration = Conditions::Configuration::getInstance();
70  if ((m_testingPayloadName != "") and (m_GlobalTagName == ""))
71  dbConfiguration.prependTestingPayloadLocation(m_testingPayloadName);
72  else if ((m_testingPayloadName == "") and (m_GlobalTagName != ""))
73  dbConfiguration.prependGlobalTag(m_GlobalTagName);
74  else
75  B2FATAL("Setting both testing payload and Global Tag or setting no one of them.");
76 }
77 
78 void KLMCalibrationChecker::resetDatabase()
79 {
80  /* Reset both DataStore and Database. */
81  DataStore::Instance().reset();
82  Database::Instance().reset(false);
83  DBStore::Instance().reset(false);
84 }
85 
86 void KLMCalibrationChecker::checkAlignment()
87 {
88  /* Initialize the database. */
89  initializeDatabase();
90  /* Now we can read the payload. */
91  DBObjPtr<BKLMAlignment> bklmAlignment;
92  DBObjPtr<EKLMAlignment> eklmAlignment;
93  DBObjPtr<EKLMSegmentAlignment> eklmSegmentAlignment;
94  DBObjPtr<BKLMAlignment> bklmAlignmentErrors("BKLMAlignment_ERRORS");
95  DBObjPtr<EKLMAlignment> eklmAlignmentErrors("EKLMAlignment_ERRORS");
96  DBObjPtr<EKLMSegmentAlignment> eklmSegmentAlignmentErrors("EKLMSegmentAlignment_ERRORS");
97  DBObjPtr<BKLMAlignment> bklmAlignmentCorrections("BKLMAlignment_CORRECTIONS");
98  DBObjPtr<EKLMAlignment> eklmAlignmentCorrections("EKLMAlignment_CORRECTIONS");
99  DBObjPtr<EKLMSegmentAlignment> eklmSegmentAlignmentCorrections("EKLMSegmentAlignment_CORRECTIONS");
100  if (!bklmAlignment.isValid() ||
101  !eklmAlignment.isValid() ||
102  !eklmSegmentAlignment.isValid() ||
103  !bklmAlignmentErrors.isValid() ||
104  !eklmAlignmentErrors.isValid() ||
105  !eklmSegmentAlignmentErrors.isValid() ||
106  !bklmAlignmentCorrections.isValid() ||
107  !eklmAlignmentCorrections.isValid() ||
108  !eklmSegmentAlignmentCorrections.isValid())
109  B2FATAL("Alignment data are not valid.");
110  if (m_GlobalTagName != "") {
111  printPayloadInformation(bklmAlignment);
112  printPayloadInformation(eklmAlignment);
113  printPayloadInformation(eklmSegmentAlignment);
114  printPayloadInformation(bklmAlignmentErrors);
115  printPayloadInformation(eklmAlignmentErrors);
116  printPayloadInformation(eklmSegmentAlignmentErrors);
117  printPayloadInformation(bklmAlignmentCorrections);
118  printPayloadInformation(eklmAlignmentCorrections);
119  printPayloadInformation(eklmSegmentAlignmentCorrections);
120  }
121  /* Create trees with alignment results. */
122  int section, sector, layer, plane, segment, param;
123  float value, correction, error;
124  TFile* alignmentResults = new TFile(m_AlignmentResultsFile.c_str(),
125  "recreate");
126  TTree* bklmModuleTree = new TTree("bklm_module",
127  "BKLM module alignment data.");
128  bklmModuleTree->Branch("experiment", &m_experiment, "experiment/I");
129  bklmModuleTree->Branch("run", &m_run, "run/I");
130  bklmModuleTree->Branch("section", &section, "section/I");
131  bklmModuleTree->Branch("sector", &sector, "sector/I");
132  bklmModuleTree->Branch("layer", &layer, "layer/I");
133  bklmModuleTree->Branch("param", &param, "param/I");
134  bklmModuleTree->Branch("value", &value, "value/F");
135  bklmModuleTree->Branch("correction", &correction, "correction/F");
136  bklmModuleTree->Branch("error", &error, "error/F");
137  TTree* eklmModuleTree = new TTree("eklm_module",
138  "EKLM module alignment data.");
139  eklmModuleTree->Branch("experiment", &m_experiment, "experiment/I");
140  eklmModuleTree->Branch("run", &m_run, "run/I");
141  eklmModuleTree->Branch("section", &section, "section/I");
142  eklmModuleTree->Branch("sector", &sector, "sector/I");
143  eklmModuleTree->Branch("layer", &layer, "layer/I");
144  eklmModuleTree->Branch("param", &param, "param/I");
145  eklmModuleTree->Branch("value", &value, "value/F");
146  eklmModuleTree->Branch("correction", &correction, "correction/F");
147  eklmModuleTree->Branch("error", &error, "error/F");
148  TTree* eklmSegmentTree = new TTree("eklm_segment",
149  "EKLM segment alignment data.");
150  eklmSegmentTree->Branch("experiment", &m_experiment, "experiment/I");
151  eklmSegmentTree->Branch("run", &m_run, "run/I");
152  eklmSegmentTree->Branch("section", &section, "section/I");
153  eklmSegmentTree->Branch("sector", &sector, "sector/I");
154  eklmSegmentTree->Branch("layer", &layer, "layer/I");
155  eklmSegmentTree->Branch("plane", &plane, "plane/I");
156  eklmSegmentTree->Branch("segment", &segment, "segment/I");
157  eklmSegmentTree->Branch("param", &param, "param/I");
158  eklmSegmentTree->Branch("value", &value, "value/F");
159  eklmSegmentTree->Branch("correction", &correction, "correction/F");
160  eklmSegmentTree->Branch("error", &error, "error/F");
161  const KLMAlignmentData* alignment, *alignmentError, *alignmentCorrection;
162  KLMAlignmentData zeroAlignment(0, 0, 0, 0, 0, 0);
163  KLMChannelIndex klmModules(KLMChannelIndex::c_IndexLevelLayer);
164  for (KLMChannelIndex& klmModule : klmModules) {
165  KLMModuleNumber module = klmModule.getKLMModuleNumber();
166  if (klmModule.getSubdetector() == KLMElementNumbers::c_BKLM) {
167  alignment = bklmAlignment->getModuleAlignment(module);
168  alignmentError = bklmAlignmentErrors->getModuleAlignment(module);
169  alignmentCorrection =
170  bklmAlignmentCorrections->getModuleAlignment(module);
171  } else {
172  alignment = eklmAlignment->getModuleAlignment(module);
173  alignmentError = eklmAlignmentErrors->getModuleAlignment(module);
174  alignmentCorrection =
175  eklmAlignmentCorrections->getModuleAlignment(module);
176  }
177  if (alignment == nullptr)
178  B2FATAL("Incomplete KLM alignment data.");
179  if ((alignmentError == nullptr) && (alignmentCorrection == nullptr)) {
180  B2WARNING("Alignment is not determined for KLM module."
181  << LogVar("Module", module));
182  alignmentError = &zeroAlignment;
183  alignmentCorrection = &zeroAlignment;
184  } else if ((alignmentError == nullptr) ||
185  (alignmentCorrection == nullptr)) {
186  B2FATAL("Inconsistent undtermined parameters.");
187  }
188  section = klmModule.getSection();
189  sector = klmModule.getSector();
190  layer = klmModule.getLayer();
191  param = KLMAlignmentData::c_DeltaU;
192  value = alignment->getDeltaU();
193  /* cppcheck-suppress nullPointerRedundantCheck */
194  error = alignmentError->getDeltaU();
195  /* cppcheck-suppress nullPointerRedundantCheck */
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 
353 void 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 
398 void 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 }
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:73
Belle2::DBObjPtr
Class for accessing objects in the database.
Definition: DBObjPtr.h:21
Belle2::DBStore
Singleton class to cache database objects.
Definition: DBStore.h:32
Belle2::DataStore::Instance
static DataStore & Instance()
Instance of singleton Store.
Definition: DataStore.cc:52
Belle2::DataStore::setInitializeActive
void setInitializeActive(bool active)
Setter for m_initializeActive.
Definition: DataStore.cc:92
Belle2::DataStore::reset
void reset(EDurability durability)
Frees memory occupied by data store items and removes all objects from the map.
Definition: DataStore.cc:84
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::checkStripEfficiency
void checkStripEfficiency()
Check strip efficiency.
Definition: KLMCalibrationChecker.cc:353
Belle2::KLMCalibrationChecker::resetDatabase
void resetDatabase()
Reset the database.
Definition: KLMCalibrationChecker.cc:78
Belle2::KLMCalibrationChecker::initializeDatabase
void initializeDatabase()
Initialize the database.
Definition: KLMCalibrationChecker.cc:57
Belle2::KLMCalibrationChecker::setExperimentRun
void setExperimentRun(int experiment, int run)
Set experiment and run numbers.
Definition: KLMCalibrationChecker.cc:47
Belle2::KLMCalibrationChecker::checkAlignment
void checkAlignment()
Check alignment.
Definition: KLMCalibrationChecker.cc:86
Belle2::KLMCalibrationChecker::m_ElementNumbers
const KLMElementNumbers * m_ElementNumbers
Element numbers.
Definition: KLMCalibrationChecker.h:142
Belle2::KLMCalibrationChecker::m_GlobalTagName
std::string m_GlobalTagName
Global Tag name.
Definition: KLMCalibrationChecker.h:133
Belle2::KLMCalibrationChecker::m_AlignmentResultsFile
std::string m_AlignmentResultsFile
Output file for alignment results.
Definition: KLMCalibrationChecker.h:136
Belle2::KLMCalibrationChecker::m_testingPayloadName
std::string m_testingPayloadName
Testing payload location.
Definition: KLMCalibrationChecker.h:130
Belle2::KLMCalibrationChecker::m_StripEfficiencyResultsFile
std::string m_StripEfficiencyResultsFile
Output file for alignment results.
Definition: KLMCalibrationChecker.h:139
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:114
Belle2::KLMCalibrationChecker::m_EventMetaData
StoreObjPtr< EventMetaData > m_EventMetaData
Event metadata.
Definition: KLMCalibrationChecker.h:145
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
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:175
Belle2::Database::Instance
static Database & Instance()
Instance of a singleton Database.
Definition: Database.cc:41
Belle2::DBStore::Instance
static DBStore & Instance()
Instance of a singleton DBStore.
Definition: DBStore.cc:26
Belle2::DBStore::updateEvent
void updateEvent()
Updates all intra-run dependent objects.
Definition: DBStore.cc:140
Belle2::DBStore::update
void update()
Updates all objects that are outside their interval of validity.
Definition: DBStore.cc:77
Belle2::Database::reset
static void reset(bool keepConfig=false)
Reset the database instance.
Definition: Database.cc:49
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