Belle II Software  release-05-02-19
PXDDQMExpressRecoModule.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2017 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Björn Spruck, Peter Kodys *
7  * *
8  * Prepared for Belle II geometry *
9  * *
10  * This software is provided "as is" without any warranty. *
11  **************************************************************************/
12 
13 #include "pxd/modules/pxdDQM/PXDDQMExpressRecoModule.h"
14 
15 #include <pxd/geometry/SensorInfo.h>
16 #include <vxd/geometry/GeoCache.h>
17 #include <vxd/geometry/SensorInfoBase.h>
18 #include <vxd/geometry/GeoTools.h>
19 #include <pxd/unpacking/PXDMappingLookup.h>
20 
21 #include <boost/format.hpp>
22 
23 #include "TDirectory.h"
24 
25 using namespace std;
26 using boost::format;
27 using namespace Belle2;
28 using namespace Belle2::PXD;
29 
30 //-----------------------------------------------------------------
31 // Register the Module
32 //-----------------------------------------------------------------
33 REG_MODULE(PXDDQMExpressReco)
34 
35 
36 //-----------------------------------------------------------------
37 // Implementation
38 //-----------------------------------------------------------------
39 
40 PXDDQMExpressRecoModule::PXDDQMExpressRecoModule() : HistoModule()
41 {
42  //Set module properties
43  setDescription("PXD DQM module for Express Reco "
44  "Recommended Number of events for monitor is 40 kEvents or more to fill all histograms "
45  );
46 
47  setPropertyFlags(c_ParallelProcessingCertified); // specify this flag if you need parallel processing
48  addParam("CutMinCharge", m_CutMinCharge,
49  "cut on pixel charge for accepting good pixel, default >= 12", 12);
50  addParam("CutMinSeedCharge", m_CutMinSeedCharge,
51  "cut on cluster seed for accepting good cluster, default >= 12", 12);
52  addParam("CutMaxClusterSize", m_CutMaxClusterSize,
53  "cut on cluster size accepting good cluster, default <= 4", 4);
54  addParam("CutMinClusterCharge", m_CutMinClusterCharge,
55  "cut on cluster charge for accepting good cluster, default >= 12", 12);
56  addParam("histogramDirectoryName", m_histogramDirectoryName, "Name of the directory where histograms will be placed",
57  std::string("PXDER"));
58 }
59 
60 
61 //------------------------------------------------------------------
62 // Function to define histograms
63 //-----------------------------------------------------------------
64 
65 void PXDDQMExpressRecoModule::defineHisto()
66 {
67  auto gTools = VXD::GeoCache::getInstance().getGeoTools();
68  if (gTools->getNumberOfLayers() == 0) {
69  B2FATAL("Missing geometry for VXD, check steering file.");
70  }
71  if (gTools->getNumberOfPXDLayers() == 0) {
72  B2WARNING("Missing geometry for PXD, PXD-DQM is skipped.");
73  return;
74  }
75 
76  // Create a separate histogram directories and cd into it.
77  TDirectory* oldDir = gDirectory;
78  if (m_histogramDirectoryName != "") {
79  oldDir->mkdir(m_histogramDirectoryName.c_str());// do not use return value with ->cd(), its ZERO if dir already exists
80  oldDir->cd(m_histogramDirectoryName.c_str());
81  }
82 
83  // basic constants presets:
84  int nPXDSensors = gTools->getNumberOfPXDSensors();
85  int nPXDChips = gTools->getTotalPXDChips();
86 
87  // Create basic histograms:
88  m_hitMapCounts = new TH1D("DQMER_PXD_PixelHitmapCounts", "PXD Integrated number of fired pixels per sensor",
89  nPXDSensors, 0, nPXDSensors);
90  m_hitMapCounts->GetXaxis()->SetTitle("Sensor ID");
91  m_hitMapCounts->GetYaxis()->SetTitle("counts");
92 
93  m_hitMapFilterCounts = new TH1D("DQMER_PXD_PixelHitmapFilterCounts", "PXD Integrated number of filtered pixels per sensor",
94  nPXDSensors, 0, nPXDSensors);
95  m_hitMapFilterCounts->GetXaxis()->SetTitle("Sensor ID");
96  m_hitMapFilterCounts->GetYaxis()->SetTitle("counts");
97 
98  m_hitMapClCounts = new TH1D("DQMER_PXD_ClusterHitmapCounts", "PXD Integrated number of clusters per sensor",
99  nPXDSensors, 0, nPXDSensors);
100  m_hitMapClCounts->GetXaxis()->SetTitle("Sensor ID");
101  m_hitMapClCounts->GetYaxis()->SetTitle("counts");
102 
103  m_hitMapClFilterCounts = new TH1D("DQMER_PXD_ClusterHitmapFilterCounts", "PXD Integrated number of filtered clusters per sensor",
104  nPXDSensors, 0, nPXDSensors);
105  m_hitMapClFilterCounts->GetXaxis()->SetTitle("Sensor ID");
106  m_hitMapClFilterCounts->GetYaxis()->SetTitle("counts");
107 
108  // basic counters per chip:
109  m_hitMapCountsChip = new TH1D("DQMER_PXD_PixelHitmapCountsChip", "PXD Integrated number of fired pixels per chip",
110  nPXDChips, 0, nPXDChips);
111  m_hitMapCountsChip->GetXaxis()->SetTitle("Chip ID");
112  m_hitMapCountsChip->GetYaxis()->SetTitle("counts");
113  m_hitMapClCountsChip = new TH1D("DQMER_PXD_ClusterHitmapCountsChip", "PXD Integrated number of clusters per chip",
114  nPXDChips, 0, nPXDChips);
115  m_hitMapClCountsChip->GetXaxis()->SetTitle("Chip ID");
116  m_hitMapClCountsChip->GetYaxis()->SetTitle("counts");
117  for (int i = 0; i < nPXDChips; i++) {
118  VxdID id = gTools->getChipIDFromPXDIndex(i);
119  int iLayer = id.getLayerNumber();
120  int iLadder = id.getLadderNumber();
121  int iSensor = id.getSensorNumber();
122  int iChip = gTools->getPXDChipNumber(id);
123  int IsU = gTools->isPXDSideU(id);
124  TString AxisTicks = Form("%i_%i_%i_u%iDCD", iLayer, iLadder, iSensor, iChip);
125  if (!IsU)
126  AxisTicks = Form("%i_%i_%i_v%iSWB", iLayer, iLadder, iSensor, iChip);
127  m_hitMapCountsChip->GetXaxis()->SetBinLabel(i + 1, AxisTicks.Data());
128  m_hitMapClCountsChip->GetXaxis()->SetBinLabel(i + 1, AxisTicks.Data());
129  }
130 
131  for (int i = 0; i < nPXDSensors; i++) {
132  VxdID id = gTools->getSensorIDFromPXDIndex(i);
133  int iLayer = id.getLayerNumber();
134  int iLadder = id.getLadderNumber();
135  int iSensor = id.getSensorNumber();
136  TString AxisTicks = Form("%i_%i_%i", iLayer, iLadder, iSensor);
137  m_hitMapCounts->GetXaxis()->SetBinLabel(i + 1, AxisTicks.Data());
138  m_hitMapClCounts->GetXaxis()->SetBinLabel(i + 1, AxisTicks.Data());
139  }
140 
141  m_fired.resize(nPXDSensors);
142  m_goodfired.resize(nPXDSensors);
143  m_clusters.resize(nPXDSensors);
144  m_goodclusters.resize(nPXDSensors);
145  // FIXME: startrow histos are for experts not shifters
146  //m_startRow.resize(nPXDSensors);
147  //m_chargStartRow.resize(nPXDSensors);
148  //m_startRowCount.resize(nPXDSensors);
149  m_clusterCharge.resize(nPXDSensors);
150  m_pixelSignal.resize(nPXDSensors);
151  m_clusterSizeU.resize(nPXDSensors);
152  m_clusterSizeV.resize(nPXDSensors);
153  m_clusterSizeUV.resize(nPXDSensors);
154  for (int i = 0; i < nPXDSensors; i++) {
155  VxdID id = gTools->getSensorIDFromPXDIndex(i);
156  int iLayer = id.getLayerNumber();
157  int iLadder = id.getLadderNumber();
158  int iSensor = id.getSensorNumber();
159  VxdID sensorID(iLayer, iLadder, iSensor);
160  PXD::SensorInfo SensorInfo = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::get(sensorID));
161  string sensorDescr = str(format("%1%_%2%_%3%") % iLayer % iLadder % iSensor);
162  //----------------------------------------------------------------
163  // Number of fired pixels per frame
164  //----------------------------------------------------------------
165  string name = str(format("DQMER_PXD_%1%_Fired") % sensorDescr);
166  string title = str(format("PXD Sensor %1% Fired pixels") % sensorDescr);
167  m_fired[i] = new TH1D(name.c_str(), title.c_str(), 200, 0, 200);
168  m_fired[i]->SetCanExtend(TH1::kAllAxes);
169  m_fired[i]->GetXaxis()->SetTitle("# of fired pixels");
170  m_fired[i]->GetYaxis()->SetTitle("counts");
171  //----------------------------------------------------------------
172  // Number of good fired pixels per frame
173  //----------------------------------------------------------------
174  name = str(format("DQMER_PXD_%1%_GoodFired") % sensorDescr);
175  title = str(format("PXD Sensor %1% Good pixels") % sensorDescr);
176  m_goodfired[i] = new TH1D(name.c_str(), title.c_str(), 200, 0, 200);
177  m_goodfired[i]->SetCanExtend(TH1::kAllAxes);
178  m_goodfired[i]->GetXaxis()->SetTitle("# of fired pixels");
179  m_goodfired[i]->GetYaxis()->SetTitle("counts");
180  //----------------------------------------------------------------
181  // Number of clusters per frame
182  //----------------------------------------------------------------
183  name = str(format("DQMER_PXD_%1%_Clusters") % sensorDescr);
184  title = str(format("PXD Sensor %1% Clusters") % sensorDescr);
185  m_clusters[i] = new TH1D(name.c_str(), title.c_str(), 200, 0, 200);
186  m_clusters[i]->SetCanExtend(TH1::kAllAxes);
187  m_clusters[i]->GetXaxis()->SetTitle("# of clusters");
188  m_clusters[i]->GetYaxis()->SetTitle("counts");
189  //----------------------------------------------------------------
190  // Number of good clusters per frame
191  //----------------------------------------------------------------
192  name = str(format("DQMER_PXD_%1%_GoodClusters") % sensorDescr);
193  title = str(format("PXD Sensor %1% Good clusters") % sensorDescr);
194  m_goodclusters[i] = new TH1D(name.c_str(), title.c_str(), 200, 0, 200);
195  m_goodclusters[i]->SetCanExtend(TH1::kAllAxes);
196  m_goodclusters[i]->GetXaxis()->SetTitle("# of clusters");
197  m_goodclusters[i]->GetYaxis()->SetTitle("counts");
198  //----------------------------------------------------------------
199  // Start row distribution
200  // FIXME: expert level, remove here at some point
201  //----------------------------------------------------------------
202  //name = str(format("DQMER_PXD_%1%_StartRow") % sensorDescr);
203  //title = str(format("PXD Sensor %1% Start row distribution") % sensorDescr);
204 
205  //int nPixels;/** Number of pixels on PXD v direction */
206  //nPixels = SensorInfo.getVCells();
207  //m_startRow[i] = new TH1D(name.c_str(), title.c_str(), nPixels / 4, 0.0, nPixels);
208  //m_startRow[i]->GetXaxis()->SetTitle("start row [pitch units]");
209  //m_startRow[i]->GetYaxis()->SetTitle("count");
210  //----------------------------------------------------------------
211  // Cluster seed charge by distance from the start row
212  //----------------------------------------------------------------
213  //name = str(format("DQMER_PXD_%1%_AverageSeedByStartRow") % sensorDescr);
214  //title = str(format("PXD Sensor %1% Average seed charge by distance from the start row") % sensorDescr);
215  //m_chargStartRow[i] = new TH1D(name.c_str(), title.c_str(), nPixels / 4, 0.0, nPixels);
216  //m_chargStartRow[i]->GetXaxis()->SetTitle("distance from the start row [pitch units]");
217  //m_chargStartRow[i]->GetYaxis()->SetTitle("average seed [ADU]");
218  //name = str(format("DQMER_PXD_%1%_SeedCountsByStartRow") % sensorDescr);
219  //title = str(format("PXD Sensor %1% Seed charge count by distance from the start row") % sensorDescr);
220  //m_startRowCount[i] = new TH1D(name.c_str(), title.c_str(), nPixels / 4, 0.0, nPixels);
221  //m_startRowCount[i]->GetXaxis()->SetTitle("distance from the start row [pitch units]");
222  //m_startRowCount[i]->GetYaxis()->SetTitle("count");
223  //----------------------------------------------------------------
224  // Cluster Charge
225  //----------------------------------------------------------------
226  name = str(format("DQMER_PXD_%1%_ClusterCharge") % sensorDescr);
227  title = str(format("PXD Sensor %1% Cluster Charge") % sensorDescr);
228  m_clusterCharge[i] = new TH1D(name.c_str(), title.c_str(), 256, 0, 256);
229  m_clusterCharge[i]->GetXaxis()->SetTitle("charge of clusters [ADU]");
230  m_clusterCharge[i]->GetYaxis()->SetTitle("counts");
231  //----------------------------------------------------------------
232  // Pixel Signal
233  //----------------------------------------------------------------
234  name = str(format("DQMER_PXD_%1%_PixelSignal") % sensorDescr);
235  title = str(format("PXD Sensor %1% Pixel Signal") % sensorDescr);
236  m_pixelSignal[i] = new TH1D(name.c_str(), title.c_str(), 256, 0, 256);
237  m_pixelSignal[i]->GetXaxis()->SetTitle("signal of pixels [ADU]");
238  m_pixelSignal[i]->GetYaxis()->SetTitle("counts");
239  //----------------------------------------------------------------
240  // Cluster Size in U
241  //----------------------------------------------------------------
242  name = str(format("DQMER_PXD_%1%_ClusterSizeU") % sensorDescr);
243  title = str(format("PXD Sensor %1% Cluster Size U") % sensorDescr);
244  m_clusterSizeU[i] = new TH1D(name.c_str(), title.c_str(), 10, 0, 10);
245  m_clusterSizeU[i]->GetXaxis()->SetTitle("size of u clusters");
246  m_clusterSizeU[i]->GetYaxis()->SetTitle("counts");
247  //----------------------------------------------------------------
248  // Cluster Size in V
249  //----------------------------------------------------------------
250  name = str(format("DQMER_PXD_%1%_ClusterSizeV") % sensorDescr);
251  title = str(format("PXD Sensor %1% Cluster Size V") % sensorDescr);
252  m_clusterSizeV[i] = new TH1D(name.c_str(), title.c_str(), 10, 0, 10);
253  m_clusterSizeV[i]->GetXaxis()->SetTitle("size of v clusters");
254  m_clusterSizeV[i]->GetYaxis()->SetTitle("counts");
255  //----------------------------------------------------------------
256  // Cluster Size in U+V
257  //----------------------------------------------------------------
258  name = str(format("DQMER_PXD_%1%_ClusterSizeUV") % sensorDescr);
259  title = str(format("PXD Sensor %1% Cluster Size U+V") % sensorDescr);
260  m_clusterSizeUV[i] = new TH1D(name.c_str(), title.c_str(), 10, 0, 10);
261  m_clusterSizeUV[i]->GetXaxis()->SetTitle("size of u+v clusters");
262  m_clusterSizeUV[i]->GetYaxis()->SetTitle("counts");
263  }
264 
265  oldDir->cd();
266 }
267 
268 
269 void PXDDQMExpressRecoModule::initialize()
270 {
271  // Register histograms (calls back defineHisto)
272  REG_HISTOGRAM
273 
274  auto gTools = VXD::GeoCache::getInstance().getGeoTools();
275  if (gTools->getNumberOfPXDLayers() != 0) {
276  //Register collections
277  m_storePXDDigits.isOptional(m_storePXDDigitsName);
278  m_storePXDClusters.isOptional(m_storePXDClustersName);
279  }
280 }
281 
282 void PXDDQMExpressRecoModule::beginRun()
283 {
284  auto gTools = VXD::GeoCache::getInstance().getGeoTools();
285  if (gTools->getNumberOfPXDLayers() == 0) return;
286 
287  if (m_hitMapCounts != nullptr) m_hitMapCounts->Reset();
288  if (m_hitMapFilterCounts != nullptr) m_hitMapFilterCounts->Reset();
289  if (m_hitMapClCounts != nullptr) m_hitMapClCounts->Reset();
290  if (m_hitMapClFilterCounts != nullptr) m_hitMapClFilterCounts->Reset();
291  if (m_hitMapCountsChip != nullptr) m_hitMapCountsChip->Reset();
292  if (m_hitMapClCountsChip != nullptr) m_hitMapClCountsChip->Reset();
293 
294  for (int i = 0; i < gTools->getNumberOfPXDSensors(); i++) {
295  if (m_fired[i] != nullptr) m_fired[i]->Reset();
296  if (m_goodfired[i] != nullptr) m_goodfired[i]->Reset();
297  if (m_clusters[i] != nullptr) m_clusters[i]->Reset();
298  if (m_goodclusters[i] != nullptr) m_goodclusters[i]->Reset();
299  // FIXME: startrow is for expert only, not shifter
300  //if (m_startRow[i] != nullptr) m_startRow[i]->Reset();
301  //if (m_chargStartRow[i] != nullptr) m_chargStartRow[i]->Reset();
302  //if (m_startRowCount[i] != nullptr) m_startRowCount[i]->Reset();
303  if (m_clusterCharge[i] != nullptr) m_clusterCharge[i]->Reset();
304  if (m_pixelSignal[i] != nullptr) m_pixelSignal[i]->Reset();
305  if (m_clusterSizeU[i] != nullptr) m_clusterSizeU[i]->Reset();
306  if (m_clusterSizeV[i] != nullptr) m_clusterSizeV[i]->Reset();
307  if (m_clusterSizeUV[i] != nullptr) m_clusterSizeUV[i]->Reset();
308  }
309 
310 }
311 
312 
313 void PXDDQMExpressRecoModule::event()
314 {
315  auto gTools = VXD::GeoCache::getInstance().getGeoTools();
316  if (gTools->getNumberOfPXDLayers() == 0) return;
317 
318  // If there are no digits, leave
319  if (!m_storePXDDigits || !m_storePXDDigits.getEntries()) return;
320 
321  int nPXDSensors = gTools->getNumberOfPXDSensors();
322 
323  // PXD basic histograms:
324  // Fired pixels
325  vector< int > Pixels(nPXDSensors);
326  vector< int > GoodPixels(nPXDSensors);
327  for (const PXDDigit& digit : m_storePXDDigits) {
328  int iLayer = digit.getSensorID().getLayerNumber();
329  int iLadder = digit.getSensorID().getLadderNumber();
330  int iSensor = digit.getSensorID().getSensorNumber();
331  VxdID sensorID(iLayer, iLadder, iSensor);
332  int index = gTools->getPXDSensorIndex(sensorID);
333  PXD::SensorInfo SensorInfo = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::get(sensorID));
334  Pixels[index]++;
335  int iChip = PXDMappingLookup::getDCDID(digit.getUCellID(), digit.getVCellID(), sensorID);
336  int indexChip = gTools->getPXDChipIndex(sensorID, kTRUE, iChip);
337  if (m_hitMapCountsChip != nullptr) m_hitMapCountsChip->Fill(indexChip);
338  iChip = PXDMappingLookup::getSWBID(digit.getVCellID());
339  indexChip = gTools->getPXDChipIndex(sensorID, kFALSE, iChip);
340  if (m_hitMapCountsChip != nullptr) m_hitMapCountsChip->Fill(indexChip);
341  if (m_pixelSignal[index] != nullptr) m_pixelSignal[index]->Fill(digit.getCharge());
342  if (m_hitMapCounts != nullptr) m_hitMapCounts->Fill(index);
343  // filter for pixel charge
344  if (digit.getCharge() >= m_CutMinCharge && digit.getCharge() < 255) {
345  GoodPixels[index]++;
346  if (m_hitMapFilterCounts != nullptr) m_hitMapFilterCounts->Fill(index);
347  }
348  }
349  for (int i = 0; i < nPXDSensors; i++) {
350  if (m_fired[i] != nullptr && Pixels[i] > 0) m_fired[i]->Fill(Pixels[i]);
351  if (m_goodfired[i] != nullptr && GoodPixels[i] > 0) m_goodfired[i]->Fill(GoodPixels[i]);
352  }
353 
354  // Hitmaps, Charge, Seed, Size, ...
355  vector< int > Clusters(nPXDSensors);
356  vector< int > GoodClusters(nPXDSensors);
357  for (const PXDCluster& cluster : m_storePXDClusters) {
358  int iLayer = cluster.getSensorID().getLayerNumber();
359  int iLadder = cluster.getSensorID().getLadderNumber();
360  int iSensor = cluster.getSensorID().getSensorNumber();
361  VxdID sensorID(iLayer, iLadder, iSensor);
362  int index = gTools->getPXDSensorIndex(sensorID);
363  PXD::SensorInfo SensorInfo = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::get(sensorID));
364  Clusters[index]++;
365  int iChip = PXDMappingLookup::getDCDID(SensorInfo.getUCellID(cluster.getU()), SensorInfo.getVCellID(cluster.getV()), sensorID);
366  int indexChip = gTools->getPXDChipIndex(sensorID, kTRUE, iChip);
367  if (m_hitMapClCountsChip != nullptr) m_hitMapClCountsChip->Fill(indexChip);
368  iChip = PXDMappingLookup::getSWBID(SensorInfo.getVCellID(cluster.getV()));
369  indexChip = gTools->getPXDChipIndex(sensorID, kFALSE, iChip);
370  if (m_hitMapClCountsChip != nullptr) m_hitMapClCountsChip->Fill(indexChip);
371  if (m_hitMapClCounts != nullptr) m_hitMapClCounts->Fill(index);
372  if (m_clusterCharge[index] != nullptr) m_clusterCharge[index]->Fill(cluster.getCharge());
373  if (m_clusterSizeU[index] != nullptr) m_clusterSizeU[index]->Fill(cluster.getUSize());
374  if (m_clusterSizeV[index] != nullptr) m_clusterSizeV[index]->Fill(cluster.getVSize());
375  if (m_clusterSizeUV[index] != nullptr) m_clusterSizeUV[index]->Fill(cluster.getSize());
376  // filter for cluster size and seed pixel
377  if (cluster.getSize() <= m_CutMaxClusterSize && cluster.getCharge() >= m_CutMinClusterCharge
378  && cluster.getSeedCharge() >= m_CutMinSeedCharge && cluster.getSeedCharge() < 255) {
379  GoodClusters[index]++;
380  if (m_hitMapClFilterCounts != nullptr) m_hitMapClFilterCounts->Fill(index);
381  }
382  }
383  for (int i = 0; i < nPXDSensors; i++) {
384  if (m_clusters[i] != nullptr && Clusters[i] > 0) m_clusters[i]->Fill(Clusters[i]);
385  if (m_goodclusters[i] != nullptr && GoodClusters[i] > 0) m_goodclusters[i]->Fill(GoodClusters[i]);
386  }
387 }
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
Belle2::VXD::SensorInfoBase::getUCellID
int getUCellID(double u, double v=0, bool clamp=false) const
Return the corresponding pixel/strip ID of a given u coordinate.
Definition: SensorInfoBase.h:203
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::PXDDigit
The PXD digit class.
Definition: PXDDigit.h:38
Belle2::PXD::SensorInfo
Specific implementation of SensorInfo for PXD Sensors which provides additional pixel specific inform...
Definition: SensorInfo.h:34
Belle2::PXD
Namespace to encapsulate code needed for simulation and reconstrucion of the PXD.
Definition: PXDCalibrationUtilities.h:28
Belle2::VXD::SensorInfoBase::getVCellID
int getVCellID(double v, bool clamp=false) const
Return the corresponding pixel/strip ID of a given v coordinate.
Definition: SensorInfoBase.h:213
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::PXDCluster
The PXD Cluster class This class stores all information about reconstructed PXD clusters The position...
Definition: PXDCluster.h:41
Belle2::PXDDQMExpressRecoModule
PXD DQM Module.
Definition: PXDDQMExpressRecoModule.h:42
Belle2::VxdID::getLayerNumber
baseType getLayerNumber() const
Get the layer id.
Definition: VxdID.h:106
Belle2::HistoModule
HistoModule.h is supposed to be used instead of Module.h for the modules with histogram definitions t...
Definition: HistoModule.h:29