Belle II Software  release-05-01-25
KLMDQMModule.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2018 Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Kirill Chilikin, Vipin Gaur, Leo Piilonen *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 /* Own header. */
12 #include <klm/modules/KLMDQM/KLMDQMModule.h>
13 
14 /* KLM headers. */
15 #include <klm/dataobjects/KLMChannelIndex.h>
16 #include <klm/dataobjects/KLMDigitRaw.h>
17 
18 /* ROOT headers. */
19 #include <TDirectory.h>
20 
21 using namespace Belle2;
22 
23 REG_MODULE(KLMDQM)
24 
26  HistoModule(),
27  m_DAQInclusion{nullptr},
28  m_TimeRPC{nullptr},
29  m_TimeScintillatorBKLM{nullptr},
30  m_TimeScintillatorEKLM{nullptr},
31  m_PlaneBKLMPhi{nullptr},
32  m_PlaneBKLMZ{nullptr},
33  m_PlaneEKLM{nullptr},
34  m_MaskedChannelsPerSector{nullptr},
35  m_DigitsKLM{nullptr},
36  m_DigitsRPC{nullptr},
37  m_DigitsScintillatorBKLM{nullptr},
38  m_DigitsScintillatorEKLM{nullptr},
39  m_DigitsMultiStripBKLM{nullptr},
40  m_DigitsMultiStripEKLM{nullptr},
41  m_TriggerBitsBKLM{nullptr},
42  m_TriggerBitsEKLM{nullptr},
43  m_KlmDigitsAfterLERInj{nullptr},
44  m_TriggersLERInj{nullptr},
45  m_KlmDigitsAfterHERInj{nullptr},
46  m_TriggersHERInj{nullptr},
47  m_ChannelArrayIndex{&(KLMChannelArrayIndex::Instance())},
48  m_SectorArrayIndex{&(KLMSectorArrayIndex::Instance())},
49  m_ElementNumbers{&(KLMElementNumbers::Instance())},
50  m_eklmElementNumbers{&(EKLMElementNumbers::Instance())}
51 {
52  setDescription("KLM data quality monitor.");
53  setPropertyFlags(c_ParallelProcessingCertified);
54  addParam("histogramDirectoryName", m_HistogramDirectoryName,
55  "Directory for KLM DQM histograms in ROOT file.",
56  std::string("KLM"));
57 }
58 
60 {
62  for (KLMChannelIndex& klmSector : klmSectors) {
63  uint16_t sector = klmSector.getKLMSectorNumber();
64  uint16_t sectorIndex = m_SectorArrayIndex->getIndex(sector);
65  if (m_ChannelHits[sectorIndex] != nullptr)
66  delete[] m_ChannelHits[sectorIndex];
67  }
68 }
69 
71 {
72  TDirectory* oldDirectory, *newDirectory;
73  oldDirectory = gDirectory;
74  newDirectory = oldDirectory->mkdir(m_HistogramDirectoryName.c_str());
75  newDirectory->cd();
76  /* DAQ inclusion. */
77  m_DAQInclusion = new TH1F("daq_inclusion", "Is KLM included in DAQ?", 2, 0.0, 2.0);
78  m_DAQInclusion->GetXaxis()->SetBinLabel(1, "No");
79  m_DAQInclusion->GetXaxis()->SetBinLabel(2, "Yes");
80  m_DAQInclusion->SetOption("LIVE");
81  /* Time histograms. */
82  m_TimeRPC = new TH1F("time_rpc", "RPC hit time", 128, -1023.5, 0.5);
83  m_TimeRPC->GetXaxis()->SetTitle("Time, ns");
84  m_TimeRPC->SetOption("LIVE");
86  new TH1F("time_scintillator_bklm", "Scintillator hit time (BKLM)",
87  100, -5000, -4000);
88  m_TimeScintillatorBKLM->GetXaxis()->SetTitle("Time, ns");
89  m_TimeScintillatorBKLM->SetOption("LIVE");
91  new TH1F("time_scintillator_eklm", "Scintillator hit time (EKLM)",
92  100, -5000, -4000);
93  m_TimeScintillatorEKLM->GetXaxis()->SetTitle("Time, ns");
94  m_TimeScintillatorEKLM->SetOption("LIVE");
95  /* Number of hits per plane. */
96  m_PlaneBKLMPhi = new TH1F("plane_bklm_phi",
97  "BKLM plane occupancy (#phi readout)",
98  240, 0.5, 240.5);
99  m_PlaneBKLMPhi->GetXaxis()->SetTitle("Layer number");
100  m_PlaneBKLMPhi->SetOption("LIVE");
101  m_PlaneBKLMZ = new TH1F("plane_bklm_z",
102  "BKLM plane occupancy (z readout)",
103  240, 0.5, 240.5);
104  m_PlaneBKLMZ->GetXaxis()->SetTitle("Layer number");
105  m_PlaneBKLMZ->SetOption("LIVE");
106  m_PlaneEKLM = new TH1F("plane_eklm", "EKLM plane occupancy (both readouts)", 208, 0.5, 208.5);
107  m_PlaneEKLM->GetXaxis()->SetTitle("Plane number");
108  m_PlaneEKLM->SetOption("LIVE");
109  /* Number of hits per channel. */
110  int nChannelHistograms =
115  uint16_t* firstChannelNumbers = new uint16_t[nChannelHistograms + 1];
116  int i = 0;
118  for (KLMChannelIndex& klmSector : klmSectors) {
119  KLMChannelIndex klmChannel(klmSector);
121  uint16_t channel = klmChannel.getKLMChannelNumber();
122  firstChannelNumbers[i] = m_ChannelArrayIndex->getIndex(channel);
123  if (klmSector.getSubdetector() == KLMElementNumbers::c_BKLM) {
125  klmChannel.getSection(), klmChannel.getSector(), 8, 0, 1);
126  firstChannelNumbers[i + 1] = m_ChannelArrayIndex->getIndex(channel);
127  i += 2;
128  } else {
129  int layerIncrease = (klmSector.getSection() == 1) ? 4 : 5;
131  klmChannel.getSection(), klmChannel.getSector(),
132  1 + layerIncrease, 1, 1);
133  firstChannelNumbers[i + 1] = m_ChannelArrayIndex->getIndex(channel);
135  klmChannel.getSection(), klmChannel.getSector(),
136  1 + layerIncrease * 2, 1, 1);
137  firstChannelNumbers[i + 2] = m_ChannelArrayIndex->getIndex(channel);
138  i += 3;
139  }
140  }
141  firstChannelNumbers[nChannelHistograms] = m_ChannelArrayIndex->getNElements();
142  i = 0;
143  for (KLMChannelIndex& klmSector : klmSectors) {
144  int nHistograms;
145  if (klmSector.getSubdetector() == KLMElementNumbers::c_BKLM)
146  nHistograms = m_ChannelHitHistogramsBKLM;
147  else
148  nHistograms = m_ChannelHitHistogramsEKLM;
149  uint16_t sector = klmSector.getKLMSectorNumber();
150  uint16_t sectorIndex = m_SectorArrayIndex->getIndex(sector);
151  m_ChannelHits[sectorIndex] = new TH1F*[nHistograms];
152  for (int j = 0; j < nHistograms; j++) {
153  std::string name =
154  "strip_hits_subdetector_" + std::to_string(klmSector.getSubdetector()) +
155  "_section_" + std::to_string(klmSector.getSection()) +
156  "_sector_" + std::to_string(klmSector.getSector()) +
157  "_" + std::to_string(j);
158  std::string title = "Sector " + std::to_string(klmSector.getSector()) + " -- " +
159  m_ElementNumbers->getSectorDAQName(klmSector.getSubdetector(), klmSector.getSection(), klmSector.getSector());
160  m_ChannelHits[sectorIndex][j] = new TH1F(
161  name.c_str(), title.c_str(),
162  firstChannelNumbers[i + 1] - firstChannelNumbers[i],
163  firstChannelNumbers[i] - 0.5, firstChannelNumbers[i + 1] - 0.5);
164  m_ChannelHits[sectorIndex][j]->SetOption("LIVE");
165  i++;
166  }
167  }
168  delete[] firstChannelNumbers;
169  /* Masked channels per sector:
170  * it is defined here, but filled by the analysis module. */
171  uint16_t totalSectors = m_SectorArrayIndex->getNElements();
172  m_MaskedChannelsPerSector = new TH1F("masked_channels", "Number of masked channels per sector",
173  totalSectors, -0.5, totalSectors - 0.5);
174  for (KLMChannelIndex& klmSector : klmSectors) {
175  std::string label = m_ElementNumbers->getSectorDAQName(klmSector.getSubdetector(), klmSector.getSection(), klmSector.getSector());
176  uint16_t sector = klmSector.getKLMSectorNumber();
177  uint16_t sectorIndex = m_SectorArrayIndex->getIndex(sector);
178  m_MaskedChannelsPerSector->GetXaxis()->SetBinLabel(sectorIndex + 1, label.c_str());
179  }
180  m_MaskedChannelsPerSector->SetOption("LIVE");
181  /* Number of digits. */
182  m_DigitsKLM = new TH1F("digits_klm", "Number of KLM digits",
183  250.0, 0.0, 250.0);
184  m_DigitsKLM->GetXaxis()->SetTitle("Number of digits");
185  m_DigitsKLM->SetOption("LIVE");
186  m_DigitsRPC = new TH1F("digits_rpc", "Number of RPC digits",
187  250.0, 0.0, 250.0);
188  m_DigitsRPC->GetXaxis()->SetTitle("Number of digits");
189  m_DigitsRPC->SetOption("LIVE");
190  m_DigitsScintillatorBKLM = new TH1F("digits_scintillator_bklm", "Number of scintillator digits (BKLM)",
191  250.0, 0.0, 250.0);
192  m_DigitsScintillatorBKLM->GetXaxis()->SetTitle("Number of digits");
193  m_DigitsScintillatorBKLM->SetOption("LIVE");
194  m_DigitsScintillatorEKLM = new TH1F("digits_scintillator_eklm", "Number of scintillator digits (EKLM)",
195  250.0, 0.0, 250.0);
196  m_DigitsScintillatorEKLM->GetXaxis()->SetTitle("Number of digits");
197  m_DigitsScintillatorEKLM->SetOption("LIVE");
198  m_DigitsMultiStripBKLM = new TH1F("digits_multi_bklm", "Number of multi-strip digits (BKLM)",
199  50.0, 0.0, 50.0);
200  m_DigitsMultiStripBKLM->GetXaxis()->SetTitle("Number of multi-strip digits");
201  m_DigitsMultiStripBKLM->SetOption("LIVE");
202  m_DigitsMultiStripEKLM = new TH1F("digits_multi_eklm", "Number of multi-strip digits (EKLM)",
203  50.0, 0.0, 50.0);
204  m_DigitsMultiStripEKLM->GetXaxis()->SetTitle("Number of multi-strip digits");
205  m_DigitsMultiStripEKLM->SetOption("LIVE");
206  /* Trigger bits. */
207  m_TriggerBitsBKLM = new TH1F("trigger_bits_bklm", "Trigger bits of multi-strip digits (BKLM)",
208  (double)c_0x1, (double)c_0x8, (double)c_0x1 + 1.0);
209  m_TriggerBitsBKLM->GetXaxis()->SetBinLabel(c_0x8, "0x8");
210  m_TriggerBitsBKLM->GetXaxis()->SetBinLabel(c_0x4, "0x4");
211  m_TriggerBitsBKLM->GetXaxis()->SetBinLabel(c_0x2, "0x2");
212  m_TriggerBitsBKLM->GetXaxis()->SetBinLabel(c_0x1, "0x1");
213  m_TriggerBitsBKLM->SetOption("LIVE");
214  m_TriggerBitsEKLM = new TH1F("trigger_bits_eklm", "Trigger bits of multi-strip digits (EKLM)",
215  (double)c_0x1, (double)c_0x8, (double)c_0x1 + 1.0);
216  m_TriggerBitsEKLM->GetXaxis()->SetBinLabel(c_0x8, "0x8");
217  m_TriggerBitsEKLM->GetXaxis()->SetBinLabel(c_0x4, "0x4");
218  m_TriggerBitsEKLM->GetXaxis()->SetBinLabel(c_0x2, "0x2");
219  m_TriggerBitsEKLM->GetXaxis()->SetBinLabel(c_0x1, "0x1");
220  m_TriggerBitsEKLM->SetOption("LIVE");
221  /* Number of digits after injection */
222  /* For the histograms below, we use the same style as for other subdetectors. */
223  m_KlmDigitsAfterLERInj = new TH1F("KLMOccInjLER", "KLMOccInjLER / Time;Time in #mus;KLM Digits / Time (5 #mus bins)",
224  4000, 0, 20000);
225  m_KlmDigitsAfterLERInj->SetOption("LIVE");
226  m_TriggersLERInj = new TH1F("KLMOEccInjLER", "KLMEOccInjLER / Time;Time in #mus;Triggers / Time (5 #mus bins)",
227  4000, 0, 20000);
228  m_TriggersLERInj->SetOption("LIVE");
229  m_KlmDigitsAfterHERInj = new TH1F("KLMOccInjHER", "KLMOccInjHER / Time;Time in #mus;KLM Digits / Time (5 #mus bins)",
230  4000, 0, 20000);
231  m_KlmDigitsAfterHERInj->SetOption("LIVE");
232  m_TriggersHERInj = new TH1F("KLMEOccInjHER", "KLMEOccInjHER / Time;Time in #mus;Triggers / Time (5 #mus bins)",
233  4000, 0, 20000);
234  m_TriggersHERInj->SetOption("LIVE");
235  oldDirectory->cd();
236 }
237 
239 {
240  REG_HISTOGRAM;
241  m_RawFtsws.isOptional();
242  m_RawKlms.isOptional();
243  m_Digits.isOptional();
244  m_BklmHit1ds.isOptional();
245 }
246 
248 {
249  /* DAQ inclusion. */
250  m_DAQInclusion->Reset();
251  if (m_RawKlms.isValid())
252  m_DAQInclusion->Fill("Yes", 1);
253  else
254  m_DAQInclusion->Fill("No", 1);
255  /* Time. */
256  m_TimeRPC->Reset();
257  m_TimeScintillatorBKLM->Reset();
258  m_TimeScintillatorEKLM->Reset();
259  /* Plane hits. */
260  m_PlaneEKLM->Reset();
261  m_PlaneBKLMPhi->Reset();
262  m_PlaneBKLMZ->Reset();
263  /* Channel hits. */
265  for (KLMChannelIndex& klmSector : klmSectors) {
266  int nHistograms;
267  if (klmSector.getSubdetector() == KLMElementNumbers::c_BKLM)
268  nHistograms = m_ChannelHitHistogramsBKLM;
269  else
270  nHistograms = m_ChannelHitHistogramsEKLM;
271  uint16_t sector = klmSector.getKLMSectorNumber();
272  uint16_t sectorIndex = m_SectorArrayIndex->getIndex(sector);
273  for (int j = 0; j < nHistograms; j++)
274  m_ChannelHits[sectorIndex][j]->Reset();
275  }
276  /* Digits. */
277  m_DigitsKLM->Reset();
278  m_DigitsRPC->Reset();
279  m_DigitsScintillatorBKLM->Reset();
280  m_DigitsScintillatorEKLM->Reset();
281  m_DigitsMultiStripBKLM->Reset();
282  m_DigitsMultiStripEKLM->Reset();
283  /* Trigger bits. */
284  m_TriggerBitsBKLM->Reset();
285  m_TriggerBitsEKLM->Reset();
286  /* Injection information. */
287  m_KlmDigitsAfterLERInj->Reset();
288  m_TriggersLERInj->Reset();
289  m_KlmDigitsAfterHERInj->Reset();
290  m_TriggersHERInj->Reset();
291 }
292 
294 {
295  int nDigits = m_Digits.getEntries();
296  int nDigitsRPC = 0, nDigitsScintillatorBKLM = 0, nDigitsScintillatorEKLM = 0;
297  int nDigitsMultiStripBKLM = 0, nDigitsMultiStripEKLM = 0;
298  for (const KLMDigit& digit : m_Digits) {
299  /*
300  * Reject digits that are below the threshold (such digits may appear
301  * for simulated events).
302  */
303  if (!digit.isGood())
304  continue;
305  if (digit.getSubdetector() == KLMElementNumbers::c_EKLM) {
306  nDigitsScintillatorEKLM++;
307  int section = digit.getSection();
308  int sector = digit.getSector();
309  int layer = digit.getLayer();
310  int plane = digit.getPlane();
311  int strip = digit.getStrip();
312  if (not digit.isMultiStrip()) {
313  uint16_t klmSector = m_ElementNumbers->sectorNumberEKLM(section, sector);
314  uint16_t klmSectorIndex = m_SectorArrayIndex->getIndex(klmSector);
315  uint16_t channel = m_ElementNumbers->channelNumberEKLM(section, sector, layer, plane, strip);
316  uint16_t channelIndex = m_ChannelArrayIndex->getIndex(channel);
317  for (int j = 0; j < m_ChannelHitHistogramsEKLM; j++) {
318  double xMin = m_ChannelHits[klmSectorIndex][j]->GetXaxis()->GetXmin();
319  double xMax = m_ChannelHits[klmSectorIndex][j]->GetXaxis()->GetXmax();
320  if ((xMin > channelIndex) || (xMax < channelIndex))
321  continue;
322  m_ChannelHits[klmSectorIndex][j]->Fill(channelIndex);
323  }
324  } else
325  nDigitsMultiStripEKLM++;
326  int planeGlobal = m_eklmElementNumbers->planeNumber(section, layer, sector, plane);
327  m_PlaneEKLM->Fill(planeGlobal);
328  m_TimeScintillatorEKLM->Fill(digit.getTime());
329  if (digit.isMultiStrip()) {
330  KLMDigitRaw* digitRaw = digit.getRelated<KLMDigitRaw>();
331  if (digitRaw) {
332  uint16_t triggerBits = digitRaw->getTriggerBits();
333  if ((triggerBits & 0x1) != 0)
334  m_TriggerBitsEKLM->Fill(c_0x1);
335  if ((triggerBits & 0x2) != 0)
336  m_TriggerBitsEKLM->Fill(c_0x2);
337  if ((triggerBits & 0x4) != 0)
338  m_TriggerBitsEKLM->Fill(c_0x4);
339  if ((triggerBits & 0x8) != 0)
340  m_TriggerBitsEKLM->Fill(c_0x8);
341  }
342  }
343  } else if (digit.getSubdetector() == KLMElementNumbers::c_BKLM) {
344  int section = digit.getSection();
345  int sector = digit.getSector();
346  int layer = digit.getLayer();
347  int plane = digit.getPlane();
348  int strip = digit.getStrip();
349  if (not digit.isMultiStrip()) {
350  uint16_t klmSector = m_ElementNumbers->sectorNumberBKLM(section, sector);
351  uint16_t klmSectorIndex = m_SectorArrayIndex->getIndex(klmSector);
352  uint16_t channel = m_ElementNumbers->channelNumberBKLM(section, sector, layer, plane, strip);
353  uint16_t channelIndex = m_ChannelArrayIndex->getIndex(channel);
354  for (int j = 0; j < m_ChannelHitHistogramsBKLM; j++) {
355  double xMin = m_ChannelHits[klmSectorIndex][j]->GetXaxis()->GetXmin();
356  double xMax = m_ChannelHits[klmSectorIndex][j]->GetXaxis()->GetXmax();
357  if ((xMin > channelIndex) || (xMax < channelIndex))
358  continue;
359  m_ChannelHits[klmSectorIndex][j]->Fill(channelIndex);
360  }
361  } else
362  nDigitsMultiStripBKLM++;
363  if (digit.inRPC()) {
364  nDigitsRPC++;
365  m_TimeRPC->Fill(digit.getTime());
366  } else {
367  nDigitsScintillatorBKLM++;
368  m_TimeScintillatorBKLM->Fill(digit.getTime());
369  }
370  if (digit.isMultiStrip()) {
371  KLMDigitRaw* digitRaw = digit.getRelated<KLMDigitRaw>();
372  if (digitRaw) {
373  uint16_t triggerBits = digitRaw->getTriggerBits();
374  if ((triggerBits & 0x1) != 0)
375  m_TriggerBitsBKLM->Fill(c_0x1);
376  if ((triggerBits & 0x2) != 0)
377  m_TriggerBitsBKLM->Fill(c_0x2);
378  if ((triggerBits & 0x4) != 0)
379  m_TriggerBitsBKLM->Fill(c_0x4);
380  if ((triggerBits & 0x8) != 0)
381  m_TriggerBitsBKLM->Fill(c_0x8);
382  }
383  }
384  } else
385  B2FATAL("Not a BKLM or a EKLM digit, something went really wrong.");
386  }
387  for (const BKLMHit1d& hit1d : m_BklmHit1ds) {
388  int section = hit1d.getSection();
389  int sector = hit1d.getSector();
390  int layer = hit1d.getLayer();
391  int layerGlobal = BKLMElementNumbers::layerGlobalNumber(
392  section, sector, layer);
393  if (hit1d.isPhiReadout())
394  m_PlaneBKLMPhi->Fill(layerGlobal);
395  else
396  m_PlaneBKLMZ->Fill(layerGlobal);
397  }
398  /* Digits. */
399  m_DigitsKLM->Fill((double)nDigits);
400  m_DigitsRPC->Fill((double)nDigitsRPC);
401  m_DigitsScintillatorBKLM->Fill((double)nDigitsScintillatorBKLM);
402  m_DigitsScintillatorEKLM->Fill((double)nDigitsScintillatorEKLM);
403  if (nDigitsMultiStripBKLM > 0)
404  m_DigitsMultiStripBKLM->Fill((double)nDigitsMultiStripBKLM);
405  if (nDigitsMultiStripEKLM > 0)
406  m_DigitsMultiStripEKLM->Fill((double)nDigitsMultiStripEKLM);
407  /* Injection information. */
408  for (RawFTSW& rawFtsw : m_RawFtsws) {
409  unsigned int difference = rawFtsw.GetTimeSinceLastInjection(0);
410  if (difference != 0x7FFFFFFF) {
411  /* 127 MHz clock ticks to us, inexact rounding. */
412  float differenceInUs = difference / 127.;
413  if (rawFtsw.GetIsHER(0)) {
414  m_KlmDigitsAfterHERInj->Fill(differenceInUs, nDigits);
415  m_TriggersHERInj->Fill(differenceInUs);
416  } else {
417  m_KlmDigitsAfterLERInj->Fill(differenceInUs, nDigits);
418  m_TriggersLERInj->Fill(differenceInUs);
419  }
420  }
421  /*
422  * Usually, only one RawFTSW object is stored per event.
423  * If there are more, ignore the others.
424  */
425  break;
426  }
427 }
428 
430 {
431 }
432 
434 {
435 }
Belle2::KLMDQMModule::c_0x2
@ c_0x2
0x2.
Definition: KLMDQMModule.h:107
Belle2::KLMElementNumbers::sectorNumberBKLM
uint16_t sectorNumberBKLM(int section, int sector) const
Get sector number for BKLM.
Definition: KLMElementNumbers.cc:222
Belle2::EKLMElementNumbers::getMaximalSectorGlobalNumberKLMOrder
static constexpr int getMaximalSectorGlobalNumberKLMOrder()
Get maximal sector global number with KLM ordering (section, sector).
Definition: EKLMElementNumbers.h:353
Belle2::KLMDQMModule::m_Digits
StoreArray< KLMDigit > m_Digits
KLM digits.
Definition: KLMDQMModule.h:207
Belle2::KLMChannelIndex::getSector
int getSector() const
Get sector.
Definition: KLMChannelIndex.h:132
Belle2::KLMDQMModule::m_KlmDigitsAfterHERInj
TH1F * m_KlmDigitsAfterHERInj
Number of KLM Digits after LER injection.
Definition: KLMDQMModule.h:183
Belle2::BKLMHit1d
Store one reconstructed BKLM 1D hit as a ROOT object.
Definition: BKLMHit1d.h:39
Belle2::KLMDQMModule::m_TriggerBitsEKLM
TH1F * m_TriggerBitsEKLM
Trigger bits: EKLM scintillators.
Definition: KLMDQMModule.h:174
Belle2::KLMDQMModule::beginRun
void beginRun() override
Called when entering a new run.
Definition: KLMDQMModule.cc:247
Belle2::KLMDQMModule::m_ChannelHitHistogramsEKLM
const int m_ChannelHitHistogramsEKLM
Number of channel hit histograms per sector for EKLM.
Definition: KLMDQMModule.h:118
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::EKLMElementNumbers::planeNumber
int planeNumber(int section, int layer, int sector, int plane) const
Get plane number.
Definition: EKLMElementNumbers.cc:171
Belle2::KLMDQMModule::m_RawKlms
StoreArray< RawKLM > m_RawKlms
Raw KLM.
Definition: KLMDQMModule.h:204
Belle2::KLMChannelIndex::getSection
int getSection() const
Get section.
Definition: KLMChannelIndex.h:124
Belle2::KLMDigitRaw::getTriggerBits
uint16_t getTriggerBits()
Get trigger bits.
Definition: KLMDigitRaw.h:169
Belle2::KLMDQMModule::m_PlaneBKLMPhi
TH1F * m_PlaneBKLMPhi
Plane occupancy: BKLM, phi readout.
Definition: KLMDQMModule.h:136
Belle2::KLMDQMModule::m_DAQInclusion
TH1F * m_DAQInclusion
KLM DAQ inclusion.
Definition: KLMDQMModule.h:124
Belle2::KLMDQMModule::m_ChannelHitHistogramsBKLM
const int m_ChannelHitHistogramsBKLM
Number of channel hit histograms per sector for BKLM.
Definition: KLMDQMModule.h:115
Belle2::KLMDQMModule::m_PlaneBKLMZ
TH1F * m_PlaneBKLMZ
Plane occupancy: BKLM, z readout.
Definition: KLMDQMModule.h:139
Belle2::KLMDQMModule::m_TriggersHERInj
TH1F * m_TriggersHERInj
Histogram to be used for normalization of occupancy after HER injection.
Definition: KLMDQMModule.h:186
Belle2::KLMDQMModule::m_MaskedChannelsPerSector
TH1F * m_MaskedChannelsPerSector
Masked channels per sector.
Definition: KLMDQMModule.h:150
Belle2::KLMElementNumbers::c_EKLM
@ c_EKLM
EKLM.
Definition: KLMElementNumbers.h:50
Belle2::KLMDQMModule::endRun
void endRun() override
This method is called if the current run ends.
Definition: KLMDQMModule.cc:429
Belle2::KLMDQMModule::~KLMDQMModule
~KLMDQMModule()
Destructor.
Definition: KLMDQMModule.cc:59
Belle2::KLMSectorArrayIndex::Instance
static const KLMSectorArrayIndex & Instance()
Instantiation.
Definition: KLMSectorArrayIndex.cc:28
Belle2::RelationsInterface::getRelated
T * getRelated(const std::string &name="", const std::string &namedRelation="") const
Get the object to or from which this object has a relation.
Definition: RelationsObject.h:280
Belle2::KLMDQMModule::m_HistogramDirectoryName
std::string m_HistogramDirectoryName
Directory for KLM DQM histograms in ROOT file.
Definition: KLMDQMModule.h:121
Belle2::KLMElementNumbers::Instance
static const KLMElementNumbers & Instance()
Instantiation.
Definition: KLMElementNumbers.cc:31
Belle2::KLMElementNumbers::channelNumberBKLM
uint16_t channelNumberBKLM(int section, int sector, int layer, int plane, int strip) const
Get channel number for BKLM.
Definition: KLMElementNumbers.cc:50
Belle2::KLMDQMModule::m_TriggerBitsBKLM
TH1F * m_TriggerBitsBKLM
Trigger bits: BKLM scintillators.
Definition: KLMDQMModule.h:171
Belle2::KLMDQMModule::m_PlaneEKLM
TH1F * m_PlaneEKLM
Plane occupancy: EKLM.
Definition: KLMDQMModule.h:142
Belle2::KLMDQMModule::m_ChannelHits
TH1F ** m_ChannelHits[EKLMElementNumbers::getMaximalSectorGlobalNumberKLMOrder()+BKLMElementNumbers::getMaximalSectorGlobalNumber()]
Number of hits per channel.
Definition: KLMDQMModule.h:147
Belle2::KLMDQMModule::m_DigitsRPC
TH1F * m_DigitsRPC
Number of digits: BKLM RPCs.
Definition: KLMDQMModule.h:156
Belle2::KLMChannelIndex::getKLMChannelNumber
uint16_t getKLMChannelNumber() const
Get KLM channel number.
Definition: KLMChannelIndex.cc:145
Belle2::KLMDigit
KLM digit (class representing a digitized hit in RPCs or scintillators).
Definition: KLMDigit.h:40
Belle2::KLMDQMModule::c_0x8
@ c_0x8
0x8.
Definition: KLMDQMModule.h:101
Belle2::KLMChannelIndex::c_IndexLevelSector
@ c_IndexLevelSector
Sector.
Definition: KLMChannelIndex.h:49
Belle2::KLMDQMModule::c_0x1
@ c_0x1
0x1.
Definition: KLMDQMModule.h:110
Belle2::KLMDQMModule::m_ChannelArrayIndex
const KLMChannelArrayIndex * m_ChannelArrayIndex
KLM channel array index.
Definition: KLMDQMModule.h:189
Belle2::KLMDQMModule::event
void event() override
This method is called for each event.
Definition: KLMDQMModule.cc:293
Belle2::KLMDQMModule::initialize
void initialize() override
Initializer.
Definition: KLMDQMModule.cc:238
Belle2::KLMElementNumbers::sectorNumberEKLM
uint16_t sectorNumberEKLM(int section, int sector) const
Get sector number for EKLM.
Definition: KLMElementNumbers.cc:229
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::BKLMElementNumbers::getMaximalSectorGlobalNumber
static constexpr int getMaximalSectorGlobalNumber()
Get maximal sector global number.
Definition: BKLMElementNumbers.h:267
Belle2::KLMDQMModule::m_BklmHit1ds
StoreArray< BKLMHit1d > m_BklmHit1ds
BKLM 1d hits.
Definition: KLMDQMModule.h:210
Belle2::EKLMElementNumbers::Instance
static const EKLMElementNumbers & Instance()
Instantiation.
Definition: EKLMElementNumbers.cc:20
Belle2::KLMDQMModule::defineHisto
void defineHisto() override
Definition of the histograms.
Definition: KLMDQMModule.cc:70
Belle2::KLMDigitRaw
Class to store the raw words from the unpacker, digit-by-digit.
Definition: KLMDigitRaw.h:39
Belle2::KLMElementNumbers::c_BKLM
@ c_BKLM
BKLM.
Definition: KLMElementNumbers.h:47
Belle2::KLMDQMModule::m_TriggersLERInj
TH1F * m_TriggersLERInj
Histogram to be used for normalization of occupancy after LER injection.
Definition: KLMDQMModule.h:180
Belle2::KLMDQMModule::m_RawFtsws
StoreArray< RawFTSW > m_RawFtsws
Raw FTSW.
Definition: KLMDQMModule.h:201
Belle2::KLMDQMModule
KLM data quality monitor module.
Definition: KLMDQMModule.h:51
Belle2::BKLMElementNumbers::layerGlobalNumber
static int layerGlobalNumber(int section, int sector, int layer)
Get layer global number.
Definition: BKLMElementNumbers.cc:97
Belle2::KLMElementArrayIndex::getNElements
uint16_t getNElements() const
Get number of elements.
Definition: KLMElementArrayIndex.h:65
Belle2::KLMDQMModule::m_TimeScintillatorBKLM
TH1F * m_TimeScintillatorBKLM
Time: BKLM scintillators.
Definition: KLMDQMModule.h:130
Belle2::KLMDQMModule::m_DigitsScintillatorEKLM
TH1F * m_DigitsScintillatorEKLM
Number of digits: EKLM scintillators.
Definition: KLMDQMModule.h:162
Belle2::KLMDQMModule::m_DigitsMultiStripEKLM
TH1F * m_DigitsMultiStripEKLM
Number of multi-strip digits: EKLM scintillators.
Definition: KLMDQMModule.h:168
Belle2::KLMElementNumbers::channelNumberEKLM
uint16_t channelNumberEKLM(int section, int sector, int layer, int plane, int strip) const
Get channel number for EKLM.
Definition: KLMElementNumbers.cc:64
Belle2::KLMDQMModule::m_ElementNumbers
const KLMElementNumbers * m_ElementNumbers
KLM element numbers.
Definition: KLMDQMModule.h:195
Belle2::KLMChannelArrayIndex::Instance
static const KLMChannelArrayIndex & Instance()
Instantiation.
Definition: KLMChannelArrayIndex.cc:28
Belle2::KLMChannelIndex
KLM channel index.
Definition: KLMChannelIndex.h:33
Belle2::KLMDQMModule::terminate
void terminate() override
This method is called at the end of the event processing.
Definition: KLMDQMModule.cc:433
Belle2::KLMDQMModule::m_DigitsMultiStripBKLM
TH1F * m_DigitsMultiStripBKLM
Number of multi-strip digits: BKLM scintillators.
Definition: KLMDQMModule.h:165
Belle2::KLMDQMModule::m_eklmElementNumbers
const EKLMElementNumbers * m_eklmElementNumbers
Element numbers.
Definition: KLMDQMModule.h:198
Belle2::KLMDQMModule::m_DigitsKLM
TH1F * m_DigitsKLM
Number of digits: whole KLM.
Definition: KLMDQMModule.h:153
Belle2::KLMDQMModule::m_DigitsScintillatorBKLM
TH1F * m_DigitsScintillatorBKLM
Number of digits: BKLM scintillators.
Definition: KLMDQMModule.h:159
Belle2::KLMDQMModule::m_SectorArrayIndex
const KLMSectorArrayIndex * m_SectorArrayIndex
KLM sector array index.
Definition: KLMDQMModule.h:192
Belle2::KLMDQMModule::m_TimeScintillatorEKLM
TH1F * m_TimeScintillatorEKLM
Time: EKLM scintillators.
Definition: KLMDQMModule.h:133
Belle2::KLMDQMModule::m_TimeRPC
TH1F * m_TimeRPC
Time: BKLM RPCs.
Definition: KLMDQMModule.h:127
Belle2::KLMDQMModule::m_KlmDigitsAfterLERInj
TH1F * m_KlmDigitsAfterLERInj
Number of KLM Digits after LER injection.
Definition: KLMDQMModule.h:177
Belle2::KLMDQMModule::c_0x4
@ c_0x4
0x4.
Definition: KLMDQMModule.h:104
Belle2::KLMChannelIndex::setIndexLevel
void setIndexLevel(enum IndexLevel indexLevel)
Set index level.
Definition: KLMChannelIndex.cc:67
Belle2::KLMElementNumbers::getSectorDAQName
std::string getSectorDAQName(int subdetector, int section, int sector) const
Get DAQ name for a given sector.
Definition: KLMElementNumbers.cc:252
Belle2::HistoModule
HistoModule.h is supposed to be used instead of Module.h for the modules with histogram definitions t...
Definition: HistoModule.h:29
Belle2::KLMElementArrayIndex::getIndex
uint16_t getIndex(uint16_t number) const
Get element index.
Definition: KLMElementArrayIndex.cc:54
Belle2::KLMChannelIndex::c_IndexLevelStrip
@ c_IndexLevelStrip
Strip.
Definition: KLMChannelIndex.h:58
Belle2::RawFTSW
The Raw FTSW class.
Definition: RawFTSW.h:30