ATLAS Offline Software
CaloLVL1_ID.h
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #ifndef CALOLVL1_ID_H
6 #define CALOLVL1_ID_H
7 
8 #include "AthenaKernel/CLASS_DEF.h"
9 #include "AtlasDetDescr/AtlasDetectorID.h"
10 #include "Identifier/IdentifierHash.h"
11 #include "Identifier/Range.h"
12 #include "IdDict/IdDictFieldImplementation.h"
13 
14 #include "CaloIdentifier/CaloID_Exception.h"
15 
16 #include "boost/range/iterator_range.hpp"
17 #include <vector>
18 #include <algorithm>
19 
20 
63 class IdentifierHash;
64 
65 class CaloLVL1_ID : public AtlasDetectorID
66 {
67 public:
68 
69  typedef Identifier::size_type size_type ;
70 
71 
72  CaloLVL1_ID(void);
73 
74  virtual ~CaloLVL1_ID();
75 
77  Identifier tower_id (int pos_neg_z, int sampling, int region,
78  int eta, int phi ) const ;
79  Identifier tower_id (int pos_neg_z, int sampling, int region,
80  int eta, int phi, bool checks ) const ;
81 
83  Identifier tower_id (const Identifier regionId,
84  int eta, int phi ) const ;
85  Identifier tower_id (const Identifier regionId,
86  int eta, int phi, bool checks ) const ;
87 
89  Identifier tower_id (const Identifier layerId) const;
90 
92  Identifier region_id ( int pos_neg_z, int sampling, int region ) const;
93  Identifier region_id ( int pos_neg_z, int sampling, int region, bool checks) const;
94 
96  Identifier region_id ( const Identifier tower_or_layerId ) const;
97 
98 
100  Identifier layer_id ( int pos_neg_z, int sampling, int region,
101  int eta, int phi, int layer ) const;
102  Identifier layer_id ( int pos_neg_z, int sampling, int region,
103  int eta, int phi, int layer,
104  bool checks) const;
105 
107  Identifier layer_id ( const Identifier towerId, int layer ) const;
108  Identifier layer_id ( const Identifier towerId, int layer, bool checks ) const;
109 
110 
113  IdContext region_context (void) const;
114 
117  IdContext tower_context (void) const;
118 
121  IdContext layer_context (void) const;
122 
124  virtual int get_id (const IdentifierHash& hash_id, Identifier& id, const IdContext* context = 0 ) const;
125 
127  virtual int get_hash (const Identifier& id, IdentifierHash& hash_id, const IdContext* context = 0 ) const;
128 
130  Identifier region_id (IdentifierHash region_hash_id) const;
131 
133  Identifier tower_id (IdentifierHash tower_hash_id) const;
134 
136  IdentifierHash tower_hash (Identifier towerId) const;
138  IdentifierHash tower_hash_binary_search (Identifier towerId) const;
139 
141  virtual int initialize_from_dictionary (const IdDictMgr& dict_mgr);
142 
144  size_type tower_hash_max (void) const;
146  size_type layer_hash_max (void) const;
148  size_type region_hash_max (void) const;
149 
150 
152  typedef std::vector<Identifier>::const_iterator id_iterator;
154  typedef boost::iterator_range<id_iterator> id_range;
155 
156 
158  id_iterator region_begin () const;
160  id_iterator region_end () const;
162  id_range region_range () const;
163 
165  id_iterator tower_begin () const;
167  id_iterator tower_end () const;
169  id_range tower_range () const;
170 
172  id_iterator layer_begin () const;
174  id_iterator layer_end () const;
176  id_range layer_range () const;
177 
180  bool is_tile (const Identifier id) const;
184  bool is_emb (const Identifier id) const;
187  bool is_barrel_end (const Identifier id) const;
190  bool is_emec (const Identifier id) const;
193  bool is_hec (const Identifier id) const;
196  bool is_fcal (const Identifier id) const;
197 
210  int pos_neg_z (const Identifier id)const;
211 
225  int sampling (const Identifier id)const;
226 
239  int region (const Identifier id)const;
240 
256  int eta (const Identifier id)const;
257 
273  int phi (const Identifier id)const;
274 
288  int layer (const Identifier id)const;
289 
290 
293  int eta_min(const Identifier regId) const;
296  int eta_max(const Identifier regId) const;
299  int phi_max(const Identifier regId) const;
302  int layer_max(const Identifier regId) const;
303 
306  int get_prev_in_phi(const IdentifierHash& id, IdentifierHash& prev) const;
309  int get_next_in_phi(const IdentifierHash& id, IdentifierHash& next) const;
312  int get_prev_in_eta(const IdentifierHash& id, IdentifierHash& prev) const;
315  int get_next_in_eta(const IdentifierHash& id, IdentifierHash& next) const;
316 
317 private:
318 
319 
320  enum {NOT_VALID_HASH = 64000};
321 
322 
324  int get_expanded_id (const Identifier& id, ExpandedIdentifier& exp_id, const IdContext* context) const;
325 
326 
327  void tower_id_checks (int pos_neg_z, int sampling, int region,
328  int eta, int phi ) const;
329  void tower_id_checks (const Identifier regionId,
330  int eta, int phi ) const;
331  void region_id_checks ( int pos_neg_z, int sampling, int region ) const;
332 
333  void layer_id_checks ( int pos_neg_z, int sampling, int region,
334  int eta, int phi, int layer ) const;
335  void layer_id_checks ( const Identifier towerId,
336  int layer ) const;
337 
338 
339  int initLevelsFromDict(void) ;
340 
341  int init_hashes(void) ;
342 
343  int init_neighbors(void) ;
344 
345 
346  size_type m_lvl1_region_index;
347  size_type m_CALO_INDEX;
348  size_type m_DETZSIDE_INDEX;
349  size_type m_SAMPLING_INDEX;
350  size_type m_REGION_INDEX;
351  size_type m_ETA_INDEX;
352  size_type m_PHI_INDEX;
353  size_type m_LAYER_INDEX;
354 
355  const IdDictDictionary* m_dict;
356 
357  MultiRange m_full_region_range;
358  MultiRange m_full_tower_range;
359  MultiRange m_full_layer_range;
360  size_type m_tower_hash_max;
361  size_type m_layer_hash_max;
362  size_type m_region_hash_max;
363  std::vector<Identifier> m_tower_vec;
364  std::vector<Identifier> m_layer_vec;
365  std::vector<Identifier> m_region_vec;
366  std::vector<unsigned short> m_prev_phi_vec;
367  std::vector<unsigned short> m_next_phi_vec;
368  std::vector<unsigned short> m_prev_eta_vec;
369  std::vector<unsigned short> m_next_eta_vec;
370 
376  class HashCalc
377  {
378  public:
379  HashCalc() :
380  m_hash(0),
381  m_etamin(0),
382  m_nphi(0) {}
383  IdentifierHash m_hash;
384  size_type m_etamin;
385  size_type m_nphi;
386  };
387  std::vector<HashCalc> m_hash_calcs;
388 
389 
390 
391  IdDictFieldImplementation m_calo_impl;
392  IdDictFieldImplementation m_lvl1_impl;
393  IdDictFieldImplementation m_sampling_impl;
394  IdDictFieldImplementation m_region_impl;
395  IdDictFieldImplementation m_eta_impl;
396  IdDictFieldImplementation m_phi_impl;
397  IdDictFieldImplementation m_layer_impl;
398 
399  IdDictFieldImplementation m_pnz_reg_impl;
400 
401 };
402 
403 //using the macros below we can assign an identifier (and a version)
404 //This is required and checked at compile time when you try to record/retrieve
405 CLASS_DEF( CaloLVL1_ID , 108133391 , 1 )
406 
407 
408 //----------------------------------------------------------------------------
409 inline Identifier CaloLVL1_ID::tower_id ( int pos_neg_z, int sampling, int region,
410  int eta, int phi, bool checks ) const
411 {
412  Identifier result(0);
413  // Pack fields independently
414  m_calo_impl.pack (calo_field_value(), result);
415  m_lvl1_impl.pack (pos_neg_z, result);
416  m_sampling_impl.pack (sampling, result);
417  m_region_impl.pack (region, result);
418  m_eta_impl.pack (eta, result);
419  m_phi_impl.pack (phi, result);
420 
421  // Do checks
422  if(checks) {
423  tower_id_checks( pos_neg_z, sampling, region, eta, phi );
424  }
425 
426  return result;
427 }
428 
429 inline Identifier CaloLVL1_ID::tower_id ( int pos_neg_z, int sampling, int region,
430  int eta, int phi ) const
431 {
432  return tower_id (pos_neg_z, sampling, region, eta, phi, do_checks());
433 }
434 
435 
436 //----------------------------------------------------------------------------
437 inline Identifier CaloLVL1_ID::tower_id ( const Identifier regionId,
438  int eta, int phi, bool checks ) const
439 {
440  Identifier result(regionId);
441 
442  // Reset the fields and then set the values
443  m_eta_impl.reset (result);
444  m_phi_impl.reset (result);
445  m_eta_impl.pack (eta, result);
446  m_phi_impl.pack (phi, result);
447 
448  // Do checks
449  if(checks) {
450  tower_id_checks( regionId, eta, phi );
451  }
452 
453  return result;
454 }
455 
456 inline Identifier CaloLVL1_ID::tower_id ( const Identifier regionId,
457  int eta, int phi ) const
458 {
459  return tower_id (regionId, eta, phi, do_checks());
460 }
461 
462 
463 //----------------------------------------------------------------------------
464 inline Identifier CaloLVL1_ID::region_id ( const Identifier tower_or_layerId ) const
465 {
466  Identifier result(tower_or_layerId);
467  // reset eta, phi, layer
468  m_eta_impl.reset(result);
469  m_phi_impl.reset(result);
470  m_layer_impl.reset(result);
471  return (result);
472 }
473 
474 //----------------------------------------------------------------------------
475 inline Identifier CaloLVL1_ID::tower_id ( const Identifier layerId ) const
476 {
477  Identifier result(layerId);
478  // reset layer
479  m_layer_impl.reset(result);
480  return (result);
481 }
482 
483 //----------------------------------------------------------------------------
484 inline Identifier CaloLVL1_ID::region_id (int pos_neg_z, int sampling, int region,
485  bool checks)const
486 {
487  Identifier result(0);
488  // Pack fields independently
489  m_calo_impl.pack (calo_field_value(), result);
490  m_lvl1_impl.pack (pos_neg_z, result);
491  m_sampling_impl.pack (sampling, result);
492  m_region_impl.pack (region, result);
493 
494  // Do checks
495  if(checks) {
496  region_id_checks( pos_neg_z, sampling, region);
497  }
498 
499  return result;
500 }
501 
502 inline Identifier CaloLVL1_ID::region_id (int pos_neg_z, int sampling, int region)const
503 {
504  return region_id (pos_neg_z, sampling, region, do_checks());
505 }
506 
507 //----------------------------------------------------------------------------
508 inline Identifier CaloLVL1_ID::layer_id ( int pos_neg_z, int sampling, int region,
509  int eta, int phi, int layer,
510  bool checks) const
511 {
512  Identifier result(0);
513  // Pack fields independently
514  m_calo_impl.pack (calo_field_value(), result);
515  m_lvl1_impl.pack (pos_neg_z, result);
516  m_sampling_impl.pack (sampling, result);
517  m_region_impl.pack (region, result);
518  m_eta_impl.pack (eta, result);
519  m_phi_impl.pack (phi, result);
520  m_layer_impl.pack (layer, result);
521 
522  // Do checks
523  if(checks) {
524  layer_id_checks( pos_neg_z, sampling, region, eta, phi, layer );
525  }
526 
527  return result;
528 }
529 
530 inline Identifier CaloLVL1_ID::layer_id ( int pos_neg_z, int sampling, int region,
531  int eta, int phi, int layer ) const
532 {
533  return layer_id (pos_neg_z, sampling, region, eta, phi, layer, do_checks());
534 }
535 
536 //----------------------------------------------------------------------------
537 inline Identifier CaloLVL1_ID::layer_id ( const Identifier towerId,
538  int layer, bool checks ) const
539 {
540  Identifier result(towerId);
541 
542  // Reset the fields and then set the values
543  m_layer_impl.reset (result);
544  m_layer_impl.pack (layer, result);
545  // Do checks
546  if(checks) {
547  layer_id_checks( towerId, layer );
548  }
549 
550  return result;
551 }
552 
553 inline Identifier CaloLVL1_ID::layer_id ( const Identifier towerId,
554  int layer ) const
555 {
556  return layer_id (towerId, layer, do_checks());
557 }
558 
559 //----------------------------------------------------------------------------
560 inline CaloLVL1_ID::size_type CaloLVL1_ID::tower_hash_max (void) const
561 {
562  return m_tower_hash_max;
563 }
564 
565 //----------------------------------------------------------------------------
566 inline CaloLVL1_ID::size_type CaloLVL1_ID::layer_hash_max (void) const
567 {
568  return m_layer_hash_max;
569 }
570 
571 //----------------------------------------------------------------------------
572 inline CaloLVL1_ID::size_type CaloLVL1_ID::region_hash_max (void) const
573 {
574  return m_region_hash_max;
575 }
576 
577 
578 //----------------------------------------------------------------------------
579 inline CaloLVL1_ID::id_iterator CaloLVL1_ID::region_begin (void) const
580 {
581  return(m_region_vec.begin());
582 }
583 
584 //----------------------------------------------------------------------------
585 inline CaloLVL1_ID::id_iterator CaloLVL1_ID::region_end (void) const
586 {
587  return(m_region_vec.end());
588 }
589 
590 //----------------------------------------------------------------------------
591 inline CaloLVL1_ID::id_range CaloLVL1_ID::region_range () const
592 {
593  return id_range (region_begin(), region_end());
594 }
595 
596 //----------------------------------------------------------------------------
597 inline CaloLVL1_ID::id_iterator CaloLVL1_ID::tower_begin (void) const
598 {
599  return(m_tower_vec.begin());
600 }
601 
602 //----------------------------------------------------------------------------
603 inline CaloLVL1_ID::id_iterator CaloLVL1_ID::tower_end (void) const
604 {
605  return(m_tower_vec.end());
606 }
607 
608 //----------------------------------------------------------------------------
609 inline CaloLVL1_ID::id_range CaloLVL1_ID::tower_range () const
610 {
611  return id_range (tower_begin(), tower_end());
612 }
613 
614 //----------------------------------------------------------------------------
615 
616 inline CaloLVL1_ID::id_iterator CaloLVL1_ID::layer_begin (void) const
617 {
618  return(m_layer_vec.begin());
619 }
620 
621 //----------------------------------------------------------------------------
622 inline CaloLVL1_ID::id_iterator CaloLVL1_ID::layer_end (void) const
623 {
624  return(m_layer_vec.end());
625 }
626 
627 
628 //----------------------------------------------------------------------------
629 inline CaloLVL1_ID::id_range CaloLVL1_ID::layer_range () const
630 {
631  return id_range (layer_begin(), layer_end());
632 }
633 
634 //----------------------------------------------------------------------------
635 inline int CaloLVL1_ID::pos_neg_z(const Identifier id) const
636 {
637  return (m_lvl1_impl.unpack(id));
638 }
639 
640 //----------------------------------------------------------------------------
641 inline int CaloLVL1_ID::sampling(const Identifier id) const
642 {
643  return (m_sampling_impl.unpack(id));
644 }
645 
646 //----------------------------------------------------------------------------
647 inline int CaloLVL1_ID::region(const Identifier id) const
648 {
649  return (m_region_impl.unpack(id));
650 }
651 
652 //----------------------------------------------------------------------------
653 inline int CaloLVL1_ID::eta(const Identifier id) const
654 {
655  return (m_eta_impl.unpack(id));
656 }
657 
658 //----------------------------------------------------------------------------
659 inline int CaloLVL1_ID::phi(const Identifier id) const
660 {
661  return (m_phi_impl.unpack(id));
662 }
663 
664 //----------------------------------------------------------------------------
665 inline int CaloLVL1_ID::layer(const Identifier id) const
666 {
667  return (m_layer_impl.unpack(id));
668 }
669 
670 
671 //----------------------------------------------------------------------------
672 inline bool CaloLVL1_ID::is_tile (const Identifier id) const
673 {
674  // Must first check if this is a normal tile id
675  if (AtlasDetectorID::is_tile(id)) {
676  return (true);
677  }
678  else {
679  return (is_lvl1_trig_towers(id) && region(id) == 0 && sampling(id) == 1 && eta(id) < 15);
680  }
681 }
682 
683 //----------------------------------------------------------------------------
684 inline bool CaloLVL1_ID::is_emb (const Identifier id) const
685 {
686  return (is_lvl1_trig_towers(id) && region(id) == 0 && sampling(id) == 0 && eta(id) < 14);
687 }
688 
689 //----------------------------------------------------------------------------
690 inline bool CaloLVL1_ID::is_barrel_end (const Identifier id) const
691 {
692  return (is_lvl1_trig_towers(id) && region(id) == 0 && sampling(id) == 0 && eta(id) == 14);
693 }
694 
695 //----------------------------------------------------------------------------
696 inline bool CaloLVL1_ID::is_emec (const Identifier id) const
697 {
698  return (is_lvl1_trig_towers(id) && sampling(id) == 0 &&
699  ((region(id) == 0 && eta(id) > 14) || region(id) == 1 || region(id) == 2 ));
700 }
701 
702 //----------------------------------------------------------------------------
703 inline bool CaloLVL1_ID::is_hec (const Identifier id) const
704 {
705  return (is_lvl1_trig_towers(id) && sampling(id) == 1 &&
706  ((region(id) == 0 && eta(id) > 14) || region(id) == 1 || region(id) == 2 ));
707 }
708 
709 //----------------------------------------------------------------------------
710 inline bool CaloLVL1_ID::is_fcal (const Identifier id) const
711 {
712  return (is_lvl1_trig_towers(id) && region(id) == 3 );
713 }
714 
715 //----------------------------------------------------------------------------
716 inline Identifier CaloLVL1_ID::region_id (IdentifierHash region_hash_id) const
717 {
718  return(m_region_vec[region_hash_id]);
719 }
720 
721 //----------------------------------------------------------------------------
722 inline Identifier CaloLVL1_ID::tower_id (IdentifierHash tower_hash_id) const
723 {
724  return(m_tower_vec[tower_hash_id]);
725 }
726 
727 //----------------------------------------------------------------------------
728 inline IdentifierHash CaloLVL1_ID::tower_hash (Identifier towerId) const
729 {
730  const HashCalc& hc = m_hash_calcs[m_pnz_reg_impl.unpack(towerId)];
731  return (hc.m_hash + (eta(towerId)-hc.m_etamin)*hc.m_nphi + phi(towerId));
732 }
733 
734 //----------------------------------------------------------------------------
735 inline IdentifierHash CaloLVL1_ID::tower_hash_binary_search (Identifier towerId) const
736 {
737  std::vector<Identifier>::const_iterator it = std::lower_bound(m_tower_vec.begin(),m_tower_vec.end(),towerId);
738  if ( it != m_tower_vec.end() ){
739  return (it - m_tower_vec.begin());
740  }
741  return (0);
742 }
743 
744 
745 
746 #endif // CALOLVL1_ID_H
747 
748 
749 
750 
751 
752 
753 
754 
755 
756 
757 
758 
759 
760 
761 
762 
763 
764 
765 
766 
767 
768 
769 
770 
CaloLVL1_ID::layer_hash_max
size_type layer_hash_max(void) const
layer hash table max size
Definition: CaloLVL1_ID.h:566
CaloLVL1_ID::get_next_in_eta
int get_next_in_eta(const IdentifierHash &id, IdentifierHash &next) const
access to hashes for neighbours in eta – towers only (no extended) return == 0 for neighbours found
Definition: CaloLVL1_ID.cxx:573
CaloLVL1_ID::id_range
boost::iterator_range< id_iterator > id_range
Type for range over identifiers.
Definition: CaloLVL1_ID.h:154
CaloLVL1_ID::m_next_phi_vec
std::vector< unsigned short > m_next_phi_vec
Definition: CaloLVL1_ID.h:367
CaloLVL1_ID::HashCalc::m_nphi
size_type m_nphi
Definition: CaloLVL1_ID.h:385
CaloLVL1_ID::tower_context
IdContext tower_context(void) const
access to IdContext's which define which levels of fields are contained in the id
Definition: CaloLVL1_ID.cxx:53
CaloLVL1_ID::layer_max
int layer_max(const Identifier regId) const
max value of phi index (-999 == failure)
Definition: CaloLVL1_ID.cxx:515
CaloLVL1_ID::region_range
id_range region_range() const
range over regions
Definition: CaloLVL1_ID.h:591
get_generator_info.result
result
Definition: get_generator_info.py:21
CaloLVL1_ID::m_PHI_INDEX
size_type m_PHI_INDEX
Definition: CaloLVL1_ID.h:352
CaloLVL1_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: CaloLVL1_ID.cxx:585
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
CaloLVL1_ID::layer_id_checks
void layer_id_checks(int pos_neg_z, int sampling, int region, int eta, int phi, int layer) const
Definition: CaloLVL1_ID.cxx:655
CaloLVL1_ID::is_fcal
bool is_fcal(const Identifier id) const
Test wether given tower or layer is part of the FCAL.
Definition: CaloLVL1_ID.h:710
CaloLVL1_ID::m_prev_eta_vec
std::vector< unsigned short > m_prev_eta_vec
Definition: CaloLVL1_ID.h:368
CaloLVL1_ID::m_REGION_INDEX
size_type m_REGION_INDEX
Definition: CaloLVL1_ID.h:350
CaloLVL1_ID::region_context
IdContext region_context(void) const
access to IdContext's which define which levels of fields are contained in the id
Definition: CaloLVL1_ID.cxx:46
CaloLVL1_ID::m_sampling_impl
IdDictFieldImplementation m_sampling_impl
Definition: CaloLVL1_ID.h:393
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
CaloLVL1_ID::phi_max
int phi_max(const Identifier regId) const
min value of phi index (-999 == failure)
Definition: CaloLVL1_ID.cxx:494
CaloLVL1_ID::m_phi_impl
IdDictFieldImplementation m_phi_impl
Definition: CaloLVL1_ID.h:396
AtlasDetectorID::calo_field_value
int calo_field_value() const
Definition: AtlasDetectorID.h:623
Range.h
CaloLVL1_ID::m_region_impl
IdDictFieldImplementation m_region_impl
Definition: CaloLVL1_ID.h:394
CaloLVL1_ID::initialize_from_dictionary
virtual int initialize_from_dictionary(const IdDictMgr &dict_mgr)
initialization from the identifier dictionary
Definition: CaloLVL1_ID.cxx:192
skel.it
it
Definition: skel.GENtoEVGEN.py:423
CaloLVL1_ID::is_emec
bool is_emec(const Identifier id) const
Test wether given tower or layer is part of the EM end-cap.
Definition: CaloLVL1_ID.h:696
CaloLVL1_ID::size_type
Identifier::size_type size_type
Definition: CaloLVL1_ID.h:69
CaloLVL1_ID::m_region_vec
std::vector< Identifier > m_region_vec
Definition: CaloLVL1_ID.h:365
ExpandedIdentifier
Definition: DetectorDescription/Identifier/Identifier/ExpandedIdentifier.h:108
IdDictFieldImplementation::pack
void pack(int value, Identifier &id) const
Definition: IdDictFieldImplementation.h:174
CaloLVL1_ID::region
int region(const Identifier id) const
return region according to :
Definition: CaloLVL1_ID.h:647
CaloLVL1_ID::m_dict
const IdDictDictionary * m_dict
Definition: CaloLVL1_ID.h:355
CaloLVL1_ID::is_barrel_end
bool is_barrel_end(const Identifier id) const
Test wether given tower or layer is part of the EM barrel END.
Definition: CaloLVL1_ID.h:690
CaloLVL1_ID::init_hashes
int init_hashes(void)
Definition: CaloLVL1_ID.cxx:938
CaloLVL1_ID::m_layer_impl
IdDictFieldImplementation m_layer_impl
Definition: CaloLVL1_ID.h:397
CaloLVL1_ID::region_id
Identifier region_id(int pos_neg_z, int sampling, int region) const
build a region (of towers) identifier
Definition: CaloLVL1_ID.h:502
CaloLVL1_ID::layer_end
id_iterator layer_end() const
end iterators over layers
Definition: CaloLVL1_ID.h:622
IdDictFieldImplementation::unpack
int unpack(Identifier id) const
Identifier manipulation methods.
Definition: IdDictFieldImplementation.h:148
CaloLVL1_ID::layer_context
IdContext layer_context(void) const
access to IdContext's which define which levels of fields are contained in the id
Definition: CaloLVL1_ID.cxx:60
CaloLVL1_ID::tower_end
id_iterator tower_end() const
end iterator over towers
Definition: CaloLVL1_ID.h:603
CaloLVL1_ID::layer
int layer(const Identifier id) const
return layer according to :
Definition: CaloLVL1_ID.h:665
AtlasDetectorID::is_lvl1_trig_towers
bool is_lvl1_trig_towers(Identifier id) const
Definition: AtlasDetectorID.h:713
CaloLVL1_ID::is_hec
bool is_hec(const Identifier id) const
Test wether given tower or layer is part of the HEC.
Definition: CaloLVL1_ID.h:703
IdDictFieldImplementation::reset
void reset(Identifier &id) const
Definition: IdDictFieldImplementation.h:184
CaloLVL1_ID::region_end
id_iterator region_end() const
end iterator over regions
Definition: CaloLVL1_ID.h:585
CaloLVL1_ID::get_prev_in_eta
int get_prev_in_eta(const IdentifierHash &id, IdentifierHash &prev) const
access to hashes for neighbours in eta – towers only (no extended) return == 0 for neighbours found
Definition: CaloLVL1_ID.cxx:561
CaloLVL1_ID::m_full_layer_range
MultiRange m_full_layer_range
Definition: CaloLVL1_ID.h:359
CaloLVL1_ID::layer_id
Identifier layer_id(int pos_neg_z, int sampling, int region, int eta, int phi, int layer) const
build a layer identifier
Definition: CaloLVL1_ID.h:530
CaloLVL1_ID::phi
int phi(const Identifier id) const
return phi according to :
Definition: CaloLVL1_ID.h:659
CaloLVL1_ID::eta_max
int eta_max(const Identifier regId) const
max value of eta index (-999 == failure)
Definition: CaloLVL1_ID.cxx:473
AtlasDetectorID.h
This class provides an interface to generate or decode an identifier for the upper levels of the dete...
IdDictMgr
Definition: IdDictDefs.h:32
CaloLVL1_ID::m_next_eta_vec
std::vector< unsigned short > m_next_eta_vec
Definition: CaloLVL1_ID.h:369
CaloLVL1_ID::m_eta_impl
IdDictFieldImplementation m_eta_impl
Definition: CaloLVL1_ID.h:395
CaloLVL1_ID::~CaloLVL1_ID
virtual ~CaloLVL1_ID()
CaloLVL1_ID::HashCalc::HashCalc
HashCalc()
Definition: CaloLVL1_ID.h:379
CaloLVL1_ID::m_LAYER_INDEX
size_type m_LAYER_INDEX
Definition: CaloLVL1_ID.h:353
CaloLVL1_ID::region_begin
id_iterator region_begin() const
begin iterator over regions
Definition: CaloLVL1_ID.h:579
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
CaloLVL1_ID::m_hash_calcs
std::vector< HashCalc > m_hash_calcs
Definition: CaloLVL1_ID.h:387
CaloLVL1_ID::HashCalc
small class holding the starting hash value, the min eta and the number of phi bins of each region
Definition: CaloLVL1_ID.h:377
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
CaloLVL1_ID::init_neighbors
int init_neighbors(void)
Definition: CaloLVL1_ID.cxx:1143
CaloLVL1_ID::m_prev_phi_vec
std::vector< unsigned short > m_prev_phi_vec
Definition: CaloLVL1_ID.h:366
CaloLVL1_ID::m_tower_vec
std::vector< Identifier > m_tower_vec
Definition: CaloLVL1_ID.h:363
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
CaloLVL1_ID::eta_min
int eta_min(const Identifier regId) const
min value of eta index (-999 == failure)
Definition: CaloLVL1_ID.cxx:447
CaloLVL1_ID::get_next_in_phi
int get_next_in_phi(const IdentifierHash &id, IdentifierHash &next) const
access to hashes for neighbours in phi – towers only (no extended) return == 0 for neighbours found
Definition: CaloLVL1_ID.cxx:549
CaloLVL1_ID::HashCalc::m_etamin
size_type m_etamin
Definition: CaloLVL1_ID.h:384
CaloLVL1_ID::get_hash
virtual int get_hash(const Identifier &id, IdentifierHash &hash_id, const IdContext *context=0) const
create hash id from compact id (return == 0 for OK)
Definition: CaloLVL1_ID.cxx:143
AtlasDetectorID::is_tile
bool is_tile(Identifier id) const
Definition: AtlasDetectorID.h:695
CaloLVL1_ID::is_emb
bool is_emb(const Identifier id) const
Test wether given tower or layer is part of the EM barrel.
Definition: CaloLVL1_ID.h:684
CaloLVL1_ID::region_hash_max
size_type region_hash_max(void) const
region hash table max size
Definition: CaloLVL1_ID.h:572
CaloLVL1_ID::m_DETZSIDE_INDEX
size_type m_DETZSIDE_INDEX
Definition: CaloLVL1_ID.h:348
CaloLVL1_ID::m_lvl1_impl
IdDictFieldImplementation m_lvl1_impl
Definition: CaloLVL1_ID.h:392
CaloLVL1_ID::m_SAMPLING_INDEX
size_type m_SAMPLING_INDEX
Definition: CaloLVL1_ID.h:349
CaloLVL1_ID
Helper class for offline TT identifiers.
Definition: CaloLVL1_ID.h:66
MultiRange
A MultiRange combines several Ranges.
Definition: DetectorDescription/Identifier/Identifier/Range.h:351
CaloLVL1_ID::get_id
virtual int get_id(const IdentifierHash &hash_id, Identifier &id, const IdContext *context=0) const
create compact id from hash id (return == 0 for OK)
Definition: CaloLVL1_ID.cxx:68
CaloLVL1_ID::m_region_hash_max
size_type m_region_hash_max
Definition: CaloLVL1_ID.h:362
IdentifierHash.h
CaloLVL1_ID::m_pnz_reg_impl
IdDictFieldImplementation m_pnz_reg_impl
Definition: CaloLVL1_ID.h:399
CaloLVL1_ID::get_prev_in_phi
int get_prev_in_phi(const IdentifierHash &id, IdentifierHash &prev) const
access to hashes for neighbours in phi – towers only (no extended) return == 0 for neighbours found
Definition: CaloLVL1_ID.cxx:537
CaloLVL1_ID::tower_hash_binary_search
IdentifierHash tower_hash_binary_search(Identifier towerId) const
create hash id from tower id – method NOT optimised, please use tower_hash() above
Definition: CaloLVL1_ID.h:735
CaloLVL1_ID::eta
int eta(const Identifier id) const
return eta according to :
Definition: CaloLVL1_ID.h:653
CaloLVL1_ID::m_ETA_INDEX
size_type m_ETA_INDEX
Definition: CaloLVL1_ID.h:351
CaloLVL1_ID::m_lvl1_region_index
size_type m_lvl1_region_index
Definition: CaloLVL1_ID.h:346
CaloLVL1_ID::m_full_region_range
MultiRange m_full_region_range
Definition: CaloLVL1_ID.h:357
IdDictDictionary
Definition: IdDictDefs.h:97
IdDictFieldImplementation.h
CaloLVL1_ID::region_id_checks
void region_id_checks(int pos_neg_z, int sampling, int region) const
Definition: CaloLVL1_ID.cxx:642
CaloLVL1_ID::pos_neg_z
int pos_neg_z(const Identifier id) const
return pos_neg_z according to :
Definition: CaloLVL1_ID.h:635
CaloLVL1_ID::m_layer_vec
std::vector< Identifier > m_layer_vec
Definition: CaloLVL1_ID.h:364
CaloLVL1_ID::tower_id_checks
void tower_id_checks(int pos_neg_z, int sampling, int region, int eta, int phi) const
Definition: CaloLVL1_ID.cxx:605
CaloLVL1_ID::NOT_VALID_HASH
@ NOT_VALID_HASH
Definition: CaloLVL1_ID.h:320
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
CaloLVL1_ID::tower_hash_max
size_type tower_hash_max(void) const
tower hash table max size
Definition: CaloLVL1_ID.h:560
CaloLVL1_ID::tower_begin
id_iterator tower_begin() const
begin iterator over towers
Definition: CaloLVL1_ID.h:597
CaloLVL1_ID::sampling
int sampling(const Identifier id) const
return sampling according to :
Definition: CaloLVL1_ID.h:641
CaloLVL1_ID::m_calo_impl
IdDictFieldImplementation m_calo_impl
Definition: CaloLVL1_ID.h:391
CaloLVL1_ID::HashCalc::m_hash
IdentifierHash m_hash
Definition: CaloLVL1_ID.h:383
Identifier::size_type
IDENTIFIER_TYPE size_type
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:41
CaloLVL1_ID::m_CALO_INDEX
size_type m_CALO_INDEX
Definition: CaloLVL1_ID.h:347
CaloLVL1_ID::tower_range
id_range tower_range() const
range over towers
Definition: CaloLVL1_ID.h:609
CaloLVL1_ID::id_iterator
std::vector< Identifier >::const_iterator id_iterator
Type for iterators over identifiers.
Definition: CaloLVL1_ID.h:152
CaloLVL1_ID::initLevelsFromDict
int initLevelsFromDict(void)
Definition: CaloLVL1_ID.cxx:692
CaloLVL1_ID::tower_hash
IdentifierHash tower_hash(Identifier towerId) const
create hash id from tower id
Definition: CaloLVL1_ID.h:728
IdDictFieldImplementation
IdDictFieldImplementation is used to capture the specification of a single field of an Identifier.
Definition: IdDictFieldImplementation.h:58
IdentifierHash
Definition: IdentifierHash.h:38
CaloLVL1_ID::m_layer_hash_max
size_type m_layer_hash_max
Definition: CaloLVL1_ID.h:361
CaloLVL1_ID::CaloLVL1_ID
CaloLVL1_ID(void)
Definition: CaloLVL1_ID.cxx:23
CaloLVL1_ID::m_full_tower_range
MultiRange m_full_tower_range
Definition: CaloLVL1_ID.h:358
CaloID_Exception.h
CaloLVL1_ID::tower_id
Identifier tower_id(int pos_neg_z, int sampling, int region, int eta, int phi) const
build a tower identifier
Definition: CaloLVL1_ID.h:429
CaloLVL1_ID::is_tile
bool is_tile(const Identifier id) const
Test wether given tower or layer is part of the Tile Calorimeter.
Definition: CaloLVL1_ID.h:672
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
CaloLVL1_ID::layer_range
id_range layer_range() const
range over layers
Definition: CaloLVL1_ID.h:629
IdContext
class IdContext
Definition: IdContext.h:34
CaloLVL1_ID::layer_begin
id_iterator layer_begin() const
begin iterators over layers
Definition: CaloLVL1_ID.h:616
CLASS_DEF.h
macros to associate a CLID to a type
CaloLVL1_ID::m_tower_hash_max
size_type m_tower_hash_max
Definition: CaloLVL1_ID.h:360
AtlasDetectorID
This class provides an interface to generate or decode an identifier for the upper levels of the dete...
Definition: AtlasDetectorID.h:57
Generated on Sun Jun 30 2024 21:12:00 for ATLAS Offline Software by   doxygen 1.8.18