CaloLVL1_ID.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOLVL1_ID_H
#define CALOLVL1_ID_H
 
#include "AthenaKernel/CLASS_DEF.h"
#include "AtlasDetDescr/AtlasDetectorID.h"
#include "Identifier/IdentifierHash.h"
#include "Identifier/MultiRange.h"
#include "IdDict/IdDictFieldImplementation.h"
 
#include "CaloIdentifier/CaloID_Exception.h"
 
#include <vector>
#include <ranges>
#include <algorithm>
 

class IdentifierHash;
 
class CaloLVL1_ID : public AtlasDetectorID
{
public:        
 
  typedef Identifier::size_type  size_type ;
 
 
  CaloLVL1_ID();
 
  virtual ~CaloLVL1_ID();

  Identifier  tower_id    (int pos_neg_z, int sampling, int region,
                 int eta,       int phi ) const ;
  Identifier  tower_id    (int pos_neg_z, int sampling, int region,
                 int eta,       int phi, bool checks ) const ;
                 
  Identifier  tower_id    (const Identifier regionId,
                     int eta,       int phi )  const ;
  Identifier  tower_id    (const Identifier regionId,
                     int eta,       int phi, bool checks )  const ;
  
  Identifier  tower_id    (const Identifier layerId)  const;
  
  Identifier region_id  ( int pos_neg_z, int sampling, int region ) const;
  Identifier region_id  ( int pos_neg_z, int sampling, int region, bool checks) const;

  Identifier region_id  ( const Identifier tower_or_layerId ) const;
 

  Identifier layer_id   ( int pos_neg_z, int sampling, int region,
                  int eta,       int phi,      int layer ) const;
  Identifier layer_id   ( int pos_neg_z, int sampling, int region,
                  int eta,       int phi,      int layer,
                          bool checks) const;

  Identifier layer_id   ( const Identifier towerId,   int layer ) const;
  Identifier layer_id   ( const Identifier towerId,   int layer, bool checks ) const;
 

  IdContext    region_context   () const;

  IdContext    tower_context   () const;

  IdContext    layer_context   () const;

  virtual int  get_id    (const IdentifierHash& hash_id, Identifier& id, const IdContext* context = 0 ) const;

  virtual int  get_hash  (const Identifier& id, IdentifierHash& hash_id, const IdContext* context = 0 ) const;

  Identifier region_id   (IdentifierHash region_hash_id) const;

  Identifier tower_id (IdentifierHash tower_hash_id) const; 

  IdentifierHash tower_hash (Identifier towerId) const;
  IdentifierHash tower_hash_binary_search (Identifier towerId) const;

  virtual int  initialize_from_dictionary (const IdDictMgr& dict_mgr);

  size_type     tower_hash_max () const;
  size_type     layer_hash_max () const;
  size_type     region_hash_max () const;
 

  using id_iterator = std::vector<Identifier>::const_iterator;
  using id_range = std::ranges::subrange<id_iterator>;
 

  id_iterator region_begin    () const;
  id_iterator region_end      () const;
  id_range    region_range    () const;

  id_iterator tower_begin    () const;
  id_iterator tower_end      () const;
  id_range    tower_range    () const;

  id_iterator layer_begin    () const;
  id_iterator layer_end      () const;
  id_range    layer_range    () const;

  bool  is_tile        (const Identifier id) const;
  bool  is_emb          (const Identifier id) const;
  bool  is_barrel_end (const Identifier id) const;
  bool  is_emec        (const Identifier id) const;
  bool  is_hec          (const Identifier id) const;
  bool  is_fcal        (const Identifier id) const;

  int         pos_neg_z       (const Identifier id)const;  

  int         sampling        (const Identifier id)const;  

  int         region          (const Identifier id)const;  

  int         eta             (const Identifier id)const; 

  int         phi             (const Identifier id)const;

  int         layer             (const Identifier id)const;
 

  int eta_min(const Identifier regId) const;
  int eta_max(const Identifier regId) const;
  int phi_max(const Identifier regId) const;
  int layer_max(const Identifier regId) const;
  
  int          get_prev_in_phi(const IdentifierHash& id, IdentifierHash& prev) const;
  int          get_next_in_phi(const IdentifierHash& id, IdentifierHash& next) const;
  int          get_prev_in_eta(const IdentifierHash& id, IdentifierHash& prev) const;
  int          get_next_in_eta(const IdentifierHash& id, IdentifierHash& next) const;
 
private:    
 
     
  enum {NOT_VALID_HASH = 64000};
 

  int  get_expanded_id  (const Identifier& id, ExpandedIdentifier& exp_id, const IdContext* context) const;
 
 
  void  tower_id_checks      (int pos_neg_z, int sampling, int region,
                 int eta,       int phi ) const;
  void  tower_id_checks      (const Identifier regionId,
                     int eta,       int phi )  const;
  void region_id_checks  ( int pos_neg_z, int sampling, int region ) const;
 
  void layer_id_checks   ( int pos_neg_z, int sampling, int region,
                  int eta,       int phi,      int layer ) const;
  void layer_id_checks   ( const Identifier towerId,
                  int layer ) const;
 
 
  int         initLevelsFromDict();
 
  int         init_hashes();
 
  int         init_neighbors();
 
 
  size_type                     m_lvl1_region_index;
  size_type                     m_CALO_INDEX;
  size_type                     m_DETZSIDE_INDEX;
  size_type                     m_SAMPLING_INDEX;
  size_type                     m_REGION_INDEX;
  size_type                     m_ETA_INDEX;
  size_type                     m_PHI_INDEX;
  size_type                     m_LAYER_INDEX;
 
  const IdDictDictionary*       m_dict;
 
  MultiRange                    m_full_region_range;
  MultiRange                    m_full_tower_range;
  MultiRange                    m_full_layer_range;
  size_type                     m_tower_hash_max;
  size_type                     m_layer_hash_max;
  size_type                     m_region_hash_max;
  std::vector<Identifier>       m_tower_vec;
  std::vector<Identifier>       m_layer_vec;
  std::vector<Identifier>       m_region_vec;
  std::vector<unsigned short>   m_prev_phi_vec;
  std::vector<unsigned short>   m_next_phi_vec;
  std::vector<unsigned short>   m_prev_eta_vec;
  std::vector<unsigned short>   m_next_eta_vec;

    class HashCalc
    {
    public:
    HashCalc() :
        m_hash(0),
        m_etamin(0),
        m_nphi(0) {}
    IdentifierHash m_hash;
    size_type      m_etamin;
    size_type      m_nphi;
    };
  std::vector<HashCalc>         m_hash_calcs;
 
 
 
  IdDictFieldImplementation     m_calo_impl;
  IdDictFieldImplementation    m_lvl1_impl;
  IdDictFieldImplementation    m_sampling_impl;
  IdDictFieldImplementation    m_region_impl;
  IdDictFieldImplementation    m_eta_impl;
  IdDictFieldImplementation    m_phi_impl;
  IdDictFieldImplementation    m_layer_impl;
 
  IdDictFieldImplementation    m_pnz_reg_impl;
 
};
 
//using the macros below we can assign an identifier (and a version)
//This is required and checked at compile time when you try to record/retrieve
CLASS_DEF( CaloLVL1_ID , 108133391 , 1 )
 
 
//----------------------------------------------------------------------------
inline Identifier CaloLVL1_ID::tower_id   ( int pos_neg_z, int sampling, int region,
                        int eta,       int phi, bool checks ) const 
{  
    Identifier result(0);
    // Pack fields independently
    m_calo_impl.pack     (calo_field_value(),    result);
    m_lvl1_impl.pack     (pos_neg_z,             result);
    m_sampling_impl.pack (sampling,              result);
    m_region_impl.pack   (region,                result);
    m_eta_impl.pack      (eta,                   result);
    m_phi_impl.pack      (phi,                   result);
 
    // Do checks
    if(checks) {
    tower_id_checks( pos_neg_z, sampling, region, eta, phi );
    }
 
    return result;
}
 
inline Identifier CaloLVL1_ID::tower_id   ( int pos_neg_z, int sampling, int region,
                        int eta,       int phi ) const
{
  return tower_id (pos_neg_z, sampling, region, eta, phi, do_checks());
}
 
 
//----------------------------------------------------------------------------
inline Identifier CaloLVL1_ID::tower_id   ( const Identifier regionId,
                        int eta,  int phi, bool checks ) const 
{
    Identifier result(regionId);
 
    // Reset the fields and then set the values
    m_eta_impl.reset     (result);
    m_phi_impl.reset     (result);
    m_eta_impl.pack      (eta, result);
    m_phi_impl.pack      (phi, result);
 
    // Do checks
    if(checks) {
    tower_id_checks( regionId, eta, phi );
    }
 
    return result;
}
 
inline Identifier CaloLVL1_ID::tower_id   ( const Identifier regionId,
                        int eta,  int phi ) const
{
  return tower_id (regionId, eta, phi, do_checks());
}
 
 
//----------------------------------------------------------------------------
inline Identifier CaloLVL1_ID::region_id   ( const Identifier tower_or_layerId ) const 
{
  Identifier result(tower_or_layerId);
  //  reset eta, phi, layer
  m_eta_impl.reset(result);
  m_phi_impl.reset(result);
  m_layer_impl.reset(result);
  return (result);
}
 
//----------------------------------------------------------------------------
inline Identifier CaloLVL1_ID::tower_id   ( const Identifier layerId ) const 
{
  Identifier result(layerId);
  //  reset layer
  m_layer_impl.reset(result);
  return (result);
}
 
//----------------------------------------------------------------------------
inline Identifier CaloLVL1_ID::region_id (int pos_neg_z, int sampling, int region,
                                          bool checks)const 
{
    Identifier result(0);
    // Pack fields independently
    m_calo_impl.pack     (calo_field_value(),    result);
    m_lvl1_impl.pack     (pos_neg_z,             result);
    m_sampling_impl.pack (sampling,              result);
    m_region_impl.pack   (region,                result);
 
    // Do checks
    if(checks) {
    region_id_checks( pos_neg_z, sampling, region);
    }
 
    return result;
}
 
inline Identifier CaloLVL1_ID::region_id (int pos_neg_z, int sampling, int region)const
{
  return region_id (pos_neg_z, sampling, region, do_checks());
}
 
//----------------------------------------------------------------------------
inline Identifier CaloLVL1_ID::layer_id   ( int pos_neg_z, int sampling, int region,
                        int eta,       int phi,      int layer,
                                            bool checks) const 
{  
    Identifier result(0);
    // Pack fields independently
    m_calo_impl.pack     (calo_field_value(),    result);
    m_lvl1_impl.pack     (pos_neg_z,             result);
    m_sampling_impl.pack (sampling,              result);
    m_region_impl.pack   (region,                result);
    m_eta_impl.pack      (eta,                   result);
    m_phi_impl.pack      (phi,                   result);
    m_layer_impl.pack    (layer,                 result);
 
    // Do checks
    if(checks) {
    layer_id_checks( pos_neg_z, sampling, region, eta, phi, layer );
    }
 
    return result;
}
 
inline Identifier CaloLVL1_ID::layer_id   ( int pos_neg_z, int sampling, int region,
                        int eta,       int phi,      int layer ) const
{
  return layer_id (pos_neg_z, sampling, region, eta, phi, layer, do_checks());
}
 
//----------------------------------------------------------------------------
inline Identifier CaloLVL1_ID::layer_id   ( const Identifier towerId,
                        int layer, bool checks ) const
{
    Identifier result(towerId);
 
    // Reset the fields and then set the values
    m_layer_impl.reset     (result);
    m_layer_impl.pack      (layer, result);
    // Do checks
    if(checks) {
    layer_id_checks( towerId, layer );
    }
 
    return result;
}
 
inline Identifier CaloLVL1_ID::layer_id   ( const Identifier towerId,
                        int layer ) const
{
  return layer_id (towerId, layer, do_checks());
}
 
//----------------------------------------------------------------------------
inline CaloLVL1_ID::size_type   CaloLVL1_ID::tower_hash_max () const
{
  return m_tower_hash_max;
}
 
//----------------------------------------------------------------------------
inline CaloLVL1_ID::size_type   CaloLVL1_ID::layer_hash_max () const
{
  return m_layer_hash_max;
}
 
//----------------------------------------------------------------------------
inline CaloLVL1_ID::size_type   CaloLVL1_ID::region_hash_max () const
{
  return m_region_hash_max;
}
 
 
//----------------------------------------------------------------------------
inline CaloLVL1_ID::id_iterator CaloLVL1_ID::region_begin    () const
{
  return(m_region_vec.begin());
}
 
//----------------------------------------------------------------------------
inline CaloLVL1_ID::id_iterator CaloLVL1_ID::region_end      () const
{
  return(m_region_vec.end());
}
 
//----------------------------------------------------------------------------
inline CaloLVL1_ID::id_range CaloLVL1_ID::region_range    () const
{
  return id_range (region_begin(), region_end());
}
 
//----------------------------------------------------------------------------
inline CaloLVL1_ID::id_iterator CaloLVL1_ID::tower_begin    () const
{
  return(m_tower_vec.begin());
}
 
//----------------------------------------------------------------------------
inline CaloLVL1_ID::id_iterator CaloLVL1_ID::tower_end      () const
{
  return(m_tower_vec.end());
}
 
//----------------------------------------------------------------------------
inline CaloLVL1_ID::id_range CaloLVL1_ID::tower_range    () const
{
  return id_range (tower_begin(), tower_end());
}
 
//----------------------------------------------------------------------------  
 
inline CaloLVL1_ID::id_iterator CaloLVL1_ID::layer_begin    () const
{
  return(m_layer_vec.begin());
}
 
//----------------------------------------------------------------------------
inline CaloLVL1_ID::id_iterator CaloLVL1_ID::layer_end      () const
{
  return(m_layer_vec.end());
}
 
 
//----------------------------------------------------------------------------
inline CaloLVL1_ID::id_range CaloLVL1_ID::layer_range    () const
{
  return id_range (layer_begin(), layer_end());
}
 
//----------------------------------------------------------------------------
inline int CaloLVL1_ID::pos_neg_z(const Identifier id) const
{
  return (m_lvl1_impl.unpack(id));
}
 
//----------------------------------------------------------------------------
inline int CaloLVL1_ID::sampling(const Identifier id) const
{
  return (m_sampling_impl.unpack(id));
}
 
//----------------------------------------------------------------------------
inline int CaloLVL1_ID::region(const Identifier id) const
{
  return (m_region_impl.unpack(id));
}
 
//----------------------------------------------------------------------------
inline int CaloLVL1_ID::eta(const Identifier id) const
{
  return (m_eta_impl.unpack(id));
}
 
//----------------------------------------------------------------------------
inline int CaloLVL1_ID::phi(const Identifier id) const
{
  return (m_phi_impl.unpack(id));
}
 
//----------------------------------------------------------------------------
inline int CaloLVL1_ID::layer(const Identifier id) const
{
  return (m_layer_impl.unpack(id));
}
 
 
//----------------------------------------------------------------------------
inline bool CaloLVL1_ID::is_tile    (const Identifier id) const
{
    // Must first check if this is a normal tile id
    if (AtlasDetectorID::is_tile(id)) {
    return (true);
    }
    else {
    return (is_lvl1_trig_towers(id) && region(id) == 0 && sampling(id) == 1 && eta(id) < 15);
    }
}
 
//----------------------------------------------------------------------------
inline bool CaloLVL1_ID::is_emb  (const Identifier id) const
{
  return (is_lvl1_trig_towers(id) && region(id) == 0 && sampling(id) == 0 && eta(id) < 14);
}
 
//----------------------------------------------------------------------------
inline bool CaloLVL1_ID::is_barrel_end    (const Identifier id) const
{
  return (is_lvl1_trig_towers(id) && region(id) == 0 && sampling(id) == 0 && eta(id) == 14);
}
 
//----------------------------------------------------------------------------
inline bool CaloLVL1_ID::is_emec    (const Identifier id) const
{
  return (is_lvl1_trig_towers(id) && sampling(id) == 0 &&
          ((region(id) == 0 &&  eta(id) > 14) || region(id) == 1 || region(id) == 2 ));
}
 
//----------------------------------------------------------------------------
inline bool CaloLVL1_ID::is_hec  (const Identifier id) const
{
  return (is_lvl1_trig_towers(id) && sampling(id) == 1 &&
          ((region(id) == 0 &&  eta(id) > 14) || region(id) == 1 || region(id) == 2 ));
}
 
//----------------------------------------------------------------------------
inline bool CaloLVL1_ID::is_fcal    (const Identifier id) const
{
  return (is_lvl1_trig_towers(id) && region(id) == 3 );
}
 
//----------------------------------------------------------------------------
inline Identifier CaloLVL1_ID::region_id    (IdentifierHash region_hash_id) const
{
    return(m_region_vec[region_hash_id]);
}
 
//----------------------------------------------------------------------------
inline Identifier CaloLVL1_ID::tower_id    (IdentifierHash tower_hash_id) const
{
    return(m_tower_vec[tower_hash_id]);
}
 
//----------------------------------------------------------------------------
inline IdentifierHash CaloLVL1_ID::tower_hash (Identifier towerId) const
{
    const HashCalc& hc = m_hash_calcs[m_pnz_reg_impl.unpack(towerId)];
    return (hc.m_hash + (eta(towerId)-hc.m_etamin)*hc.m_nphi + phi(towerId));
}
 
//----------------------------------------------------------------------------
inline IdentifierHash CaloLVL1_ID::tower_hash_binary_search  (Identifier towerId) const
{
    std::vector<Identifier>::const_iterator it = std::lower_bound(m_tower_vec.begin(),m_tower_vec.end(),towerId);
    if ( it != m_tower_vec.end() ){
    return (it - m_tower_vec.begin());
    }
    return (0);
}
 
 
 
#endif // CALOLVL1_ID_H