Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
PixelReadoutManager.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "PixelReadoutManager.h"
6 
7 #include <InDetIdentifier/PixelID.h>
8 #include <InDetReadoutGeometry/SiDetectorElement.h>
9 #include <PixelReadoutGeometry/PixelModuleDesign.h>
10 #include <PixelReadoutGeometry/PixelDetectorManager.h>
11 
12 // #define PIXEL_DEBUG
13 
14 namespace InDetDD
15 {
16 
17 PixelReadoutManager::PixelReadoutManager(const std::string &name,
18  ISvcLocator *svc)
19  : base_class(name, svc)
20 {
21 }
22 
23 
24 StatusCode PixelReadoutManager::initialize()
25 {
26  ATH_MSG_DEBUG("PixelReadoutManager::initialize()");
27 
28  ATH_CHECK(m_detStore.retrieve());
29  ATH_CHECK(m_detStore->retrieve(m_detManager, "Pixel"));
30  ATH_CHECK(m_detStore->retrieve(m_idHelper, "PixelID"));
31 
32  return StatusCode::SUCCESS;
33 }
34 
35 
36 PixelModuleType PixelReadoutManager::getModuleType(Identifier id) const
37 {
38  const Identifier wafer_id = m_idHelper->wafer_id(id);
39  const SiDetectorElement *element = m_detManager->getDetectorElement(wafer_id);
40  const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
41  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::RD53) {
42  ATH_MSG_ERROR("RD53 readout technologies not supported!");
43  return PixelModuleType::NONE;
44  }
45 
46  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI4) {
47  if (m_idHelper->is_dbm(id)) {
48  return PixelModuleType::DBM;
49  }
50 
51  if (p_design->numberOfCircuits() == 2) {
52  return PixelModuleType::IBL_PLANAR;
53  }
54 
55  return PixelModuleType::IBL_3D;
56  }
57 
58  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI3) {
59  if (std::abs(m_idHelper->barrel_ec(id)) == 0) {
60  return PixelModuleType::PIX_BARREL;
61  }
62  if (std::abs(m_idHelper->barrel_ec(id)) == 2) {
63  return PixelModuleType::PIX_ENDCAP;
64  }
65  }
66 
67  return PixelModuleType::NONE;
68 }
69 
70 PixelDiodeType PixelReadoutManager::getDiodeType(Identifier id) const {
71 
72  const Identifier wafer_id = m_idHelper->wafer_id(id);
73  const SiDetectorElement *element = m_detManager->getDetectorElement(wafer_id);
74  return getDiodeType(id,element);
75 }
76 
77 PixelDiodeType PixelReadoutManager::getDiodeType(Identifier id,
78  const SiDetectorElement* element) const
79 {
80  Identifier diodeId = id;
81  Identifier offlineId = m_idHelper->wafer_id(diodeId);
82  int col = getColumn(diodeId, offlineId);
83  int row = getRow(diodeId, offlineId);
84 
85  const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
86  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::RD53) {
87  ATH_MSG_ERROR("RD53 readout technologies not supported!");
88  return PixelDiodeType::NORMAL;
89  }
90 
91  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI4) {
92  if (p_design->numberOfCircuits() == 2) { // IBL planar
93  if (col == 0 || col == p_design->columnsPerCircuit() - 1) { // column edge =0,79
94  return PixelDiodeType::LONG;
95  }
96  return PixelDiodeType::NORMAL;
97  }
98  return PixelDiodeType::NORMAL;
99  }
100 
101  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI3) {
102  if (col > 0 && col < p_design->columnsPerCircuit() - 1) {
103  if (row >= p_design->rowsPerCircuit() / 2 - 1 - 6 - 1 && row <= p_design->rowsPerCircuit() / 2 - 1) {
104  if ((row - (p_design->rowsPerCircuit() / 2 - 1 - 6) + 1) % 2 + 1 == 1) {
105  return PixelDiodeType::LONG;
106  }
107  if ((row - (p_design->rowsPerCircuit() / 2 - 1 - 6) + 1) % 2 + 1 == 2) {
108  return PixelDiodeType::GANGED;
109  }
110  }
111  return PixelDiodeType::NORMAL;
112  }
113 
114  if (col == 0 || col==p_design->columnsPerCircuit() - 1) {
115  if (row >= p_design->rowsPerCircuit() / 2 - 1 - 6 - 1) {
116  return PixelDiodeType::GANGED;
117  }
118  return PixelDiodeType::LONG;
119  }
120 
121  ATH_MSG_WARNING("Pixel Type : the col number should be 0-" << p_design->columnsPerCircuit() << ", not " <<col);
122  return PixelDiodeType::NORMAL;
123  }
124 
125  return PixelDiodeType::NORMAL;
126 }
127 
128 
129 Identifier PixelReadoutManager::getPixelIdfromHash(IdentifierHash offlineIdHash,
130  uint32_t FE,
131  uint32_t row,
132  uint32_t column) const
133 {
134  return getPixelId(m_idHelper->wafer_id(offlineIdHash), FE, row, column);
135 }
136 
137 
138 Identifier PixelReadoutManager::getPixelId(Identifier offlineId,
139  uint32_t FE,
140  uint32_t row,
141  uint32_t column) const
142 {
143  const SiDetectorElement *element = m_detManager->getDetectorElement(offlineId);
144  const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
145  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::RD53) {
146  ATH_MSG_ERROR("RD53 readout technologies not supported!");
147  return {};
148  }
149 
150  unsigned int columnsPerFE = p_design->columnsPerCircuit();
151  unsigned int FEsPerHalfModule = p_design->numberOfCircuits();
152  unsigned int rowsPerFE = 0;
153  int column_row_offset = 0;
154  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI4) {
155  rowsPerFE = p_design->rowsPerCircuit();
156  column_row_offset = -1;
157  }
158  else if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI3) {
159  rowsPerFE = p_design->rowsPerCircuit()/2+4; // normal + ganged
160  }
161 
162  // ---------------------
163  // Check input sanity
164  // ---------------------
165  // Identify the module type
166  PixelModuleType moduleType = getModuleType(offlineId);
167 
168  // Correct row, column
169  row = row + column_row_offset;
170  column = column + column_row_offset;
171 
172  if (row>=rowsPerFE || column>=columnsPerFE || FE>=((moduleType == PixelModuleType::IBL_PLANAR || moduleType == PixelModuleType::IBL_3D || moduleType == PixelModuleType::DBM) ? FEsPerHalfModule:2*FEsPerHalfModule)) {
173  ATH_MSG_DEBUG("Illegal pixel requested OfflineID: " << std::hex << offlineId << std::dec << " FE: " << FE << " row: " << row << " column: " << column);
174  ATH_MSG_DEBUG("Limits are: FE < " << ((moduleType == PixelModuleType::IBL_PLANAR || moduleType == PixelModuleType::IBL_3D || moduleType == PixelModuleType::DBM) ? FEsPerHalfModule : 2*FEsPerHalfModule) << ", row < " << rowsPerFE << ", column < " << columnsPerFE);
175  return {}; // illegal Identifier, standardized for PixelRodDecoder
176  }
177 
178  // ---------------------
179  // Convert row/column to eta/phi indices
180  // ---------------------
181  unsigned int phi_index, eta_index;
182  switch (moduleType)
183  {
184  case PixelModuleType::DBM:
185  eta_index = rowsPerFE-1-row;
186  if (m_idHelper->barrel_ec(offlineId)>0) { // A side (pos. eta)
187  phi_index = column;
188  }
189  else { // C side
190  phi_index = columnsPerFE-1-column;
191  }
192  break;
193 
194  case PixelModuleType::IBL_PLANAR:
195  phi_index = rowsPerFE-1-row;
196  eta_index = FE*columnsPerFE+column;
197  break;
198 
199  case PixelModuleType::IBL_3D:
200  phi_index = rowsPerFE-1-row;
201  eta_index = FE*columnsPerFE+column;
202  break;
203 
204  default: // pixels
205  if (FE<FEsPerHalfModule) {
206  phi_index = ((2*rowsPerFE)-1)-row;
207  eta_index = ((columnsPerFE*FEsPerHalfModule)-1)-(column+(FE*columnsPerFE));
208  }
209  else {
210  phi_index = row;
211  eta_index = ((FE-FEsPerHalfModule)*columnsPerFE)+column;
212  }
213  if (moduleType == PixelModuleType::PIX_ENDCAP) {
214  // Swap phi_index for even endcap modules
215  if ((m_idHelper->phi_module(offlineId))%2==0) {
216  phi_index = 2*rowsPerFE-phi_index-1;
217  ATH_MSG_DEBUG("Even disk module found, phi module: " << m_idHelper->phi_module(offlineId) << " swapped phi index to : " << phi_index);
218  }
219  }
220  break;
221  }
222 
223  Identifier diodeId = m_idHelper->pixel_id(offlineId, phi_index, eta_index);
224 
225 #ifdef PIXEL_DEBUG
226  unsigned int eta_index_max = m_idHelper->eta_index_max(offlineId);
227  unsigned int phi_index_max = m_idHelper->phi_index_max(offlineId);
228  if (eta_index>eta_index_max) {
229  ATH_MSG_DEBUG("Error! eta_index: " << eta_index << " > eta_index_max: " << eta_index_max);
230  }
231  if (phi_index>phi_index_max) {
232  ATH_MSG_DEBUG("Error! phi_index: " << phi_index << " > phi_index_max: " << phi_index_max);
233  }
234  //consistency check - to be removed to speed up
235  uint32_t check_FE = getFE(diodeId, offlineId);
236  uint32_t check_row = getRow(diodeId, offlineId) + column_row_offset;
237  uint32_t check_column = getColumn(diodeId, offlineId) + column_row_offset;
238  if (check_FE!=FE || check_row!=row || check_column!=column) {
239  ATH_MSG_WARNING("identify OfflineID: 0x" << std::hex << offlineId << std::dec << " FE: " << FE << " row: " << row << " column: " << column << " unequal to:");
240  ATH_MSG_WARNING("identify PixelID: 0x" << std::hex << diodeId << std::dec << " FE: " << check_FE << " row: " << check_row << " column: " << check_column);
241  }
242 #endif
243 
244  return diodeId;
245 }
246 
247 
248 uint32_t PixelReadoutManager::getFE(Identifier diodeId,
249  Identifier offlineId) const {
250 
251  const SiDetectorElement *element = m_detManager->getDetectorElement(offlineId);
252  return getFE(diodeId, offlineId, element);
253 }
254 
255 uint32_t PixelReadoutManager::getFE(Identifier diodeId,
256  Identifier offlineId,
257  const SiDetectorElement* element) const
258 {
259  const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
260  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::RD53) {
261  ATH_MSG_ERROR("RD53 readout technologies not supported!");
262  return 0xffffffff;
263  }
264 
265  unsigned int columnsPerFE = p_design->columnsPerCircuit();
266  unsigned int FEsPerHalfModule = p_design->numberOfCircuits();
267  unsigned int rowsPerFE = 0;
268  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI4) {
269  rowsPerFE = p_design->rowsPerCircuit();
270  }
271  else if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI3) {
272  rowsPerFE = p_design->rowsPerCircuit()/2+4; // normal + ganged
273  }
274 
275  // ---------------------
276  // Set module properties
277  // ---------------------
278  PixelModuleType moduleType = getModuleType(offlineId);
279  unsigned int FE;
280  unsigned int phi_index = m_idHelper->phi_index(diodeId);
281  int eta_index = m_idHelper->eta_index(diodeId);
282 
283  switch (moduleType)
284  {
285  case PixelModuleType::DBM:
286  FE = 0; // simple as that
287  return FE;
288  break;
289 
290  case PixelModuleType::PIX_ENDCAP:
291  // Swap phi_index for even endcap modules
292  if ((m_idHelper->phi_module(offlineId))%2==0) {
293  phi_index = 2*rowsPerFE-phi_index-1;
294  }
295  break;
296 
297  default: // PIX_BARREL + IBL
298  break;
299  }
300 
301 
302  // ---------------------
303  // Compute FE number
304  // ---------------------
305  if (phi_index>=rowsPerFE) {
306  FE = (int)((FEsPerHalfModule-1)-(eta_index/columnsPerFE));
307  }
308  else {
309  FE = (int)(eta_index/columnsPerFE)+FEsPerHalfModule;
310  }
311 
312  // For IBL, the above returns FE number in range [2,3] (planar), or [1] (3D sensors).
313  // Change that to be [0,1] (planar) and [0] (3D) for consistency
314  if (moduleType == PixelModuleType::IBL_PLANAR || moduleType == PixelModuleType::IBL_3D) { FE = FE - FEsPerHalfModule; }
315 
316  return FE;
317 }
318 
319 
320 uint32_t PixelReadoutManager::getColumn(Identifier diodeId,
321  Identifier offlineId) const
322 {
323  const SiDetectorElement *element = m_detManager->getDetectorElement(offlineId);
324  const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
325  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::RD53) {
326  ATH_MSG_ERROR("RD53 readout technologies not supported!");
327  return 0xffffffff;
328  }
329 
330  unsigned int columnsPerFE = p_design->columnsPerCircuit();
331  unsigned int rowsPerFE = 0;
332  int column_offset = 0;
333  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI4) {
334  rowsPerFE = p_design->rowsPerCircuit();
335  column_offset = 1;
336  }
337  else if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI3) {
338  rowsPerFE = p_design->rowsPerCircuit()/2+4; // normal + ganged
339  }
340 
341  PixelModuleType moduleType = getModuleType(offlineId);
342 
343  unsigned int phi_index = m_idHelper->phi_index(diodeId);
344  int eta_index = m_idHelper->eta_index(diodeId);
345 
346  // ---------------------
347  // Set module properties
348  // ---------------------
349  switch (moduleType)
350  {
351  case PixelModuleType::DBM:
352  break;
353 
354  case PixelModuleType::PIX_ENDCAP:
355  // Swap phi_index for even endcap modules
356  if ((m_idHelper->phi_module(offlineId))%2==0) {
357  phi_index = 2*rowsPerFE-phi_index-1;
358  }
359  break;
360 
361  default: // PIX_BARREL + IBL
362  break;
363  }
364 
365  // ---------------------
366  // Convert eta index to column number
367  // ---------------------
368  int column{};
369  // DBM (column <-> phi_index)
370  if (moduleType == PixelModuleType::DBM) {
371  if (m_idHelper->barrel_ec(offlineId)>0) {
372  column = m_idHelper->phi_index(diodeId); // A side
373  }
374  else {
375  column = columnsPerFE-m_idHelper->phi_index(diodeId)-1; // C side
376  }
377  }
378  // Pixels, IBL
379  else {
380  if ((phi_index>=rowsPerFE)) {
381  column = (columnsPerFE-1)-(eta_index%columnsPerFE);
382  }
383  else {
384  column = eta_index%columnsPerFE;
385  }
386  }
387 
388  // ---------------------
389  // Check output sanity
390  // ---------------------
391  if (column >= (int)columnsPerFE) {
392  ATH_MSG_ERROR("Computed column number exceeds maximum value: col = " << column + column_offset << " (max = " << columnsPerFE << ")");
393  return 0xffffffff;
394  }
395 
396  return column + column_offset;
397 }
398 
399 
400 uint32_t PixelReadoutManager::getRow(Identifier diodeId,
401  Identifier offlineId) const
402 {
403  const SiDetectorElement *element = m_detManager->getDetectorElement(offlineId);
404  const PixelModuleDesign *p_design = static_cast<const PixelModuleDesign *>(&element->design());
405  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::RD53) {
406  ATH_MSG_ERROR("RD53 readout technologies not supported!");
407  return 0xffffffff;
408  }
409 
410  unsigned int rowsPerFE = 0;
411  int row_offset = 0;
412  if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI4) {
413  rowsPerFE = p_design->rowsPerCircuit();
414  row_offset = 1;
415  }
416  else if (p_design->getReadoutTechnology() == PixelReadoutTechnology::FEI3) {
417  rowsPerFE = p_design->rowsPerCircuit()/2+4; // normal + ganged
418  }
419 
420  PixelModuleType moduleType = getModuleType(offlineId);
421 
422  unsigned int phi_index = m_idHelper->phi_index(diodeId);
423 
424  // ---------------------
425  // Set module properties
426  // ---------------------
427  switch (moduleType)
428  {
429  case PixelModuleType::DBM:
430  break;
431 
432  case PixelModuleType::PIX_ENDCAP:
433  // Swap phi_index for even endcap modules
434  if ((m_idHelper->phi_module(offlineId))%2==0) {
435  phi_index = 2*rowsPerFE-phi_index-1;
436  }
437  break;
438 
439  default: // PIX_BARREL + IBL
440  break;
441  }
442 
443  // ---------------------
444  // Convert phi index to row number
445  // ---------------------
446  int row{};
447  switch (moduleType)
448  {
449  case PixelModuleType::DBM:
450  // Row <-> eta_index
451  row = rowsPerFE-m_idHelper->eta_index(diodeId)-1;
452  break;
453 
454  case PixelModuleType::IBL_PLANAR:
455  row = rowsPerFE-1-phi_index;
456  break;
457 
458  case PixelModuleType::IBL_3D:
459  row = rowsPerFE-1-phi_index;
460  break;
461 
462  default: // Pixels
463  if (phi_index>=rowsPerFE) {
464  row = ((2*rowsPerFE)-1)-phi_index;
465  }
466  else {
467  row = phi_index;
468  }
469  break;
470  }
471 
472  // ---------------------
473  // Check output sanity
474  // ---------------------
475  if (row >= (int)rowsPerFE) {
476  ATH_MSG_ERROR("Computed row number exceeds maximum value: row = " << row + row_offset << "(max = " << rowsPerFE << ")");
477  return 0xffffffff;
478  }
479  return row + row_offset;
480 }
481 
482 } // namespace InDetDD
PixelID.h
This is an Identifier helper class for the Pixel subdetector. This class is a factory for creating co...
query_example.row
row
Definition: query_example.py:24
PixelID::phi_index
int phi_index(const Identifier &id) const
Definition: PixelID.h:658
InDetDD::PixelReadoutManager::m_detStore
ServiceHandle< StoreGateSvc > m_detStore
Definition: PixelReadoutManager.h:54
InDetDD::PixelModuleDesign
Definition: PixelModuleDesign.h:48
InDetDD::PixelModuleType::DBM
@ DBM
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
InDetDD::PixelReadoutManager::getPixelId
virtual Identifier getPixelId(Identifier offlineId, uint32_t FE, uint32_t row, uint32_t column) const override final
Definition: PixelReadoutManager.cxx:138
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: PixelID.h:619
InDetDD::PixelDiodeType
PixelDiodeType
Definition: PixelReadoutDefinitions.h:28
DeMoUpdate.column
dictionary column
Definition: DeMoUpdate.py:1110
InDetDD::PixelReadoutTechnology::FEI3
@ FEI3
InDetDD::PixelDiodeType::GANGED
@ GANGED
PixelID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: PixelID.h:364
InDetDD::PixelReadoutTechnology::RD53
@ RD53
PixelReadoutManager.h
InDetDD::PixelModuleType::NONE
@ NONE
PixelDetectorManager.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
InDetDD::PixelDiodeType::LONG
@ LONG
PixelID::phi_index_max
int phi_index_max(const Identifier &id) const
Definition: PixelID.cxx:141
PixelID::eta_index_max
int eta_index_max(const Identifier &id) const
Definition: PixelID.cxx:160
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
InDetDD::PixelModuleDesign::numberOfCircuits
int numberOfCircuits() const
Total number of circuits:
Definition: PixelModuleDesign.h:315
PixelID::eta_index
int eta_index(const Identifier &id) const
Definition: PixelID.h:664
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
InDetDD::PixelModuleType
PixelModuleType
Definition: PixelReadoutDefinitions.h:18
Handler::svc
AthROOTErrorHandlerSvc * svc
Definition: AthROOTErrorHandlerSvc.cxx:10
createCablingJSON.eta_index
int eta_index
Definition: createCablingJSON.py:14
InDetDD::PixelReadoutManager::PixelReadoutManager
PixelReadoutManager(const std::string &name, ISvcLocator *svc)
Definition: PixelReadoutManager.cxx:17
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
InDetDD::PixelReadoutManager::getFE
virtual uint32_t getFE(Identifier diodeId, Identifier offlineId) const override final
Definition: PixelReadoutManager.cxx:248
InDetDD::PixelReadoutManager::getRow
virtual uint32_t getRow(Identifier diodeId, Identifier offlineId) const override final
Definition: PixelReadoutManager.cxx:400
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
InDetDD::PixelReadoutTechnology::FEI4
@ FEI4
InDetDD::PixelModuleDesign::getReadoutTechnology
PixelReadoutTechnology getReadoutTechnology() const
Definition: PixelModuleDesign.h:386
query_example.col
col
Definition: query_example.py:7
InDetDD::PixelModuleType::IBL_PLANAR
@ IBL_PLANAR
SiDetectorElement.h
PixelID::is_dbm
bool is_dbm(const Identifier &id) const
Test for dbm - WARNING: id MUST be pixel id, otherwise answer is not accurate. Use SiliconID for gene...
Definition: PixelID.h:612
InDetDD::PixelReadoutManager::getPixelIdfromHash
virtual Identifier getPixelIdfromHash(IdentifierHash offlineIdHash, uint32_t FE, uint32_t row, uint32_t column) const override final
Definition: PixelReadoutManager.cxx:129
InDetDD::PixelModuleType::PIX_ENDCAP
@ PIX_ENDCAP
InDetDD::PixelModuleDesign::rowsPerCircuit
int rowsPerCircuit() const
Number of cell rows per circuit:
Definition: PixelModuleDesign.h:335
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
InDetDD
Message Stream Member.
Definition: FakeTrackBuilder.h:8
PixelModuleDesign.h
InDetDD::PixelReadoutManager::getColumn
virtual uint32_t getColumn(Identifier diodeId, Identifier offlineId) const override final
Definition: PixelReadoutManager.cxx:320
InDetDD::PixelReadoutManager::m_detManager
const PixelDetectorManager * m_detManager
Definition: PixelReadoutManager.h:55
InDetDD::PixelReadoutManager::m_idHelper
const PixelID * m_idHelper
Definition: PixelReadoutManager.h:56
PixelID::pixel_id
Identifier pixel_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int phi_index, int eta_index) const
For an individual pixel.
Definition: PixelID.h:432
InDetDD::PixelReadoutManager::getModuleType
virtual PixelModuleType getModuleType(Identifier id) const override final
Definition: PixelReadoutManager.cxx:36
InDetDD::PixelDiodeType::NORMAL
@ NORMAL
InDetDD::PixelReadoutManager::getDiodeType
virtual PixelDiodeType getDiodeType(Identifier id) const override final
Definition: PixelReadoutManager.cxx:70
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
InDetDD::PixelModuleType::PIX_BARREL
@ PIX_BARREL
InDetDD::SiDetectorElement::design
virtual const SiDetectorDesign & design() const override final
access to the local description (inline):
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition: PixelID.h:644
InDetDD::PixelModuleType::IBL_3D
@ IBL_3D
InDetDD::PixelModuleDesign::columnsPerCircuit
int columnsPerCircuit() const
Number of cell columns per circuit:
Definition: PixelModuleDesign.h:330
InDetDD::PixelReadoutManager::initialize
virtual StatusCode initialize() override final
Definition: PixelReadoutManager.cxx:24
InDetDD::PixelDetectorManager::getDetectorElement
virtual SiDetectorElement * getDetectorElement(const Identifier &id) const override
access to individual elements : via Identifier
Definition: PixelDetectorManager.cxx:80
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Wed Apr 2 2025 21:16:48 for ATLAS Offline Software by   doxygen 1.8.18