Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Private Attributes | List of all members
InDetDD::PixelReadoutManager Class Referencefinal

#include <PixelReadoutManager.h>

Inheritance diagram for InDetDD::PixelReadoutManager:
Collaboration diagram for InDetDD::PixelReadoutManager:

Public Member Functions

 PixelReadoutManager (const std::string &name, ISvcLocator *svc)
 
virtual StatusCode initialize () override final
 
virtual PixelModuleType getModuleType (Identifier id) const override final
 
virtual PixelDiodeType getDiodeType (Identifier id) const override final
 
virtual PixelDiodeType getDiodeType (Identifier id, const SiDetectorElement *element) const override final
 
virtual Identifier getPixelIdfromHash (IdentifierHash offlineIdHash, uint32_t FE, uint32_t row, uint32_t column) const override final
 
virtual Identifier getPixelId (Identifier offlineId, uint32_t FE, uint32_t row, uint32_t column) const override final
 
virtual uint32_t getFE (Identifier diodeId, Identifier offlineId) const override final
 
virtual uint32_t getFE (Identifier diodeId, Identifier offlineId, const SiDetectorElement *element) const override final
 
virtual uint32_t getColumn (Identifier diodeId, Identifier offlineId) const override final
 
virtual uint32_t getRow (Identifier diodeId, Identifier offlineId) const override final
 

Private Attributes

ServiceHandle< StoreGateSvc > m_detStore {this, "DetectorStore", "DetectorStore"}
 
const PixelDetectorManager * m_detManager {}
 
const PixelID * m_idHelper {}
 

Detailed Description

Definition at line 18 of file PixelReadoutManager.h.

Constructor & Destructor Documentation

◆ PixelReadoutManager()

InDetDD::PixelReadoutManager::PixelReadoutManager ( const std::string &  name,
ISvcLocator *  svc 
)

Definition at line 17 of file PixelReadoutManager.cxx.

19  : base_class(name, svc)
20 {
21 }

Member Function Documentation

◆ getColumn()

uint32_t InDetDD::PixelReadoutManager::getColumn ( Identifier  diodeId,
Identifier  offlineId 
) const
finaloverridevirtual

Definition at line 320 of file PixelReadoutManager.cxx.

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 }

◆ getDiodeType() [1/2]

PixelDiodeType InDetDD::PixelReadoutManager::getDiodeType ( Identifier  id) const
finaloverridevirtual

Definition at line 70 of file PixelReadoutManager.cxx.

70  {
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 }

◆ getDiodeType() [2/2]

PixelDiodeType InDetDD::PixelReadoutManager::getDiodeType ( Identifier  id,
const SiDetectorElement *  element 
) const
finaloverridevirtual

Definition at line 77 of file PixelReadoutManager.cxx.

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 }

◆ getFE() [1/2]

uint32_t InDetDD::PixelReadoutManager::getFE ( Identifier  diodeId,
Identifier  offlineId 
) const
finaloverridevirtual

Definition at line 248 of file PixelReadoutManager.cxx.

249  {
250 
251  const SiDetectorElement *element = m_detManager->getDetectorElement(offlineId);
252  return getFE(diodeId, offlineId, element);
253 }

◆ getFE() [2/2]

uint32_t InDetDD::PixelReadoutManager::getFE ( Identifier  diodeId,
Identifier  offlineId,
const SiDetectorElement *  element 
) const
finaloverridevirtual

Definition at line 255 of file PixelReadoutManager.cxx.

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 }

◆ getModuleType()

PixelModuleType InDetDD::PixelReadoutManager::getModuleType ( Identifier  id) const
finaloverridevirtual

Definition at line 36 of file PixelReadoutManager.cxx.

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 }

◆ getPixelId()

Identifier InDetDD::PixelReadoutManager::getPixelId ( Identifier  offlineId,
uint32_t  FE,
uint32_t  row,
uint32_t  column 
) const
finaloverridevirtual

Definition at line 138 of file PixelReadoutManager.cxx.

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 }

◆ getPixelIdfromHash()

Identifier InDetDD::PixelReadoutManager::getPixelIdfromHash ( IdentifierHash  offlineIdHash,
uint32_t  FE,
uint32_t  row,
uint32_t  column 
) const
finaloverridevirtual

Definition at line 129 of file PixelReadoutManager.cxx.

133 {
134  return getPixelId(m_idHelper->wafer_id(offlineIdHash), FE, row, column);
135 }

◆ getRow()

uint32_t InDetDD::PixelReadoutManager::getRow ( Identifier  diodeId,
Identifier  offlineId 
) const
finaloverridevirtual

Definition at line 400 of file PixelReadoutManager.cxx.

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 }

◆ initialize()

StatusCode InDetDD::PixelReadoutManager::initialize ( )
finaloverridevirtual

Definition at line 24 of file PixelReadoutManager.cxx.

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 }

Member Data Documentation

◆ m_detManager

const PixelDetectorManager* InDetDD::PixelReadoutManager::m_detManager {}
private

Definition at line 55 of file PixelReadoutManager.h.

◆ m_detStore

ServiceHandle<StoreGateSvc> InDetDD::PixelReadoutManager::m_detStore {this, "DetectorStore", "DetectorStore"}
private

Definition at line 54 of file PixelReadoutManager.h.

◆ m_idHelper

const PixelID* InDetDD::PixelReadoutManager::m_idHelper {}
private

Definition at line 56 of file PixelReadoutManager.h.

The documentation for this class was generated from the following files:
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::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
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
InDetDD::PixelModuleType::NONE
@ NONE
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
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
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
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::PixelReadoutTechnology::FEI4
@ FEI4
query_example.col
col
Definition: query_example.py:7
InDetDD::PixelModuleType::IBL_PLANAR
@ IBL_PLANAR
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::PixelModuleType::PIX_ENDCAP
@ PIX_ENDCAP
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
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
InDetDD::PixelModuleType::PIX_BARREL
@ PIX_BARREL
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition: PixelID.h:644
InDetDD::PixelModuleType::IBL_3D
@ IBL_3D
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 Sat Apr 12 2025 22:00:08 for ATLAS Offline Software by   doxygen 1.8.18