ATLAS Offline Software
CaloDM_ID.h
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #ifndef CALODM_ID_H
6 #define CALODM_ID_H
7 
8 #include "AthenaKernel/CLASS_DEF.h"
9 #include "AtlasDetDescr/AtlasDetectorID.h"
10 #include "Identifier/IdentifierHash.h"
11 #include "Identifier/MultiRange.h"
12 #include "IdDict/IdDictFieldImplementation.h"
13 
14 #include "CaloIdentifier/CaloID_Exception.h"
15 
16 #include <vector>
17 #include <algorithm>
18 
19 
99 class IdentifierHash;
100 
101 class CaloDM_ID : public AtlasDetectorID
102 {
103 public:
104 
105  typedef Identifier::size_type size_type ;
106 
107 
108  CaloDM_ID(void);
109 
110  virtual ~CaloDM_ID();
111 
113  Identifier region_id ( int pos_neg_z, int dmat, int sampling, int region ) const;
114  Identifier region_id ( int pos_neg_z, int dmat, int sampling, int region, bool checks) const;
115 
117  Identifier region_id (const Identifier& zoneId ) const;
118 
120  Identifier zone_id (int pos_neg_z, int dat, int sampling, int region,
121  int eta, int phi ) const;
122  Identifier zone_id (int pos_neg_z, int dat, int sampling, int region,
123  int eta, int phi, bool checks ) const;
124 
126  Identifier zone_id (const Identifier& regionId,
127  int eta, int phi ) const ;
128  Identifier zone_id (const Identifier& regionId,
129  int eta, int phi, bool checks ) const ;
130 
132  bool is_lar (const Identifier& zoneId) const;
134  bool is_tile (const Identifier& zoneId) const;
135 
137  Identifier lar_region_id (IdentifierHash lar_region_hash_id) const;
139  Identifier tile_region_id (IdentifierHash tile_region_hash_id) const;
140 
142  Identifier lar_zone_id (IdentifierHash lar_zone_hash_id) const;
144  Identifier tile_zone_id (IdentifierHash tile_zone_hash_id) const;
145 
147  IdentifierHash lar_region_hash (Identifier LArRegionId) const;
149  IdentifierHash tile_region_hash (Identifier TileRegionId) const;
150 
152  IdentifierHash lar_zone_hash (Identifier LArZoneId) const;
154  IdentifierHash tile_zone_hash (Identifier TileZoneId) const;
155 
156 
158  size_type lar_region_hash_max (void) const;
160  size_type lar_zone_hash_max (void) const;
162  size_type tile_region_hash_max (void) const;
164  size_type tile_zone_hash_max (void) const;
165 
167  std::vector<Identifier>::const_iterator lar_region_begin (void) const;
169  std::vector<Identifier>::const_iterator lar_region_end (void) const;
171  std::vector<Identifier>::const_iterator tile_region_begin (void) const;
173  std::vector<Identifier>::const_iterator tile_region_end (void) const;
174 
176  std::vector<Identifier>::const_iterator lar_zone_begin (void) const;
178  std::vector<Identifier>::const_iterator lar_zone_end (void) const;
180  std::vector<Identifier>::const_iterator tile_zone_begin (void) const;
182  std::vector<Identifier>::const_iterator tile_zone_end (void) const;
183 
184 
198  int pos_neg_z (const Identifier& id)const;
199 
213  int dmat (const Identifier& id)const;
214 
228  int sampling (const Identifier& id)const;
229 
248  int region (const Identifier& id)const;
249 
254  int eta (const Identifier& id)const;
255 
260  int phi (const Identifier& id)const;
261 
262 
263 
266  int eta_min(const Identifier& id) const;
269  int eta_max(const Identifier& id) const;
272  int phi_min(const Identifier& id) const;
275  int phi_max(const Identifier& id) const;
276 
277 
279  virtual int initialize_from_dictionary (const IdDictMgr& dict_mgr);
280 
282  IdContext region_context (void) const;
283 
285  IdContext zone_context (void) const;
286 
287 
288 private:
289 
290 
291  enum {NOT_VALID_HASH = 128000};
292 
293 
294  IdentifierHash lar_zone_hash_binary_search (Identifier zoneId) const;
295  IdentifierHash tile_zone_hash_binary_search (Identifier zoneId) const;
296 
298  int get_expanded_id (const Identifier& id, ExpandedIdentifier& exp_id, const IdContext* context) const;
299 
300 
301  void lar_region_id_checks ( int pos_neg_z, int dmat, int sampling, int region ) const;
302 
303  void tile_region_id_checks ( int pos_neg_z, int dmat, int sampling, int region ) const;
304 
305  void lar_zone_id_checks (int pos_neg_z, int dat, int sampling, int region,
306  int eta, int phi ) const;
307  void tile_zone_id_checks (int pos_neg_z, int dat, int sampling, int region,
308  int eta, int phi ) const;
309  void zone_id_checks (const Identifier& regionId,
310  int eta, int phi ) const;
311 
312 
313 
314  int initLevelsFromDict(void) ;
315 
316  int init_lar_hashes(void) ;
317  int init_tile_hashes(void) ;
318 
319 
320  size_type m_calodm_region_index;
321  size_type m_CALO_INDEX;
322  size_type m_DETZSIDE_INDEX;
323  size_type m_DMAT_INDEX;
324  size_type m_SAMPLING_INDEX;
325  size_type m_REGION_INDEX;
326  size_type m_ETA_INDEX;
327  size_type m_PHI_INDEX;
328 
329  const IdDictDictionary* m_dict;
330 
331  MultiRange m_full_lar_region_range;
332  MultiRange m_full_lar_zone_range;
333  size_type m_lar_zone_hash_max;
334  size_type m_lar_region_hash_max;
335  std::vector<Identifier> m_lar_zone_vec;
336  std::vector<Identifier> m_lar_region_vec;
337 
338  MultiRange m_full_tile_region_range;
339  MultiRange m_full_tile_zone_range;
340  size_type m_tile_zone_hash_max;
341  size_type m_tile_region_hash_max;
342  std::vector<Identifier> m_tile_zone_vec;
343  std::vector<Identifier> m_tile_region_vec;
344 
350  class HashCalc
351  {
352  public:
353  HashCalc() :
354  m_hash(0),
355  m_etamin(0),
356  m_nphi(0) {}
357  IdentifierHash m_hash;
358  size_type m_etamin;
359  size_type m_nphi;
360  };
361 
362  std::vector<HashCalc> m_lar_hash_calcs;
363  std::vector<HashCalc> m_tile_hash_calcs;
364 
365 
366 
367  IdDictFieldImplementation m_calo_impl;
368  IdDictFieldImplementation m_calodm_impl;
369  IdDictFieldImplementation m_dmat_impl;
370  IdDictFieldImplementation m_sampling_impl;
371  IdDictFieldImplementation m_region_impl;
372  IdDictFieldImplementation m_eta_impl;
373  IdDictFieldImplementation m_phi_impl;
374 
375 
376  IdDictFieldImplementation m_pnz_reg_impl;
377 
378 };
379 
380 //using the macros below we can assign an identifier (and a version)
381 //This is required and checked at compile time when you try to record/retrieve
382 CLASS_DEF( CaloDM_ID , 167756483 , 1 )
383 
384 
385 //----------------------------------------------------------------------------
386 inline Identifier CaloDM_ID::region_id (int pos_neg_z, int dmat, int sampling, int region,
387  bool checks) const
388 {
389  Identifier result(0);
390  // Pack fields independently
391  m_calo_impl.pack (calo_field_value(), result);
392  m_calodm_impl.pack (pos_neg_z, result);
393  m_dmat_impl.pack (dmat, result);
394  m_sampling_impl.pack (sampling, result);
395  m_region_impl.pack (region, result);
396 
397  // Do checks
398  if(checks) {
399  if(abs(pos_neg_z) == 4) {
400  lar_region_id_checks( pos_neg_z, dmat, sampling, region);
401  } else
402  if(abs(pos_neg_z) == 5) {
403  tile_region_id_checks( pos_neg_z, dmat, sampling, region);
404  }
405  else
406  {
407  CaloID_Exception except("wrong value for pos_neg_z, only +-4 and +-5 allowed" , 99);
408  throw except ;
409  }
410  }
411 
412  return result;
413 }
414 
415 inline Identifier CaloDM_ID::region_id (int pos_neg_z, int dmat, int sampling, int region) const
416 {
417  return region_id (pos_neg_z, dmat, sampling, region, do_checks());
418 }
419 
420 //----------------------------------------------------------------------------
421 inline Identifier
422 CaloDM_ID::region_id ( const Identifier& zoneId ) const
423 {
424  Identifier result(zoneId);
425  // reset eta/phi
426  m_eta_impl.reset(result);
427  m_phi_impl.reset(result);
428  return (result);
429 }
430 
431 //----------------------------------------------------------------------------
432 inline Identifier CaloDM_ID::zone_id ( int pos_neg_z, int dmat, int sampling, int region,
433  int eta, int phi,
434  bool checks) const
435 {
436  Identifier result(0);
437  // Pack fields independently
438  m_calo_impl.pack (calo_field_value(), result);
439  m_calodm_impl.pack (pos_neg_z, result);
440  m_dmat_impl.pack (dmat, result);
441  m_sampling_impl.pack (sampling, result);
442  m_region_impl.pack (region, result);
443  m_eta_impl.pack (eta, result);
444  m_phi_impl.pack (phi, result);
445 
446  // Do checks
447  if(checks) {
448  if(abs(pos_neg_z) == 4) {
449  lar_zone_id_checks( pos_neg_z, dmat, sampling, region, eta, phi );
450  }
451  else if(abs(pos_neg_z) == 5) {
452  tile_zone_id_checks( pos_neg_z, dmat, sampling, region, eta, phi );
453  }
454  else {
455  CaloID_Exception except("wrong value for pos_neg_z, only +-4 and +-5 allowed" , 99);
456  throw except ;
457  }
458  }
459 
460  return result;
461 }
462 
463 inline Identifier CaloDM_ID::zone_id ( int pos_neg_z, int dmat, int sampling, int region,
464  int eta, int phi ) const
465 {
466  return zone_id (pos_neg_z, dmat, sampling, region, eta, phi, do_checks());
467 }
468 
469 //----------------------------------------------------------------------------
470 inline Identifier CaloDM_ID::zone_id ( const Identifier& regionId,
471  int eta, int phi, bool checks ) const
472 {
473  Identifier result(regionId);
474 
475  // Reset the fields and then set the values
476  m_eta_impl.reset (result);
477  m_phi_impl.reset (result);
478  m_eta_impl.pack (eta, result);
479  m_phi_impl.pack (phi, result);
480 
481  // Do checks
482  if(checks) {
483  zone_id_checks( regionId, eta, phi );
484  }
485 
486  return result;
487 }
488 
489 inline Identifier CaloDM_ID::zone_id ( const Identifier& regionId,
490  int eta, int phi ) const
491 {
492  return zone_id (regionId, eta, phi, do_checks());
493 }
494 
495 //----------------------------------------------------------------------------
496 inline bool CaloDM_ID::is_lar(const Identifier& zoneId) const
497 {
498  return ( abs(m_calodm_impl.unpack(zoneId)) == 4 );
499 }
500 
501 //----------------------------------------------------------------------------
502 inline bool CaloDM_ID::is_tile(const Identifier& zoneId) const
503 {
504  return ( abs(m_calodm_impl.unpack(zoneId)) == 5 );
505 }
506 
507 //----------------------------------------------------------------------------
508 inline Identifier CaloDM_ID::lar_region_id (IdentifierHash lar_region_hash_id) const
509 {
510  return(m_lar_region_vec[lar_region_hash_id]);
511 }
512 
513 //----------------------------------------------------------------------------
514 inline Identifier CaloDM_ID::tile_region_id (IdentifierHash tile_region_hash_id) const
515 {
516  return(m_tile_region_vec[tile_region_hash_id]);
517 }
518 
519 //----------------------------------------------------------------------------
520 inline Identifier CaloDM_ID::lar_zone_id (IdentifierHash lar_zone_hash_id) const
521 {
522  return(m_lar_zone_vec[lar_zone_hash_id]);
523 }
524 
525 //----------------------------------------------------------------------------
526 inline Identifier CaloDM_ID::tile_zone_id (IdentifierHash tile_zone_hash_id) const
527 {
528  return(m_tile_zone_vec[tile_zone_hash_id]);
529 }
530 
531 //----------------------------------------------------------------------------
532 inline IdentifierHash CaloDM_ID::lar_region_hash (Identifier LArRegionId) const
533 {
534  std::vector<Identifier>::const_iterator it = std::lower_bound(m_lar_region_vec.begin(),m_lar_region_vec.end(),LArRegionId);
535  if ( it != m_lar_region_vec.end() ){
536  return (it - m_lar_region_vec.begin());
537  }
538  return (0);
539 }
540 
541 //----------------------------------------------------------------------------
542 inline IdentifierHash CaloDM_ID::tile_region_hash (Identifier TileRegionId) const
543 {
544  std::vector<Identifier>::const_iterator it = std::lower_bound(m_tile_region_vec.begin(),m_tile_region_vec.end(),TileRegionId);
545  if ( it != m_tile_region_vec.end() ){
546  return (it - m_tile_region_vec.begin());
547  }
548  return (0);
549 }
550 
551 //----------------------------------------------------------------------------
552 inline IdentifierHash CaloDM_ID::lar_zone_hash (Identifier LArZoneId) const
553 {
554  const HashCalc& hc = m_lar_hash_calcs[m_pnz_reg_impl.unpack(LArZoneId)];
555  return (hc.m_hash + (eta(LArZoneId)-hc.m_etamin)*hc.m_nphi + phi(LArZoneId));
556 }
557 
558 //----------------------------------------------------------------------------
559 inline IdentifierHash CaloDM_ID::tile_zone_hash (Identifier TileZoneId) const
560 {
561  const HashCalc& hc = m_tile_hash_calcs[m_pnz_reg_impl.unpack(TileZoneId)];
562  return (hc.m_hash + (eta(TileZoneId)-hc.m_etamin)*hc.m_nphi + phi(TileZoneId));
563 }
564 
565 //----------------------------------------------------------------------------
566 inline CaloDM_ID::size_type CaloDM_ID::lar_region_hash_max (void) const
567 {
568  return m_lar_region_hash_max;
569 }
570 
571 //----------------------------------------------------------------------------
572 inline CaloDM_ID::size_type CaloDM_ID::lar_zone_hash_max (void) const
573 {
574  return m_lar_zone_hash_max;
575 }
576 
577 //----------------------------------------------------------------------------
578 inline CaloDM_ID::size_type CaloDM_ID::tile_region_hash_max (void) const
579 {
580  return m_tile_region_hash_max;
581 }
582 
583 //----------------------------------------------------------------------------
584 inline CaloDM_ID::size_type CaloDM_ID::tile_zone_hash_max (void) const
585 {
586  return m_tile_zone_hash_max;
587 }
588 
589 //----------------------------------------------------------------------------
590 inline std::vector<Identifier>::const_iterator CaloDM_ID::lar_region_begin (void) const
591 {
592  return(m_lar_region_vec.begin());
593 }
594 
595 //----------------------------------------------------------------------------
596 inline std::vector<Identifier>::const_iterator CaloDM_ID::lar_region_end (void) const
597 {
598  return(m_lar_region_vec.end());
599 }
600 
601 //----------------------------------------------------------------------------
602 inline std::vector<Identifier>::const_iterator CaloDM_ID::lar_zone_begin (void) const
603 {
604  return(m_lar_zone_vec.begin());
605 }
606 
607 //----------------------------------------------------------------------------
608 inline std::vector<Identifier>::const_iterator CaloDM_ID::lar_zone_end (void) const
609 {
610  return(m_lar_zone_vec.end());
611 }
612 
613 //----------------------------------------------------------------------------
614 inline std::vector<Identifier>::const_iterator CaloDM_ID::tile_region_begin (void) const
615 {
616  return(m_tile_region_vec.begin());
617 }
618 
619 //----------------------------------------------------------------------------
620 inline std::vector<Identifier>::const_iterator CaloDM_ID::tile_region_end (void) const
621 {
622  return(m_tile_region_vec.end());
623 }
624 
625 
626 //----------------------------------------------------------------------------
627 inline std::vector<Identifier>::const_iterator CaloDM_ID::tile_zone_begin (void) const
628 {
629  return(m_tile_zone_vec.begin());
630 }
631 
632 //----------------------------------------------------------------------------
633 inline std::vector<Identifier>::const_iterator CaloDM_ID::tile_zone_end (void) const
634 {
635  return(m_tile_zone_vec.end());
636 }
637 
638 //----------------------------------------------------------------------------
639 inline int CaloDM_ID::pos_neg_z(const Identifier& id) const
640 {
641  return (m_calodm_impl.unpack(id));
642 }
643 
644 //----------------------------------------------------------------------------
645 inline int CaloDM_ID::sampling(const Identifier& id) const
646 {
647  return (m_sampling_impl.unpack(id));
648 }
649 
650 //----------------------------------------------------------------------------
651 inline int CaloDM_ID::region(const Identifier& id) const
652 {
653  return (m_region_impl.unpack(id));
654 }
655 
656 //----------------------------------------------------------------------------
657 inline int CaloDM_ID::eta(const Identifier& id) const
658 {
659  return (m_eta_impl.unpack(id));
660 }
661 
662 //----------------------------------------------------------------------------
663 inline int CaloDM_ID::phi(const Identifier& id) const
664 {
665  return (m_phi_impl.unpack(id));
666 }
667 
668 //----------------------------------------------------------------------------
669 inline int CaloDM_ID::dmat(const Identifier& id) const
670 {
671  return (m_dmat_impl.unpack(id));
672 }
673 
674 //----------------------------------------------------------------------------
675 inline IdentifierHash CaloDM_ID::lar_zone_hash_binary_search (Identifier zoneId) const
676 {
677  std::vector<Identifier>::const_iterator it = std::lower_bound(m_lar_zone_vec.begin(),m_lar_zone_vec.end(),zoneId);
678  if ( it != m_lar_zone_vec.end() ){
679  return (it - m_lar_zone_vec.begin());
680  }
681  return (0);
682 }
683 
684 //----------------------------------------------------------------------------
685 inline IdentifierHash CaloDM_ID::tile_zone_hash_binary_search (Identifier zoneId) const
686 {
687  std::vector<Identifier>::const_iterator it = std::lower_bound(m_tile_zone_vec.begin(),m_tile_zone_vec.end(),zoneId);
688  if ( it != m_tile_zone_vec.end() ){
689  return (it - m_tile_zone_vec.begin());
690  }
691  return (0);
692 }
693 
694 #endif // CALODM_ID_H
CaloDM_ID::phi_min
int phi_min(const Identifier &id) const
min value of phi index (-999 == failure)
Definition: CaloDM_ID.cxx:107
CaloDM_ID::m_DMAT_INDEX
size_type m_DMAT_INDEX
Definition: CaloDM_ID.h:323
CaloDM_ID::tile_region_end
std::vector< Identifier >::const_iterator tile_region_end(void) const
end iterator over tile regions
Definition: CaloDM_ID.h:620
CaloDM_ID::region_context
IdContext region_context(void) const
access to IdContext's which define which levels of fields are contained in a region id
Definition: CaloDM_ID.cxx:529
CaloDM_ID::dmat
int dmat(const Identifier &id) const
return DMtype according to :
Definition: CaloDM_ID.h:669
CaloDM_ID::m_SAMPLING_INDEX
size_type m_SAMPLING_INDEX
Definition: CaloDM_ID.h:324
CaloDM_ID::m_full_tile_region_range
MultiRange m_full_tile_region_range
Definition: CaloDM_ID.h:338
CaloDM_ID::lar_region_begin
std::vector< Identifier >::const_iterator lar_region_begin(void) const
begin iterator over lar regions
Definition: CaloDM_ID.h:590
get_generator_info.result
result
Definition: get_generator_info.py:21
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
CaloDM_ID::HashCalc::m_nphi
size_type m_nphi
Definition: CaloDM_ID.h:359
CaloDM_ID::lar_region_hash_max
size_type lar_region_hash_max(void) const
lar region hash table max size
Definition: CaloDM_ID.h:566
CaloID_Exception
Exception class for Calo Identifiers.
Definition: CaloID_Exception.h:20
CaloDM_ID::lar_zone_hash_max
size_type lar_zone_hash_max(void) const
lar zone hash table max size
Definition: CaloDM_ID.h:572
CaloDM_ID::m_CALO_INDEX
size_type m_CALO_INDEX
Definition: CaloDM_ID.h:321
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
CaloDM_ID::tile_region_id_checks
void tile_region_id_checks(int pos_neg_z, int dmat, int sampling, int region) const
Definition: CaloDM_ID.cxx:556
CaloDM_ID::m_REGION_INDEX
size_type m_REGION_INDEX
Definition: CaloDM_ID.h:325
CaloDM_ID::m_DETZSIDE_INDEX
size_type m_DETZSIDE_INDEX
Definition: CaloDM_ID.h:322
CaloDM_ID::tile_region_id
Identifier tile_region_id(IdentifierHash tile_region_hash_id) const
create a tile region id from hash id
Definition: CaloDM_ID.h:514
CaloDM_ID::region
int region(const Identifier &id) const
return region according to :
Definition: CaloDM_ID.h:651
AtlasDetectorID::calo_field_value
int calo_field_value() const
Definition: AtlasDetectorID.h:623
CaloDM_ID::m_ETA_INDEX
size_type m_ETA_INDEX
Definition: CaloDM_ID.h:326
CaloDM_ID::lar_region_hash
IdentifierHash lar_region_hash(Identifier LArRegionId) const
create a lar hash id from region id
Definition: CaloDM_ID.h:532
CaloDM_ID::tile_zone_id
Identifier tile_zone_id(IdentifierHash tile_zone_hash_id) const
create a tile zone id from hash id
Definition: CaloDM_ID.h:526
skel.it
it
Definition: skel.GENtoEVGEN.py:396
ExpandedIdentifier
Definition: DetectorDescription/Identifier/Identifier/ExpandedIdentifier.h:102
CaloDM_ID::~CaloDM_ID
virtual ~CaloDM_ID()
CaloDM_ID::eta_min
int eta_min(const Identifier &id) const
min value of eta index (-999 == failure)
Definition: CaloDM_ID.cxx:46
IdDictFieldImplementation::pack
void pack(int value, Identifier &id) const
Definition: IdDictFieldImplementation.h:173
CaloDM_ID::HashCalc::m_hash
IdentifierHash m_hash
Definition: CaloDM_ID.h:357
CaloDM_ID::lar_zone_hash_binary_search
IdentifierHash lar_zone_hash_binary_search(Identifier zoneId) const
Definition: CaloDM_ID.h:675
CaloDM_ID::m_lar_region_hash_max
size_type m_lar_region_hash_max
Definition: CaloDM_ID.h:334
CaloDM_ID::m_dict
const IdDictDictionary * m_dict
Definition: CaloDM_ID.h:329
CaloDM_ID::m_tile_zone_vec
std::vector< Identifier > m_tile_zone_vec
Definition: CaloDM_ID.h:342
CaloDM_ID::HashCalc::m_etamin
size_type m_etamin
Definition: CaloDM_ID.h:358
IdDictFieldImplementation::unpack
int unpack(Identifier id) const
Identifier manipulation methods.
Definition: IdDictFieldImplementation.h:147
CaloDM_ID::m_lar_region_vec
std::vector< Identifier > m_lar_region_vec
Definition: CaloDM_ID.h:336
CalibDbCompareRT.region_id
region_id
Definition: CalibDbCompareRT.py:68
IdDictFieldImplementation::reset
void reset(Identifier &id) const
Definition: IdDictFieldImplementation.h:183
CaloDM_ID::tile_zone_end
std::vector< Identifier >::const_iterator tile_zone_end(void) const
end iterator over full set of Tile identifiers
Definition: CaloDM_ID.h:633
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
CaloDM_ID::lar_region_id_checks
void lar_region_id_checks(int pos_neg_z, int dmat, int sampling, int region) const
Definition: CaloDM_ID.cxx:543
CaloDM_ID::m_full_tile_zone_range
MultiRange m_full_tile_zone_range
Definition: CaloDM_ID.h:339
CaloDM_ID::tile_region_hash_max
size_type tile_region_hash_max(void) const
tile region hash table max size
Definition: CaloDM_ID.h:578
CaloDM_ID::m_calo_impl
IdDictFieldImplementation m_calo_impl
Definition: CaloDM_ID.h:367
CaloDM_ID::m_full_lar_region_range
MultiRange m_full_lar_region_range
Definition: CaloDM_ID.h:331
CaloDM_ID::zone_context
IdContext zone_context(void) const
access to IdContext's which define which levels of fields are contained in a zone id
Definition: CaloDM_ID.cxx:536
CaloDM_ID::pos_neg_z
int pos_neg_z(const Identifier &id) const
return pos_neg_z according to :
Definition: CaloDM_ID.h:639
CaloDM_ID::m_lar_hash_calcs
std::vector< HashCalc > m_lar_hash_calcs
Definition: CaloDM_ID.h:362
CaloDM_ID::m_eta_impl
IdDictFieldImplementation m_eta_impl
Definition: CaloDM_ID.h:372
CaloDM_ID::is_lar
bool is_lar(const Identifier &zoneId) const
to disentangle between LAr and Tile dead material
Definition: CaloDM_ID.h:496
CaloDM_ID::tile_zone_hash
IdentifierHash tile_zone_hash(Identifier TileZoneId) const
create a tile hash id from zone id
Definition: CaloDM_ID.h:559
CaloDM_ID::m_lar_zone_vec
std::vector< Identifier > m_lar_zone_vec
Definition: CaloDM_ID.h:335
CaloDM_ID::HashCalc
small class holding the starting hash value, the min eta and the number of phi bins of each region
Definition: CaloDM_ID.h:351
CaloDM_ID::m_calodm_impl
IdDictFieldImplementation m_calodm_impl
Definition: CaloDM_ID.h:368
CaloDM_ID::lar_region_end
std::vector< Identifier >::const_iterator lar_region_end(void) const
end iterator over lar regions
Definition: CaloDM_ID.h:596
CaloDM_ID::size_type
Identifier::size_type size_type
Definition: CaloDM_ID.h:105
CaloDM_ID::m_tile_region_hash_max
size_type m_tile_region_hash_max
Definition: CaloDM_ID.h:341
CaloDM_ID::m_phi_impl
IdDictFieldImplementation m_phi_impl
Definition: CaloDM_ID.h:373
CaloDM_ID::m_sampling_impl
IdDictFieldImplementation m_sampling_impl
Definition: CaloDM_ID.h:370
CaloDM_ID::m_tile_zone_hash_max
size_type m_tile_zone_hash_max
Definition: CaloDM_ID.h:340
CaloDM_ID::eta_max
int eta_max(const Identifier &id) const
max value of eta index (-999 == failure)
Definition: CaloDM_ID.cxx:79
CaloDM_ID::region_id
Identifier region_id(int pos_neg_z, int dmat, int sampling, int region) const
build a region identifier valid for both LAr and Tiles
Definition: CaloDM_ID.h:415
CaloDM_ID::init_lar_hashes
int init_lar_hashes(void)
Definition: CaloDM_ID.cxx:882
MultiRange
A MultiRange combines several Ranges.
Definition: MultiRange.h:17
CaloDM_ID::tile_zone_hash_binary_search
IdentifierHash tile_zone_hash_binary_search(Identifier zoneId) const
Definition: CaloDM_ID.h:685
IdentifierHash.h
CaloDM_ID::tile_region_begin
std::vector< Identifier >::const_iterator tile_region_begin(void) const
begin iterator over tile regions
Definition: CaloDM_ID.h:614
CaloDM_ID::tile_region_hash
IdentifierHash tile_region_hash(Identifier TileRegionId) const
create a tile hash id from region id
Definition: CaloDM_ID.h:542
CaloDM_ID::tile_zone_begin
std::vector< Identifier >::const_iterator tile_zone_begin(void) const
begin iterator over full set of Tile identifiers
Definition: CaloDM_ID.h:627
CaloDM_ID::sampling
int sampling(const Identifier &id) const
return sampling according to :
Definition: CaloDM_ID.h:645
MultiRange.h
CaloDM_ID::phi_max
int phi_max(const Identifier &id) const
max value of phi index (-999 == failure)
Definition: CaloDM_ID.cxx:140
IdDictDictionary
Definition: IdDictDictionary.h:30
IdDictFieldImplementation.h
CaloDM_ID::NOT_VALID_HASH
@ NOT_VALID_HASH
Definition: CaloDM_ID.h:291
CaloDM_ID::m_full_lar_zone_range
MultiRange m_full_lar_zone_range
Definition: CaloDM_ID.h:332
CaloDM_ID::lar_zone_hash
IdentifierHash lar_zone_hash(Identifier LArZoneId) const
create a lar hash id from zone id
Definition: CaloDM_ID.h:552
CaloDM_ID::eta
int eta(const Identifier &id) const
return eta
Definition: CaloDM_ID.h:657
CaloDM_ID::m_calodm_region_index
size_type m_calodm_region_index
Definition: CaloDM_ID.h:320
CaloDM_ID::m_region_impl
IdDictFieldImplementation m_region_impl
Definition: CaloDM_ID.h:371
CaloDM_ID::initialize_from_dictionary
virtual int initialize_from_dictionary(const IdDictMgr &dict_mgr)
initialization from the identifier dictionary
Definition: CaloDM_ID.cxx:170
CaloDM_ID::tile_zone_id_checks
void tile_zone_id_checks(int pos_neg_z, int dat, int sampling, int region, int eta, int phi) const
Definition: CaloDM_ID.cxx:585
CaloDM_ID::m_tile_hash_calcs
std::vector< HashCalc > m_tile_hash_calcs
Definition: CaloDM_ID.h:363
CaloDM_ID::m_dmat_impl
IdDictFieldImplementation m_dmat_impl
Definition: CaloDM_ID.h:369
CaloDM_ID::lar_zone_id
Identifier lar_zone_id(IdentifierHash lar_zone_hash_id) const
create a lar zone id from hash id
Definition: CaloDM_ID.h:520
CaloDM_ID
Helper class for Calo Dead Material offline identifiers.
Definition: CaloDM_ID.h:102
CaloDM_ID::phi
int phi(const Identifier &id) const
return phi
Definition: CaloDM_ID.h:663
CaloDM_ID::lar_zone_id_checks
void lar_zone_id_checks(int pos_neg_z, int dat, int sampling, int region, int eta, int phi) const
Definition: CaloDM_ID.cxx:571
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:64
CaloDM_ID::lar_zone_begin
std::vector< Identifier >::const_iterator lar_zone_begin(void) const
begin iterator over full set of LAr identifiers
Definition: CaloDM_ID.h:602
CaloDM_ID::get_expanded_id
int get_expanded_id(const Identifier &id, ExpandedIdentifier &exp_id, const IdContext *context) const
create expanded Identifier from Identifier (return == 0 for OK)
Definition: CaloDM_ID.cxx:510
CaloDM_ID::lar_region_id
Identifier lar_region_id(IdentifierHash lar_region_hash_id) const
create a lar region id from hash id
Definition: CaloDM_ID.h:508
CaloDM_ID::lar_zone_end
std::vector< Identifier >::const_iterator lar_zone_end(void) const
end iterator over full set of LAr identifiers
Definition: CaloDM_ID.h:608
CaloDM_ID::is_tile
bool is_tile(const Identifier &zoneId) const
to disentangle between LAr and Tile dead material
Definition: CaloDM_ID.h:502
CaloDM_ID::CaloDM_ID
CaloDM_ID(void)
Definition: CaloDM_ID.cxx:24
CaloDM_ID::m_lar_zone_hash_max
size_type m_lar_zone_hash_max
Definition: CaloDM_ID.h:333
CaloDM_ID::tile_zone_hash_max
size_type tile_zone_hash_max(void) const
tile zone hash table max size
Definition: CaloDM_ID.h:584
CaloDM_ID::initLevelsFromDict
int initLevelsFromDict(void)
Definition: CaloDM_ID.cxx:632
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
CaloDM_ID::m_PHI_INDEX
size_type m_PHI_INDEX
Definition: CaloDM_ID.h:327
CaloDM_ID::zone_id
Identifier zone_id(int pos_neg_z, int dat, int sampling, int region, int eta, int phi) const
build a zone identifier valid for both LAr and Tiles
Definition: CaloDM_ID.h:463
CaloID_Exception.h
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:728
IdContext
This class saves the "context" of an expanded identifier (ExpandedIdentifier) for compact or hash ver...
Definition: IdContext.h:26
CaloDM_ID::m_pnz_reg_impl
IdDictFieldImplementation m_pnz_reg_impl
Definition: CaloDM_ID.h:376
CLASS_DEF.h
macros to associate a CLID to a type
CaloDM_ID::m_tile_region_vec
std::vector< Identifier > m_tile_region_vec
Definition: CaloDM_ID.h:343
CaloDM_ID::zone_id_checks
void zone_id_checks(const Identifier &regionId, int eta, int phi) const
Definition: CaloDM_ID.cxx:600
AtlasDetectorID
This class provides an interface to generate or decode an identifier for the upper levels of the dete...
Definition: AtlasDetectorID.h:57
CaloDM_ID::init_tile_hashes
int init_tile_hashes(void)
Definition: CaloDM_ID.cxx:1025
CaloDM_ID::HashCalc::HashCalc
HashCalc()
Definition: CaloDM_ID.h:353
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sun Dec 22 2024 21:07:54 for ATLAS Offline Software by   doxygen 1.8.18