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