PixelID.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 */
 
#ifndef INDETIDENTIFIER_PIXELID_H
#define INDETIDENTIFIER_PIXELID_H
 
#include "AtlasDetDescr/AtlasDetectorID.h"
#include "Identifier/Identifier.h"
#include "Identifier/Identifier32.h"
#include "Identifier/IdentifierHash.h"
#include "Identifier/MultiRange.h"
#include "Identifier/IdHelper.h"
#include "IdDict/IdDictFieldImplementation.h"
#include "AthenaKernel/CLASS_DEF.h"
 
#include <string>
#include <cassert>
#include <algorithm>
#include <string_view>
#include <array>
 
 
class IdDictDictionary;

 
class PixelID: public AtlasDetectorID
{
public:

  typedef Identifier::size_type size_type;
  typedef std::vector<Identifier>::const_iterator const_id_iterator;
  typedef MultiRange::const_identifier_factory const_expanded_id_iterator;
 
  PixelID();
  
  virtual AtlasDetectorID::HelperType helper() const override{ 
    return AtlasDetectorID::HelperType::Pixel;
  }



  Identifier wafer_id(int barrel_ec,
                      int layer_disk,
                      int phi_module,
                      int eta_module) const;
  Identifier wafer_id(int barrel_ec,
                      int layer_disk,
                      int phi_module,
                      int eta_module,
                      bool checks) const;

  Identifier wafer_id(const Identifier& pixel_id) const;

  Identifier wafer_id(IdentifierHash wafer_hash) const;

  Identifier pixel_id(int barrel_ec,
                      int layer_disk,
                      int phi_module,
                      int eta_module,
                      int phi_index,
                      int eta_index) const;
  Identifier pixel_id(int barrel_ec,
                      int layer_disk,
                      int phi_module,
                      int eta_module,
                      int phi_index,
                      int eta_index,
                      bool checks) const;
  Identifier pixel_id(const Identifier& id,
                      int phi_index,
                      int eta_index) const;


  size_type wafer_hash_max() const;
  size_type pixel_hash_max() const;



  const_id_iterator wafer_begin() const;
  const_id_iterator wafer_end() const;
  const_expanded_id_iterator pixel_begin() const;
  const_expanded_id_iterator pixel_end() const;
 



  IdentifierHash wafer_hash(Identifier wafer_id) const;

  bool is_barrel(const Identifier& id) const;

  bool is_dbm(const Identifier& id) const; //DBM

  bool is_blayer(const Identifier& id) const;

  int barrel_ec(const Identifier& id) const;
  int layer_disk(const Identifier& id) const;
  int phi_module(const Identifier& id) const;
  int eta_module(const Identifier& id) const;
  int phi_index(const Identifier& id) const;
  int eta_index(const Identifier& id) const;

  int layer_disk_max(const Identifier& id) const;
  int phi_module_max(const Identifier& id) const;
  int eta_module_max(const Identifier& id) const;
  int eta_module_min(const Identifier& id) const;
  int phi_index_max(const Identifier& id) const;
  int eta_index_max(const Identifier& id) 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;

  bool is_phi_module_max(const Identifier& id) const;
  bool is_eta_module_min(const Identifier& id) const;
  bool is_eta_module_max(const Identifier& id) const;
 


  IdContext wafer_context() const;
  IdContext pixel_context() const;



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

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

  Identifier pixel_id(Identifier::value_type val) const;

  bool is_shortened_pixel_id(Identifier32::value_type val) const;
  bool is_shortened_pixel_id(const Identifier32& id) const;
  bool is_shortened_pixel_id(const Identifier& id) const;

  Identifier pixel_id_from_shortened(Identifier32::value_type val) const;

  int base_bit() const;

  Identifier::diff_type calc_offset(const Identifier& base,
                                    const Identifier& target) const;

  Identifier pixel_id_offset(const Identifier& base,
                             Identifier::diff_type offset) const;



  Identifier pixel_id(const ExpandedIdentifier& pixel_id) const;
  Identifier pixel_id(const ExpandedIdentifier& pixel_id, bool checks) const;

  void get_expanded_id(const Identifier& id,
                       ExpandedIdentifier& exp_id,
                       const IdContext* context = 0) const;

  virtual int initialize_from_dictionary(const IdDictMgr& dict_mgr) override;

  void test_wafer_packing() const;
 
protected:
  enum {
    NOT_VALID_HASH        = 64000,
    MAX_BIT               = Identifier::MAX_BIT,
    BITS32                = Identifier::ALL_BITS
  };
 
  typedef std::vector<Identifier>     id_vec;
  typedef id_vec::const_iterator id_vec_it;
  typedef std::vector<unsigned short> hash_vec;
  typedef hash_vec::const_iterator hash_vec_it;
 
  void wafer_id_checks(int barrel_ec,
                       int layer_disk,
                       int phi_module,
                       int eta_module) const;
  void pixel_id_checks(int barrel_ec,
                       int layer_disk,
                       int phi_module,
                       int eta_module,
                       int phi_index,
                       int eta_index) const;
 
  int initLevelsFromDict();
 
  int init_hashes();
 
  int init_neighbors();
 
  Identifier m_baseIdentifier{};
  ExpandedIdentifier m_baseExpandedIdentifier{};
 
  size_type m_pixel_region_index{0};
  size_type m_INDET_INDEX{0};
  size_type m_PIXEL_INDEX{1};
  size_type m_BARREL_EC_INDEX{2};
  size_type m_LAYER_DISK_INDEX{3};
  size_type m_PHI_MODULE_INDEX{4};
  size_type m_ETA_MODULE_INDEX{5};
  size_type m_PHI_INDEX_INDEX{6};
  size_type m_ETA_INDEX_INDEX{7};
  int m_ETA_MODULE_OFFSET{999};
  Identifier m_pixel_id{};
  const IdDictDictionary* m_dict{};
  MultiRange m_full_wafer_range;
  MultiRange m_full_pixel_range;
  size_type m_wafer_hash_max{};
  size_type m_pixel_hash_max{};
  Range::field m_barrel_field;
  id_vec m_wafer_vec;
  hash_vec m_prev_phi_wafer_vec;
  hash_vec m_next_phi_wafer_vec;
  hash_vec m_prev_eta_wafer_vec;
  hash_vec m_next_eta_wafer_vec;
  
  
  enum Implementations{kIndet, kPixel, kBec, kBecShift, kLayDisk, kLayDiskShift,
    kPhiMod, kPhiModShift, kEtaMod, kEtaModShift, kPhiIndex, kEtaIndex, kBecEtaMod, 
    nImplementations };
  static constexpr std::array<std::string_view, nImplementations> m_implNames{
    "indet", "pixel", "bec", "bec_shift", "lay_disk", "lay_disk_shift", 
    "phi_mod", "phi_mod_shift", "eta_mod", "eta_mod_shift", "phi_index",
    "eta_index", "bec_eta_mod"
  };
  std::array<IdDictFieldImplementation, nImplementations> m_impl;
  Range::field m_dbm_field; //DBM
};
 
 
 
//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(PixelID, 2516, 1)
 
//----------------------------------------------------------------------------
inline Identifier
PixelID::wafer_id(int barrel_ec,
                  int layer_disk,
                  int phi_module,
                  int eta_module,
                  bool checks) const {
  // Build identifier
  Identifier result = m_baseIdentifier;
 
  // Pack fields independently
  m_impl[kBec].pack(barrel_ec, result);
  m_impl[kLayDisk].pack(layer_disk, result);
  m_impl[kPhiMod].pack(phi_module, result);
  m_impl[kEtaMod].pack(eta_module, result);
 
  // Do checks
  if (checks) {
    wafer_id_checks(barrel_ec, layer_disk, phi_module, eta_module);
  }
 
  return result;
}
 
inline Identifier
PixelID::wafer_id(int barrel_ec,
                  int layer_disk,
                  int phi_module,
                  int eta_module) const {
  return wafer_id(barrel_ec, layer_disk, phi_module, eta_module, do_checks());
}
 
//----------------------------------------------------------------------------
inline Identifier
PixelID::wafer_id(const Identifier& pixel_id) const {
  Identifier result(pixel_id);
 
  m_impl[kPhiIndex].reset(result);
  m_impl[kEtaIndex].reset(result);
  return(result);
}
 
//----------------------------------------------------------------------------
inline Identifier PixelID::wafer_id(IdentifierHash wafer_hash) const {
  return(m_wafer_vec[wafer_hash]);
}
 
//----------------------------------------------------------------------------
inline IdentifierHash PixelID::wafer_hash(Identifier wafer_id) const {
  id_vec_it it = std::lower_bound(m_wafer_vec.begin(),
                                  m_wafer_vec.end(),
                                  wafer_id);
 
  // Require that wafer_id matches the one in vector
  if (it != m_wafer_vec.end() && wafer_id == (*it)) {
    return(it - m_wafer_vec.begin());
  }
  IdentifierHash result;
  return(result); // return hash in invalid state
}
 
//----------------------------------------------------------------------------
inline Identifier
PixelID::pixel_id(int barrel_ec,
                  int layer_disk,
                  int phi_module,
                  int eta_module,
                  int phi_index,
                  int eta_index,
                  bool checks) const {
  // Build identifier
  Identifier result = m_baseIdentifier;
 
  m_impl[kBec].pack(barrel_ec, result);
  m_impl[kLayDisk].pack(layer_disk, result);
  m_impl[kPhiMod].pack(phi_module, result);
  m_impl[kEtaMod].pack(eta_module, result);
  m_impl[kPhiIndex].pack(phi_index, result);
  m_impl[kEtaIndex].pack(eta_index, result);
 
  if (checks) {
    pixel_id_checks(barrel_ec,
                    layer_disk,
                    phi_module,
                    eta_module,
                    phi_index,
                    eta_index);
  }
 
  return result;
}
 
inline Identifier
PixelID::pixel_id(int barrel_ec,
                  int layer_disk,
                  int phi_module,
                  int eta_module,
                  int phi_index,
                  int eta_index) const {
  return pixel_id(barrel_ec, layer_disk, phi_module, eta_module,
                  phi_index, eta_index, do_checks());
}

//----------------------------------------------------------------------------
inline Identifier
PixelID::pixel_id(const ExpandedIdentifier& id,
                  bool checks) const {
  Identifier result;
 
  result = pixel_id(id[m_BARREL_EC_INDEX],
                    id[m_LAYER_DISK_INDEX],
                    id[m_PHI_MODULE_INDEX],
                    id[m_ETA_MODULE_INDEX],
                    id[m_PHI_INDEX_INDEX],
                    id[m_ETA_INDEX_INDEX]);
 
  if (checks) {
    pixel_id_checks(id[m_BARREL_EC_INDEX],
                    id[m_LAYER_DISK_INDEX],
                    id[m_PHI_MODULE_INDEX],
                    id[m_ETA_MODULE_INDEX],
                    id[m_PHI_INDEX_INDEX],
                    id[m_ETA_INDEX_INDEX]);
  }
 
  return(result);
}
 
inline Identifier
PixelID::pixel_id(const ExpandedIdentifier& id) const {
  return pixel_id(id, do_checks());
}
 
//----------------------------------------------------------------------------
inline Identifier
PixelID::pixel_id(const Identifier& wafer_id,
                  int phi_index,
                  int eta_index) const {
  Identifier result(wafer_id);
 
  m_impl[kPhiIndex].reset(result);
  m_impl[kEtaIndex].reset(result);
  m_impl[kPhiIndex].pack(phi_index, result);
  m_impl[kEtaIndex].pack(eta_index, result);
  return(result);
}
 
//----------------------------------------------------------------------------
inline Identifier
PixelID::pixel_id(Identifier::value_type val) const {
  // a pixel channel id has bit 31 set, and low 8 bits > 0.
  // This could also have been shifted up by 32 bits.
 
  // first test to see if this is a 32-bit value promoted to 64-bit
  // (low word != 0, high word == 0).
  if ((val << 32) && !(val >> 32)) {
    // test to see if this is a genuine 64-bit pixel channel id;
    // these would not have the low 8-bits nonzero.
    // (This will break if pixel channel id's fill more than 56 bits!)
    Identifier32::value_type valshort = static_cast<Identifier32::value_type>(val);
    if (is_shortened_pixel_id(valshort)) {
      return pixel_id_from_shortened(valshort);
    }
  } else if (!(val << 32) && (val >> 32)) {
    // low word 0, high word != 0
    Identifier32::value_type valshort = static_cast<Identifier32::value_type>(val >> 32);
    if (is_shortened_pixel_id(valshort)) {
      return pixel_id_from_shortened(valshort);
    }
  }
  return Identifier(val); // genuine 64-bit pixel channel id
}
 
//----------------------------------------------------------------------------
inline bool
PixelID::is_shortened_pixel_id(Identifier32::value_type val) const {
  return (val >> 31) && (val & 0xff);
}
 
//----------------------------------------------------------------------------
inline bool
PixelID::is_shortened_pixel_id(const Identifier32& id) const {
  return is_shortened_pixel_id(id.get_compact());
}
 
//----------------------------------------------------------------------------
inline bool
PixelID::is_shortened_pixel_id(const Identifier& id) const {
  Identifier::value_type val = id.get_compact();
  Identifier32::value_type valshort;
  // first test if value is contained in one half or the other
  if ((val << 32) && !(val >> 32)) {
    // low word contains value, high word empty
    valshort = static_cast<Identifier32::value_type>(val);
  } else if (!(val << 32) && (val >> 32)) {
    // high word contains value, low word empty
    valshort = static_cast<Identifier32::value_type>(val >> 32);
  } else {
    return false;
  }
  return is_shortened_pixel_id(valshort);
}
 
//----------------------------------------------------------------------------
inline Identifier
PixelID::pixel_id_from_shortened(Identifier32::value_type val) const {
  int bec_val[4] = {
    -2, 0, 2, -999
  }; // CHECK decodings
  int bec = bec_val[(val >> 29) & 0x03];
 
  if (bec < -2) return Identifier();
 
  return pixel_id(bec,
                  /* lay_disk */ ((val >> 27) & 0x03),
                  /* phi_mod */ ((val >> 21) & 0x3f),
                  /* eta_mod */ (((val >> 17) & 0x0f) + m_ETA_MODULE_OFFSET),
                  /* phi_index */ ((val >> 8) & 0x1ff),
                  /* eta_index */ ((val) & 0xff) - 1);
}
 
//----------------------------------------------------------------------------
inline Identifier::diff_type
PixelID::calc_offset(const Identifier& base, const Identifier& target) const {
  Identifier::diff_type tval = static_cast<Identifier::diff_type>(target.get_compact() >> base_bit());
  Identifier::diff_type bval = static_cast<Identifier::diff_type>(base.get_compact() >> base_bit());
  return(tval - bval);
}
 
//----------------------------------------------------------------------------
inline Identifier
PixelID::pixel_id_offset(const Identifier& base,
                         Identifier::diff_type offset) const {
  Identifier::value_type bval = base.get_compact() >> base_bit();
  return Identifier((bval + offset) << base_bit());
}
 
//----------------------------------------------------------------------------
inline int
PixelID::base_bit() const {
  int base = static_cast<int>(m_impl[kEtaIndex].shift()); // lowest field base
 
  return (base > 32) ? 32 : base;
  // max base is 32 so we can still read old strip id's and differences
  // from non-SLHC releases.
}
 
//----------------------------------------------------------------------------
inline bool
PixelID::is_barrel(const Identifier& id) const {
  // Normal unshifted id
  return(m_barrel_field.match(m_impl[kBec].unpack(id)));
}
 
//----------------------------------------------------------------------------
inline bool
PixelID::is_dbm(const Identifier& id) const {
  // Normal unshifted id
  return(m_dbm_field.match(m_impl[kBec].unpack(id)));
}
 
//----------------------------------------------------------------------------
inline int
PixelID::barrel_ec(const Identifier& id) const {
  // Normal unshifted id
  return(m_impl[kBec].unpack(id));
}
 
//----------------------------------------------------------------------------
inline int
PixelID::layer_disk(const Identifier& id) const {
  // Normal unshifted id
  return(m_impl[kLayDisk].unpack(id));
}
 
//----------------------------------------------------------------------------
inline bool
PixelID::is_blayer(const Identifier& id) const {
  // Check if it is pixel id
  if (is_barrel(id)) {
    return(0 == layer_disk(id));
  } else {
    return(false);
  }
}
 
//----------------------------------------------------------------------------
inline int
PixelID::phi_module(const Identifier& id) const {
  // Normal unshifted id
  return(m_impl[kPhiMod].unpack(id));
}
 
//----------------------------------------------------------------------------
inline int
PixelID::eta_module(const Identifier& id) const {
  // Normal unshifted id
  return(m_impl[kEtaMod].unpack(id));
}
 
//----------------------------------------------------------------------------
inline int
PixelID::phi_index(const Identifier& id) const {
  return(m_impl[kPhiIndex].unpack(id));
}
 
//----------------------------------------------------------------------------
inline int
PixelID::eta_index(const Identifier& id) const {
  return(m_impl[kEtaIndex].unpack(id));
}
 
#endif // INDETIDENTIFIER_PIXELID_H