ATLAS Offline Software
PixelID.h
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3  */
4 
5 #ifndef INDETIDENTIFIER_PIXELID_H
6 #define INDETIDENTIFIER_PIXELID_H
7 
20 #include "Identifier/Identifier.h"
23 #include "Identifier/MultiRange.h"
24 #include "Identifier/IdHelper.h"
26 #include "AthenaKernel/CLASS_DEF.h"
27 
28 #include <string>
29 #include <cassert>
30 #include <algorithm>
31 
32 
33 class IdDictDictionary;
34 
66 class PixelID: public AtlasDetectorID
67 {
68 public:
70 
72  typedef std::vector<Identifier>::const_iterator const_id_iterator;
75 
77 
78  PixelID();
80 
82  virtual AtlasDetectorID::HelperType helper() const override{
84  }
85 
87 
90  int layer_disk,
91  int phi_module,
92  int eta_module) const;
94  int layer_disk,
95  int phi_module,
96  int eta_module,
97  bool checks) const;
98 
101  Identifier wafer_id(const Identifier& pixel_id) const;
102 
105 
108  int layer_disk,
109  int phi_module,
110  int eta_module,
111  int phi_index,
112  int eta_index) const;
114  int layer_disk,
115  int phi_module,
116  int eta_module,
117  int phi_index,
118  int eta_index,
119  bool checks) const;
120  Identifier pixel_id(const Identifier& id,
121  int phi_index,
122  int eta_index) const;
124 
126 
127  size_type wafer_hash_max() const;
128  size_type pixel_hash_max() const;
130 
132 
141 
142 
144 
147 
149  bool is_barrel(const Identifier& id) const;
150 
152  bool is_dbm(const Identifier& id) const; //DBM
153 
155  bool is_blayer(const Identifier& id) const;
156 
158  int barrel_ec(const Identifier& id) const;
159  int layer_disk(const Identifier& id) const;
160  int phi_module(const Identifier& id) const;
161  int eta_module(const Identifier& id) const;
162  int phi_index(const Identifier& id) const;
163  int eta_index(const Identifier& id) const;
164 
166  int layer_disk_max(const Identifier& id) const;
167  int phi_module_max(const Identifier& id) const;
168  int eta_module_max(const Identifier& id) const;
169  int eta_module_min(const Identifier& id) const;
170  int phi_index_max(const Identifier& id) const;
171  int eta_index_max(const Identifier& id) const;
173 
175 
176  int get_prev_in_phi(const IdentifierHash& id, IdentifierHash& prev) const;
179  int get_next_in_phi(const IdentifierHash& id, IdentifierHash& next) const;
181  int get_prev_in_eta(const IdentifierHash& id, IdentifierHash& prev) const;
183  int get_next_in_eta(const IdentifierHash& id, IdentifierHash& next) const;
184 
186  bool is_phi_module_max(const Identifier& id) const;
188  bool is_eta_module_min(const Identifier& id) const;
190  bool is_eta_module_max(const Identifier& id) const;
192 
193 
195 
196  IdContext wafer_context() const;
197  IdContext pixel_context() const;
199 
201 
202  virtual int get_id(const IdentifierHash& hash_id,
204  Identifier& id,
205  const IdContext* context = 0) const override final;
206 
208  virtual int get_hash(const Identifier& id,
209  IdentifierHash& hash_id,
210  const IdContext* context = 0) const override final;
212 
216 
221 
226 
228  int base_bit() const;
229 
233 
236  Identifier::diff_type offset) const;
237 
239 
244 
247  ExpandedIdentifier& exp_id,
248  const IdContext* context = 0) const;
249 
251  virtual int initialize_from_dictionary(const IdDictMgr& dict_mgr) override;
252 
254  void test_wafer_packing() const;
256 
257 protected:
258  enum {
259  NOT_VALID_HASH = 64000,
262  };
263 
264  typedef std::vector<Identifier> id_vec;
265  typedef id_vec::const_iterator id_vec_it;
266  typedef std::vector<unsigned short> hash_vec;
267  typedef hash_vec::const_iterator hash_vec_it;
268 
269  void wafer_id_checks(int barrel_ec,
270  int layer_disk,
271  int phi_module,
272  int eta_module) const;
273  void pixel_id_checks(int barrel_ec,
274  int layer_disk,
275  int phi_module,
276  int eta_module,
277  int phi_index,
278  int eta_index) const;
279 
280  int initLevelsFromDict();
281 
282  int init_hashes();
283 
284  int init_neighbors();
285 
288 
311 
325 
327 };
328 
329 
330 
331 //using the macros below we can assign an identifier (and a version)
332 //This is required and checked at compile time when you try to record/retrieve
333 CLASS_DEF(PixelID, 2516, 1)
334 
335 //----------------------------------------------------------------------------
336 inline Identifier
337 PixelID::wafer_id(int barrel_ec,
338  int layer_disk,
339  int phi_module,
340  int eta_module,
341  bool checks) const {
342  // Build identifier
343  Identifier result = m_baseIdentifier;
344 
345  // Pack fields independently
346  m_bec_impl.pack(barrel_ec, result);
347  m_lay_disk_impl.pack(layer_disk, result);
348  m_phi_mod_impl.pack(phi_module, result);
349  m_eta_mod_impl.pack(eta_module, result);
350 
351  // Do checks
352  if (checks) {
353  wafer_id_checks(barrel_ec, layer_disk, phi_module, eta_module);
354  }
355 
356  return result;
357 }
358 
359 inline Identifier
360 PixelID::wafer_id(int barrel_ec,
361  int layer_disk,
362  int phi_module,
363  int eta_module) const {
365 }
366 
367 //----------------------------------------------------------------------------
368 inline Identifier
369 PixelID::wafer_id(const Identifier& pixel_id) const {
371 
374  return(result);
375 }
376 
377 //----------------------------------------------------------------------------
378 inline Identifier PixelID::wafer_id(IdentifierHash wafer_hash) const {
379  return(m_wafer_vec[wafer_hash]);
380 }
381 
382 //----------------------------------------------------------------------------
384  id_vec_it it = std::lower_bound(m_wafer_vec.begin(),
385  m_wafer_vec.end(),
386  wafer_id);
387 
388  // Require that wafer_id matches the one in vector
389  if (it != m_wafer_vec.end() && wafer_id == (*it)) {
390  return(it - m_wafer_vec.begin());
391  }
393  return(result); // return hash in invalid state
394 }
395 
396 //----------------------------------------------------------------------------
397 inline Identifier
398 PixelID::pixel_id(int barrel_ec,
399  int layer_disk,
400  int phi_module,
401  int eta_module,
402  int phi_index,
403  int eta_index,
404  bool checks) const {
405  // Build identifier
407 
414 
415  if (checks) {
417  layer_disk,
418  phi_module,
419  eta_module,
420  phi_index,
421  eta_index);
422  }
423 
424  return result;
425 }
426 
427 inline Identifier
428 PixelID::pixel_id(int barrel_ec,
429  int layer_disk,
430  int phi_module,
431  int eta_module,
432  int phi_index,
433  int eta_index) const {
436 }
437 
440 //----------------------------------------------------------------------------
441 inline Identifier
443  bool checks) const {
445 
447  id[m_LAYER_DISK_INDEX],
448  id[m_PHI_MODULE_INDEX],
449  id[m_ETA_MODULE_INDEX],
450  id[m_PHI_INDEX_INDEX],
451  id[m_ETA_INDEX_INDEX]);
452 
453  if (checks) {
455  id[m_LAYER_DISK_INDEX],
456  id[m_PHI_MODULE_INDEX],
457  id[m_ETA_MODULE_INDEX],
458  id[m_PHI_INDEX_INDEX],
459  id[m_ETA_INDEX_INDEX]);
460  }
461 
462  return(result);
463 }
464 
465 inline Identifier
467  return pixel_id(id, do_checks());
468 }
469 
470 //----------------------------------------------------------------------------
471 inline Identifier
473  int phi_index,
474  int eta_index) const {
476 
481  return(result);
482 }
483 
484 //----------------------------------------------------------------------------
485 inline Identifier
487  // a pixel channel id has bit 31 set, and low 8 bits > 0.
488  // This could also have been shifted up by 32 bits.
489 
490  // first test to see if this is a 32-bit value promoted to 64-bit
491  // (low word != 0, high word == 0).
492  if ((val << 32) && !(val >> 32)) {
493  // test to see if this is a genuine 64-bit pixel channel id;
494  // these would not have the low 8-bits nonzero.
495  // (This will break if pixel channel id's fill more than 56 bits!)
496  Identifier32::value_type valshort = static_cast<Identifier32::value_type>(val);
497  if (is_shortened_pixel_id(valshort)) {
498  return pixel_id_from_shortened(valshort);
499  }
500  } else if (!(val << 32) && (val >> 32)) {
501  // low word 0, high word != 0
502  Identifier32::value_type valshort = static_cast<Identifier32::value_type>(val >> 32);
503  if (is_shortened_pixel_id(valshort)) {
504  return pixel_id_from_shortened(valshort);
505  }
506  }
507  return Identifier(val); // genuine 64-bit pixel channel id
508 }
509 
510 //----------------------------------------------------------------------------
511 inline bool
513  return (val >> 31) && (val & 0xff);
514 }
515 
516 //----------------------------------------------------------------------------
517 inline bool
519  return is_shortened_pixel_id(id.get_compact());
520 }
521 
522 //----------------------------------------------------------------------------
523 inline bool
525  Identifier::value_type val = id.get_compact();
526  Identifier32::value_type valshort;
527  // first test if value is contained in one half or the other
528  if ((val << 32) && !(val >> 32)) {
529  // low word contains value, high word empty
530  valshort = static_cast<Identifier32::value_type>(val);
531  } else if (!(val << 32) && (val >> 32)) {
532  // high word contains value, low word empty
533  valshort = static_cast<Identifier32::value_type>(val >> 32);
534  } else {
535  return false;
536  }
537  return is_shortened_pixel_id(valshort);
538 }
539 
540 //----------------------------------------------------------------------------
541 inline Identifier
543  int bec_val[4] = {
544  -2, 0, 2, -999
545  }; // CHECK decodings
546  int bec = bec_val[(val >> 29) & 0x03];
547 
548  if (bec < -2) return Identifier();
549 
550  return pixel_id(bec,
551  /* lay_disk */ ((val >> 27) & 0x03),
552  /* phi_mod */ ((val >> 21) & 0x3f),
553  /* eta_mod */ (((val >> 17) & 0x0f) + m_ETA_MODULE_OFFSET),
554  /* phi_index */ ((val >> 8) & 0x1ff),
555  /* eta_index */ ((val) & 0xff) - 1);
556 }
557 
558 //----------------------------------------------------------------------------
561  Identifier::diff_type tval = static_cast<Identifier::diff_type>(target.get_compact() >> base_bit());
562  Identifier::diff_type bval = static_cast<Identifier::diff_type>(base.get_compact() >> base_bit());
563  return(tval - bval);
564 }
565 
566 //----------------------------------------------------------------------------
567 inline Identifier
570  Identifier::value_type bval = base.get_compact() >> base_bit();
571  return Identifier((bval + offset) << base_bit());
572 }
573 
574 //----------------------------------------------------------------------------
575 inline int
577  int base = static_cast<int>(m_eta_index_impl.shift()); // lowest field base
578 
579  return (base > 32) ? 32 : base;
580  // max base is 32 so we can still read old strip id's and differences
581  // from non-SLHC releases.
582 }
583 
584 //----------------------------------------------------------------------------
585 inline IdContext
588 
589  return(IdContext(id, 0, m_ETA_MODULE_INDEX));
590 }
591 
592 //----------------------------------------------------------------------------
593 inline IdContext
595  // For pixel only, the prefix is the first two levels
597 }
598 
599 //----------------------------------------------------------------------------
600 inline bool
601 PixelID::is_barrel(const Identifier& id) const {
602  // Normal unshifted id
603  return(m_barrel_field.match(m_bec_impl.unpack(id)));
604 }
605 
606 //----------------------------------------------------------------------------
607 inline bool
608 PixelID::is_dbm(const Identifier& id) const {
609  // Normal unshifted id
610  return(m_dbm_field.match(m_bec_impl.unpack(id)));
611 }
612 
613 //----------------------------------------------------------------------------
614 inline int
615 PixelID::barrel_ec(const Identifier& id) const {
616  // Normal unshifted id
617  return(m_bec_impl.unpack(id));
618 }
619 
620 //----------------------------------------------------------------------------
621 inline int
622 PixelID::layer_disk(const Identifier& id) const {
623  // Normal unshifted id
624  return(m_lay_disk_impl.unpack(id));
625 }
626 
627 //----------------------------------------------------------------------------
628 inline bool
629 PixelID::is_blayer(const Identifier& id) const {
630  // Check if it is pixel id
631  if (is_barrel(id)) {
632  return(0 == layer_disk(id));
633  } else {
634  return(false);
635  }
636 }
637 
638 //----------------------------------------------------------------------------
639 inline int
640 PixelID::phi_module(const Identifier& id) const {
641  // Normal unshifted id
642  return(m_phi_mod_impl.unpack(id));
643 }
644 
645 //----------------------------------------------------------------------------
646 inline int
647 PixelID::eta_module(const Identifier& id) const {
648  // Normal unshifted id
649  return(m_eta_mod_impl.unpack(id));
650 }
651 
652 //----------------------------------------------------------------------------
653 inline int
654 PixelID::phi_index(const Identifier& id) const {
655  return(m_phi_index_impl.unpack(id));
656 }
657 
658 //----------------------------------------------------------------------------
659 inline int
660 PixelID::eta_index(const Identifier& id) const {
661  return(m_eta_index_impl.unpack(id));
662 }
663 
664 #endif // INDETIDENTIFIER_PIXELID_H
PixelID::init_hashes
int init_hashes()
Definition: PixelID.cxx:356
base
std::string base
Definition: hcg.cxx:78
PixelID::m_bec_impl
IdDictFieldImplementation m_bec_impl
Definition: PixelID.h:314
Identifier32
Definition: Identifier32.h:25
PixelID::get_hash
virtual int get_hash(const Identifier &id, IdentifierHash &hash_id, const IdContext *context=0) const override final
Create hash id from compact id (return == 0 for OK)
Definition: PixelID.cxx:901
PixelID::m_wafer_hash_max
size_type m_wafer_hash_max
Definition: PixelID.h:303
PixelID::m_INDET_INDEX
size_type m_INDET_INDEX
Definition: PixelID.h:290
PixelID::phi_index
int phi_index(const Identifier &id) const
Definition: PixelID.h:654
PixelID::const_id_iterator
std::vector< Identifier >::const_iterator const_id_iterator
Definition: PixelID.h:72
get_generator_info.result
result
Definition: get_generator_info.py:21
PixelID::is_eta_module_min
bool is_eta_module_min(const Identifier &id) const
For the barrel.
Definition: PixelID.cxx:114
PixelID::base_bit
int base_bit() const
Return the lowest bit position used in the channel id.
Definition: PixelID.h:576
AtlasDetectorID::HelperType::Pixel
@ Pixel
ParticleGun_SamplingFraction.bec
int bec
Definition: ParticleGun_SamplingFraction.py:89
PixelID::m_pixel_id
Identifier m_pixel_id
Definition: PixelID.h:299
PixelID::init_neighbors
int init_neighbors()
Definition: PixelID.cxx:466
PixelID::m_eta_mod_shift_impl
IdDictFieldImplementation m_eta_mod_shift_impl
Definition: PixelID.h:321
PixelID::m_bec_shift_impl
IdDictFieldImplementation m_bec_shift_impl
Definition: PixelID.h:318
PixelID::PixelID
PixelID()
Definition: PixelID.cxx:22
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: PixelID.h:615
PixelID::hash_vec_it
hash_vec::const_iterator hash_vec_it
Definition: PixelID.h:267
PixelID::initialize_from_dictionary
virtual int initialize_from_dictionary(const IdDictMgr &dict_mgr) override
Initialization from the identifier dictionary.
Definition: PixelID.cxx:185
PixelID::m_indet_impl
IdDictFieldImplementation m_indet_impl
Definition: PixelID.h:312
PixelID::m_dbm_field
Range::field m_dbm_field
Definition: PixelID.h:326
PixelID::m_next_eta_wafer_vec
hash_vec m_next_eta_wafer_vec
Definition: PixelID.h:310
PixelID::m_BARREL_EC_INDEX
size_type m_BARREL_EC_INDEX
Definition: PixelID.h:292
skel.it
it
Definition: skel.GENtoEVGEN.py:407
PixelID::m_phi_index_impl
IdDictFieldImplementation m_phi_index_impl
Definition: PixelID.h:322
PixelID::m_ETA_INDEX_INDEX
size_type m_ETA_INDEX_INDEX
Definition: PixelID.h:297
PixelID::m_phi_mod_shift_impl
IdDictFieldImplementation m_phi_mod_shift_impl
Definition: PixelID.h:320
PixelID::BITS32
@ BITS32
Definition: PixelID.h:261
PixelID::m_full_pixel_range
MultiRange m_full_pixel_range
Definition: PixelID.h:302
ExpandedIdentifier
Definition: DetectorDescription/Identifier/Identifier/ExpandedIdentifier.h:102
PixelID::m_eta_mod_impl
IdDictFieldImplementation m_eta_mod_impl
Definition: PixelID.h:317
IdDictFieldImplementation::pack
void pack(int value, Identifier &id) const
Definition: IdDictFieldImplementation.h:173
PixelID::m_ETA_MODULE_OFFSET
int m_ETA_MODULE_OFFSET
Definition: PixelID.h:298
PixelID::m_ETA_MODULE_INDEX
size_type m_ETA_MODULE_INDEX
Definition: PixelID.h:295
IdHelper.h
PixelID::calc_offset
Identifier::diff_type calc_offset(const Identifier &base, const Identifier &target) const
Calculate a channel offset between the two identifiers.
Definition: PixelID.h:560
PixelID::get_prev_in_phi
int get_prev_in_phi(const IdentifierHash &id, IdentifierHash &prev) const
Previous wafer hash in phi (return == 0 for neighbor found)
Definition: PixelID.cxx:415
Identifier::MAX_BIT
static constexpr value_type MAX_BIT
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
PixelID::initLevelsFromDict
int initLevelsFromDict()
Definition: PixelID.cxx:598
PixelID::pixel_end
const_expanded_id_iterator pixel_end() const
Definition: PixelID.cxx:854
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:560
PixelID::m_baseExpandedIdentifier
ExpandedIdentifier m_baseExpandedIdentifier
Definition: PixelID.h:287
Identifier::diff_type
long long diff_type
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:28
IdDictFieldImplementation::unpack
int unpack(Identifier id) const
Identifier manipulation methods.
Definition: IdDictFieldImplementation.h:147
PixelID::m_wafer_vec
id_vec m_wafer_vec
Definition: PixelID.h:306
PixelID::is_shortened_pixel_id
bool is_shortened_pixel_id(Identifier32::value_type val) const
Test if this is a valid shortened pixel channel id.
Definition: PixelID.h:512
PixelID::eta_module_max
int eta_module_max(const Identifier &id) const
Definition: PixelID.cxx:79
PixelID::is_blayer
bool is_blayer(const Identifier &id) const
Test for b-layer - WARNING: id MUST be pixel id, otherwise answer is not accurate....
Definition: PixelID.h:629
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:360
AtlasDetectorID::HelperType
HelperType
enum class for eventual final derived types of this class
Definition: AtlasDetectorID.h:55
PixelID::pixel_hash_max
size_type pixel_hash_max() const
Definition: PixelID.cxx:838
PixelID::m_PIXEL_INDEX
size_type m_PIXEL_INDEX
Definition: PixelID.h:291
PixelID::wafer_context
IdContext wafer_context() const
Definition: PixelID.h:586
IdDictFieldImplementation::reset
void reset(Identifier &id) const
Definition: IdDictFieldImplementation.h:183
PixelID::m_bec_eta_mod_impl
IdDictFieldImplementation m_bec_eta_mod_impl
Definition: PixelID.h:324
AtlasDetectorID::size_type
Identifier::size_type size_type
Definition: AtlasDetectorID.h:385
IdentifierField::match
bool match(element_type value) const
The basic match operation Given a value, test to see if it satisfies the constraints for this field.
Definition: IdentifierField.cxx:71
AtlasDetectorID.h
This class provides an interface to generate or decode an identifier for the upper levels of the dete...
IdDictMgr
Definition: IdDictMgr.h:14
PixelID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel - WARNING: id MUST be pixel id, otherwise answer is not accurate. Use SiliconID for g...
Definition: PixelID.h:601
PixelID::pixel_begin
const_expanded_id_iterator pixel_begin() const
For pixel ids, only expanded id iterators are available.
Definition: PixelID.cxx:850
Identifier::ALL_BITS
static constexpr value_type ALL_BITS
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:33
IdDictFieldImplementation::shift
size_type shift() const
Definition: IdDictFieldImplementation.h:226
PixelID::wafer_hash
IdentifierHash wafer_hash(Identifier wafer_id) const
wafer hash from id
Definition: PixelID.h:383
PixelID::m_pixel_hash_max
size_type m_pixel_hash_max
Definition: PixelID.h:304
PixelID::get_next_in_phi
int get_next_in_phi(const IdentifierHash &id, IdentifierHash &next) const
Next wafer hash in phi (return == 0 for neighbor found)
Definition: PixelID.cxx:428
PixelID::m_baseIdentifier
Identifier m_baseIdentifier
Definition: PixelID.h:286
PixelID::get_expanded_id
void get_expanded_id(const Identifier &id, ExpandedIdentifier &exp_id, const IdContext *context=0) const
Create expanded id from compact id (return == 0 for OK)
Definition: PixelID.cxx:859
PixelID::phi_index_max
int phi_index_max(const Identifier &id) const
Definition: PixelID.cxx:143
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
MultiRange::const_identifier_factory
Definition: MultiRange.h:52
PixelID::pixel_id_offset
Identifier pixel_id_offset(const Identifier &base, Identifier::diff_type offset) const
Create an identifier with a given base and channel offset.
Definition: PixelID.h:568
PixelID::eta_index_max
int eta_index_max(const Identifier &id) const
Definition: PixelID.cxx:162
PixelID::m_full_wafer_range
MultiRange m_full_wafer_range
Definition: PixelID.h:301
PixelID::pixel_id_checks
void pixel_id_checks(int barrel_ec, int layer_disk, int phi_module, int eta_module, int phi_index, int eta_index) const
Definition: PixelID.cxx:45
PixelID::eta_index
int eta_index(const Identifier &id) const
Definition: PixelID.h:660
createCablingJSON.eta_index
int eta_index
Definition: createCablingJSON.py:14
PixelID::get_next_in_eta
int get_next_in_eta(const IdentifierHash &id, IdentifierHash &next) const
Next wafer hash in eta (return == 0 for neighbor found)
Definition: PixelID.cxx:454
columnar::final
CM final
Definition: ColumnAccessor.h:106
PixelID::phi_module_max
int phi_module_max(const Identifier &id) const
Definition: PixelID.cxx:123
PixelID::wafer_hash_max
size_type wafer_hash_max() const
Definition: PixelID.cxx:833
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:622
PixelID::eta_module
int eta_module(const Identifier &id) const
Definition: PixelID.h:647
PixelID::m_next_phi_wafer_vec
hash_vec m_next_phi_wafer_vec
Definition: PixelID.h:308
MultiRange
A MultiRange combines several Ranges.
Definition: MultiRange.h:17
PixelID::test_wafer_packing
void test_wafer_packing() const
Tests of packing.
Definition: PixelID.cxx:931
protected
#define protected
Definition: GenEventCnv_p1.h:26
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
PixelID::MAX_BIT
@ MAX_BIT
Definition: PixelID.h:260
IdentifierHash.h
PixelID::m_prev_phi_wafer_vec
hash_vec m_prev_phi_wafer_vec
Definition: PixelID.h:307
MultiRange.h
PixelID::layer_disk_max
int layer_disk_max(const Identifier &id) const
Max/Min values for each field (error returns -999)
Definition: PixelID.cxx:61
IdDictDictionary
Definition: IdDictDictionary.h:30
PixelID::get_id
virtual int get_id(const IdentifierHash &hash_id, Identifier &id, const IdContext *context=0) const override final
Create compact id from hash id (return == 0 for OK)
Definition: PixelID.cxx:876
IdDictFieldImplementation.h
PixelID::is_eta_module_max
bool is_eta_module_max(const Identifier &id) const
For the barrel.
Definition: PixelID.cxx:119
PixelID::const_expanded_id_iterator
MultiRange::const_identifier_factory const_expanded_id_iterator
Definition: PixelID.h:73
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:608
PixelID::m_pixel_region_index
size_type m_pixel_region_index
Definition: PixelID.h:289
PixelID::eta_module_min
int eta_module_min(const Identifier &id) const
Definition: PixelID.cxx:96
PixelID::NOT_VALID_HASH
@ NOT_VALID_HASH
Definition: PixelID.h:259
PixelID::id_vec
std::vector< Identifier > id_vec
Definition: PixelID.h:264
PixelID::pixel_context
IdContext pixel_context() const
Definition: PixelID.h:594
PixelID::wafer_id_checks
void wafer_id_checks(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
Definition: PixelID.cxx:30
PixelID::wafer_end
const_id_iterator wafer_end() const
Definition: PixelID.cxx:846
PixelID::helper
virtual AtlasDetectorID::HelperType helper() const override
THis is a PixelID helper.
Definition: PixelID.h:82
copySelective.target
string target
Definition: copySelective.py:36
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
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:428
PixelID::m_eta_index_impl
IdDictFieldImplementation m_eta_index_impl
Definition: PixelID.h:323
PixelID::m_phi_mod_impl
IdDictFieldImplementation m_phi_mod_impl
Definition: PixelID.h:316
CLASS_DEF
#define CLASS_DEF(NAME, CID, VERSION)
associate a clid and a version to a type eg
Definition: Control/AthenaKernel/AthenaKernel/CLASS_DEF.h:67
PixelID::m_barrel_field
Range::field m_barrel_field
Definition: PixelID.h:305
PixelID::is_phi_module_max
bool is_phi_module_max(const Identifier &id) const
To check for when phi wrap around may be needed.
Definition: PixelID.cxx:180
IdentifierField
This is the individual specification for the range of one ExpandedIdentifier IdentifierField.
Definition: IdentifierField.h:83
PixelID::m_lay_disk_shift_impl
IdDictFieldImplementation m_lay_disk_shift_impl
Definition: PixelID.h:319
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
PixelID::wafer_begin
const_id_iterator wafer_begin() const
Iterators over full set of ids. Wafer iterator is sorted.
Definition: PixelID.cxx:842
PixelID::m_prev_eta_wafer_vec
hash_vec m_prev_eta_wafer_vec
Definition: PixelID.h:309
PixelID::m_LAYER_DISK_INDEX
size_type m_LAYER_DISK_INDEX
Definition: PixelID.h:293
Identifier::value_type
unsigned long long value_type
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:27
PixelID::size_type
Identifier::size_type size_type
Definition: PixelID.h:71
Identifier::size_type
unsigned long long size_type
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:29
IdDictFieldImplementation
IdDictFieldImplementation is used to capture the specification of a single field of an Identifier.
Definition: IdDictFieldImplementation.h:58
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
PixelID::m_PHI_MODULE_INDEX
size_type m_PHI_MODULE_INDEX
Definition: PixelID.h:294
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition: PixelID.h:640
PixelID
Definition: PixelID.h:67
value_type
Definition: EDM_MasterSearch.h:11
PixelID::m_lay_disk_impl
IdDictFieldImplementation m_lay_disk_impl
Definition: PixelID.h:315
AtlasDetectorID::do_checks
virtual bool do_checks(void) const override
Checks are performed by default in debug compilation and NOT in optimized compilation.
Definition: AtlasDetectorID.cxx:471
PixelID::m_dict
const IdDictDictionary * m_dict
Definition: PixelID.h:300
Identifier32.h
IdContext
This class saves the "context" of an expanded identifier (ExpandedIdentifier) for compact or hash ver...
Definition: IdContext.h:26
CLASS_DEF.h
macros to associate a CLID to a type
PixelID::get_prev_in_eta
int get_prev_in_eta(const IdentifierHash &id, IdentifierHash &prev) const
Previous wafer hash in eta (return == 0 for neighbor found)
Definition: PixelID.cxx:441
PixelID::id_vec_it
id_vec::const_iterator id_vec_it
Definition: PixelID.h:265
AtlasDetectorID
This class provides an interface to generate or decode an identifier for the upper levels of the dete...
Definition: AtlasDetectorID.h:52
PixelID::pixel_id_from_shortened
Identifier pixel_id_from_shortened(Identifier32::value_type val) const
Create a compact pixel id from a (fixed format) legacy pixel channel id.
Definition: PixelID.h:542
Identifier32::value_type
unsigned int value_type
Definition: Identifier32.h:28
PixelID::m_pixel_impl
IdDictFieldImplementation m_pixel_impl
Definition: PixelID.h:313
PixelID::hash_vec
std::vector< unsigned short > hash_vec
Definition: PixelID.h:266
PixelID::m_PHI_INDEX_INDEX
size_type m_PHI_INDEX_INDEX
Definition: PixelID.h:296
Identifier
Definition: IdentifierFieldParser.cxx:14