PixelID.cxx

Go to the documentation of this file.

/*
   Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 */
 
/***************************************************************************
   Inner Detector identifier package
   -------------------------------------------
***************************************************************************/
 
 
#include "InDetIdentifier/PixelID.h"
#include "PixelOutputFormatting.h"
#include "IdDict/IdDictDictionary.h"
#include "IdDict/IdDictField.h"
#include "IdDict/IdDictMgr.h"
#include "IdDict/IdDictRegion.h"
#include "Identifier/IdentifierHash.h"
#include "Identifier/RangeIterator.h"
#include "Identifier/IdContext.h"
#include <set>
#include <algorithm>
#include <iostream>
 
using InDetIdentifierPkg::formatOutput;
 
PixelID::PixelID()
  : AtlasDetectorID("PixelID", "pixel")
{
  m_barrel_field.add_value(0);
  m_dbm_field.add_value(0); //DBM
}
 
void
PixelID::wafer_id_checks(int barrel_ec,int layer_disk,int phi_module,int eta_module) const {
 
  // Fill expanded id
  ExpandedIdentifier id;
  id = m_baseExpandedIdentifier;
  id << barrel_ec << layer_disk << phi_module << eta_module;
  if (!m_full_wafer_range.match(id)) {  // module range check is sufficient
    ATH_MSG_ERROR("PixelID::wafer_id result is NOT ok. ID, range "
                  << (std::string) id << "   " << (std::string) m_full_wafer_range);
    
  }
}
 
void
PixelID::pixel_id_checks(int barrel_ec,int layer_disk,int phi_module,int eta_module,
  int phi_index,int eta_index) const {
  // Check that id is within allowed range
  // Fill expanded id
  ExpandedIdentifier id;
  id = m_baseExpandedIdentifier;
  id << barrel_ec << layer_disk << phi_module << eta_module << phi_index << eta_index;
  if (!m_full_pixel_range.match(id)) {
    ATH_MSG_ERROR("PixelID::pixel_id result is NOT ok. ID, range "
                  << (std::string) id << " " << (std::string) m_full_pixel_range);
   
  }
}
 
int
PixelID::layer_disk_max(const Identifier& id) const {
  // get max from dictionary
  ExpandedIdentifier expId;
  IdContext wafer_context1 = wafer_context();
  get_expanded_id(id, expId, &wafer_context1);
  for (unsigned int i = 0; i < m_full_wafer_range.size(); ++i) {
    const Range& range = m_full_wafer_range[i];
    if (range.match(expId)) {
      const Range::field& layer_disk_field = range[m_LAYER_DISK_INDEX];
      if (not layer_disk_field.empty()) {
        return(layer_disk_field.get_maximum());
      }
    }
  }
  return(-999);  // default
}
 
int
PixelID::eta_module_max(const Identifier& id) const {
  // get max from dictionary
  ExpandedIdentifier expId;
  IdContext wafer_context1 = wafer_context();
  get_expanded_id(id, expId, &wafer_context1);
  for (unsigned int i = 0; i < m_full_wafer_range.size(); ++i) {
    const Range& range = m_full_wafer_range[i];
    if (range.match(expId)) {
      const Range::field& eta_field = range[m_ETA_MODULE_INDEX];
      if (not eta_field.empty()) {
        return(eta_field.get_maximum());
      }
    }
  }
  return(-999);
}
 
int PixelID::eta_module_min(const Identifier& id) const {
  // get min from dictionary
  ExpandedIdentifier expId;
  IdContext wafer_context1 = wafer_context();
  get_expanded_id(id, expId, &wafer_context1);
  for (unsigned int i = 0; i < m_full_wafer_range.size(); ++i) {
    const Range& range = m_full_wafer_range[i];
    if (range.match(expId)) {
      const Range::field& eta_field = range[m_ETA_MODULE_INDEX];
      if (not eta_field.empty()) {
        return(eta_field.get_minimum());
      }
    }
  }
  return(-999);
}
 
bool
PixelID::is_eta_module_min(const Identifier& id)  const {
  return(eta_module(id) == eta_module_min(id));
}
 
bool
PixelID::is_eta_module_max(const Identifier& id)  const {
  return(eta_module(id) == eta_module_max(id));
}
 
int PixelID::phi_module_max(const Identifier& id) const {
  // get max from dictionary
  ExpandedIdentifier expId;
  IdContext wafer_context1 = wafer_context();
 
  get_expanded_id(id, expId, &wafer_context1);
  for (unsigned int i = 0; i < m_full_wafer_range.size(); ++i) {
    const Range& range = m_full_wafer_range[i];
    if (range.match(expId)) {
      const Range::field& phi_field = range[m_PHI_MODULE_INDEX];
      if (not phi_field.empty()) {
        return(phi_field.get_maximum());
      }
    }
  }
  // Failed to find the max
  return(-999);
}
 
int
PixelID::phi_index_max(const Identifier& id) const {
  // get max from dictionary
  ExpandedIdentifier expId;
  IdContext wafer_context1 = wafer_context();
  get_expanded_id(id, expId, &wafer_context1);
  for (unsigned int i = 0; i < m_full_pixel_range.size(); ++i) {
    const Range& range = m_full_pixel_range[i];
    if (range.match(expId)) {
      const Range::field& phi_field = range[m_PHI_INDEX_INDEX];
      if (not phi_field.empty()) {
        return(phi_field.get_maximum());
      }
    }
  }
  // Failed to find the max
  return(-999);
}
 
int
PixelID::eta_index_max(const Identifier& id) const {
  // get max from dictionary
  ExpandedIdentifier expId;
  IdContext wafer_context1 = wafer_context();
  get_expanded_id(id, expId, &wafer_context1);
  for (unsigned int i = 0; i < m_full_pixel_range.size(); ++i) {
    const Range& range = m_full_pixel_range[i];
    if (range.match(expId)) {
      const Range::field& eta_field = range[m_ETA_INDEX_INDEX];
      if (not eta_field.empty()) {
        return(eta_field.get_maximum());
      }
    }
  }
  return(-999);  // default
}
 
bool
PixelID::is_phi_module_max(const Identifier& id) const {
  return(phi_module(id) == phi_module_max(id));
}
 
int
PixelID::initialize_from_dictionary(const IdDictMgr& dict_mgr) {
 
  ATH_MSG_INFO("Initialize from dictionary");
 
  // Check whether this helper should be reinitialized
  if (!reinitialize(dict_mgr)) {
    ATH_MSG_INFO("Request to reinitialize not satisfied - tags have not changed");
    return(0);
  } else {
    ATH_MSG_DEBUG("(Re)initialize");
  }
 
  // init base object
  if (AtlasDetectorID::initialize_from_dictionary(dict_mgr)) return(1);
 
  // Register version of InnerDetector dictionary
  if (register_dict_tag(dict_mgr, "InnerDetector")) return(1);
 
  m_dict = dict_mgr.find_dictionary("InnerDetector");
  if (!m_dict) {
    ATH_MSG_FATAL("PixelID::initialize_from_dict - cannot access InnerDetector dictionary");
    
    return(1);
  }
 
  AtlasDetectorID::setDictVersion(dict_mgr, "InnerDetector");
 
  // Initialize the field indices
  if (initLevelsFromDict()) return(1);
 
  // save indet id
  m_pixel_id = pixel();
  if (!is_pixel(m_pixel_id)) {
    ATH_MSG_FATAL(" PixelID::initialize_from_dict - cannot get pixel id dictionary ");
    return(1);
  }
 
  //
  // Set barrel field for testing is_barrel
  //
  int barrel_value;
  m_barrel_field.clear();
  //  barrel
  if (m_dict->get_label_value("barrel_endcap", "barrel", barrel_value)) {
    ATH_MSG_FATAL("Could not get value for label 'barrel' of field 'barrel_endcap' in dictionary "
                  << m_dict->name());
    return(1);
  }
  m_barrel_field.add_value(barrel_value);
  m_barrel_field.add_value(barrel_value);
  ATH_MSG_DEBUG(" PixelID::initialize_from_dict "
                << "Set barrel field values: "
                << (std::string) m_barrel_field);
 
  //DBM
  //Set dbm field for testing is_dbm
  //
  // WARNING:
  //   modified to skip DBM when aprorpiate dictionary is not present
  //   by adding +999 or -999 to the field
  //
 
  int dbm_value;
  m_dbm_field.clear();
  if (m_dict->get_label_value("barrel_endcap", "negative_dbm", dbm_value)) {
    if (m_dict->version().find("DBM") != std::string::npos) {
      ATH_MSG_WARNING("Could not get value for label 'negative_dbm' of field 'barrel_endcap' in dictionary "
                      << m_dict->name());
 
    }
    //return (1);
    m_dbm_field.add_value(-999);
  } else {
    m_dbm_field.add_value(dbm_value);
  }
  if (m_dict->get_label_value("barrel_endcap", "positive_dbm", dbm_value)) {
    if (m_dict->version().find("DBM") != std::string::npos) {
      ATH_MSG_WARNING("Could not get value for label 'positive_dbm' of field 'barrel_endcap' in dictionary "
                      << m_dict->name());
     
    }
    //return (1);
    m_dbm_field.add_value(999);
  } else {
    m_dbm_field.add_value(dbm_value);
  }
  ATH_MSG_DEBUG("PixelID::initialize_from_dict Set dbm field values: " << (std::string)m_dbm_field);
  
 
 
  //
  // Build multirange for the valid set of identifiers
  //
 
 
  // Find value for the field InnerDetector
  const IdDictDictionary* atlasDict = dict_mgr.find_dictionary("ATLAS");
  int inDetField = -1;
  if (atlasDict->get_label_value("subdet", "InnerDetector", inDetField)) {
    ATH_MSG_FATAL("Could not get value for label 'InnerDetector' of field 'subdet' in dictionary "
                  << atlasDict->name());
   
    return(1);
  }
 
  // Find value for the field PIXEL
  int pixelField = -1;
  if (m_dict->get_label_value("part", "Pixel", pixelField)) {
    ATH_MSG_FATAL("Could not get value for label 'Pixel' of field 'part' in dictionary "
                  << m_dict->name());
    
    return(1);
  }
  ATH_MSG_DEBUG("PixelID::initialize_from_dict Found field values: InDet/Pixel "
                << inDetField << "/" << pixelField);
  
 
  // Set up id for region and range prefix
  ExpandedIdentifier region_id;
  region_id.add(inDetField);
  region_id.add(pixelField);
  Range prefix;
  m_full_wafer_range = m_dict->build_multirange(region_id, prefix, "eta_module");
  m_full_pixel_range = m_dict->build_multirange(region_id, prefix);
 
  // Set the base identifier for Pixel
  m_baseIdentifier = ((Identifier::value_type) 0);
  m_impl[kIndet].pack(indet_field_value(), m_baseIdentifier);
  m_impl[kPixel].pack(pixel_field_value(), m_baseIdentifier);
 
  // Set the base expanded identifier for Pixel
  m_baseExpandedIdentifier << indet_field_value() << pixel_field_value();
 
  // Setup the hash tables
  if (init_hashes()) return(1);
 
  // Setup hash tables for finding neighbors
  if (init_neighbors()) return(1);
  ATH_MSG_DEBUG("PixelID::initialize_from_dict");
  ATH_MSG_DEBUG("Wafer range -> " << (std::string)m_full_wafer_range);
  ATH_MSG_DEBUG("Pixel range -> " << (std::string)m_full_pixel_range);
  
  return 0;
}
 
int
PixelID::init_hashes() {
  //
  // create a vector(s) to retrieve the hashes for compact ids. For
  // the moment, we implement a hash for wafers but NOT for pixels
  // (too many)
  //
 
  // wafer hash
  m_wafer_hash_max = m_full_wafer_range.cardinality();
  m_wafer_vec.clear();
  m_wafer_vec.resize(m_wafer_hash_max);
  unsigned int nids = 0;
  std::set<Identifier> ids;
  for (unsigned int i = 0; i < m_full_wafer_range.size(); ++i) {
    const Range& range = m_full_wafer_range[i];
    ConstRangeIterator rit(range);
    for (const auto & exp_id:rit) {
      Identifier id = wafer_id(exp_id[m_BARREL_EC_INDEX],
                               exp_id[m_LAYER_DISK_INDEX],
                               exp_id[m_PHI_MODULE_INDEX],
                               exp_id[m_ETA_MODULE_INDEX]);
      if (!(ids.insert(id)).second) {
        ATH_MSG_FATAL("PixelID::init_hashes "
                      << "Error: duplicated id for wafer id. nid " << nids
                      << " id " << show_to_string(id)
                      << " exp id " << (std::string) exp_id
                      << " " << (std::string) m_full_wafer_range);
       
        return(1);
      }
      nids++;
    }
  }
  if (ids.size() != m_wafer_hash_max) {
    ATH_MSG_FATAL("PixelID::init_hashes "
                  << "Error: set size NOT EQUAL to hash max. size " << ids.size()
                  << " hash max " << m_wafer_hash_max);
    
    return(1);
  }
 
  nids = 0;
  std::set<Identifier>::const_iterator first = ids.begin();
  std::set<Identifier>::const_iterator last = ids.end();
  for (; first != last && nids < m_wafer_vec.size(); ++first) {
    m_wafer_vec[nids] = (*first);
    nids++;
  }
 
  // pixel hash - we do not keep a vec for the pixels - too large
  m_pixel_hash_max = m_full_pixel_range.cardinality();
 
  return(0);
}
 
int
PixelID::get_prev_in_phi(const IdentifierHash& id, IdentifierHash& prev) const {
  unsigned short index = id;
 
  if (index < m_prev_phi_wafer_vec.size()) {
    if (m_prev_phi_wafer_vec[index] == NOT_VALID_HASH) return(1);
 
    prev = m_prev_phi_wafer_vec[index];
    return(0);
  }
  return(1);
}
 
int
PixelID::get_next_in_phi(const IdentifierHash& id, IdentifierHash& next) const {
  unsigned short index = id;
 
  if (index < m_next_phi_wafer_vec.size()) {
    if (m_next_phi_wafer_vec[index] == NOT_VALID_HASH) return(1);
 
    next = m_next_phi_wafer_vec[index];
    return(0);
  }
  return(1);
}
 
int
PixelID::get_prev_in_eta(const IdentifierHash& id, IdentifierHash& prev) const {
  unsigned short index = id;
 
  if (index < m_prev_eta_wafer_vec.size()) {
    if (m_prev_eta_wafer_vec[index] == NOT_VALID_HASH) return(1);
 
    prev = m_prev_eta_wafer_vec[index];
    return(0);
  }
  return(1);
}
 
int
PixelID::get_next_in_eta(const IdentifierHash& id, IdentifierHash& next) const {
  unsigned short index = id;
  if (index < m_next_eta_wafer_vec.size()) {
    if (m_next_eta_wafer_vec[index] == NOT_VALID_HASH) return(1);
 
    next = m_next_eta_wafer_vec[index];
    return(0);
  }
  return(1);
}
 
int
PixelID::init_neighbors() {
  //
  // create a vector(s) to retrieve the hashes for compact ids for
  // wafer neighbors.
  //
 
  ATH_MSG_DEBUG("PixelID::init_neighbors");
 
  m_prev_phi_wafer_vec.clear();
  m_next_phi_wafer_vec.clear();
  m_prev_eta_wafer_vec.clear();
  m_next_eta_wafer_vec.clear();
  m_prev_phi_wafer_vec.resize(m_wafer_hash_max, NOT_VALID_HASH);
  m_next_phi_wafer_vec.resize(m_wafer_hash_max, NOT_VALID_HASH);
  m_prev_eta_wafer_vec.resize(m_wafer_hash_max, NOT_VALID_HASH);
  m_next_eta_wafer_vec.resize(m_wafer_hash_max, NOT_VALID_HASH);
 
  for (unsigned int i = 0; i < m_full_wafer_range.size(); ++i) {
    const Range& range = m_full_wafer_range[i];
    const Range::field& phi_field = range[m_PHI_MODULE_INDEX];
    const Range::field& eta_field = range[m_ETA_MODULE_INDEX];
 
    // save the lowest value of the module offset
    m_ETA_MODULE_OFFSET = (eta_field.get_minimum() < m_ETA_MODULE_OFFSET) ?
                          eta_field.get_minimum() : m_ETA_MODULE_OFFSET;
    ConstRangeIterator rit(range);
    for (const auto & exp_id: rit) {
      ExpandedIdentifier::element_type previous_phi;
      ExpandedIdentifier::element_type next_phi;
      ExpandedIdentifier::element_type previous_eta;
      ExpandedIdentifier::element_type next_eta;
      bool pphi = phi_field.get_previous(exp_id[m_PHI_MODULE_INDEX], previous_phi);
      bool nphi = phi_field.get_next(exp_id[m_PHI_MODULE_INDEX], next_phi);
      bool peta = eta_field.get_previous(exp_id[m_ETA_MODULE_INDEX], previous_eta);
      bool neta = eta_field.get_next(exp_id[m_ETA_MODULE_INDEX], next_eta);
 
      IdContext wcontext = wafer_context();
 
      // First get primary hash id
      IdentifierHash hash_id;
      Identifier id = wafer_id(exp_id[m_BARREL_EC_INDEX],
                               exp_id[m_LAYER_DISK_INDEX],
                               exp_id[m_PHI_MODULE_INDEX],
                               exp_id[m_ETA_MODULE_INDEX]);
      if (get_hash(id, hash_id, &wcontext)) {
        ATH_MSG_FATAL("PixelID::init_neighbors - unable to get hash, exp/compact "
                      << id.getString() << " " << show_to_string(id));
        
        return(1);
      }
 
      // index for the subsequent arrays
      unsigned short index = hash_id;
      assert(hash_id < m_prev_phi_wafer_vec.size());
      assert(hash_id < m_next_phi_wafer_vec.size());
      assert(hash_id < m_prev_eta_wafer_vec.size());
      assert(hash_id < m_next_eta_wafer_vec.size());
 
      if (pphi) {
        // Get previous phi hash id
        ExpandedIdentifier expId = exp_id;
        expId[m_PHI_MODULE_INDEX] = previous_phi;
        Identifier id = wafer_id(expId[m_BARREL_EC_INDEX],
                                 expId[m_LAYER_DISK_INDEX],
                                 expId[m_PHI_MODULE_INDEX],
                                 expId[m_ETA_MODULE_INDEX]);
        if (get_hash(id, hash_id, &wcontext)) {
          ATH_MSG_FATAL("PixelID::init_neighbors - unable to get previous phi hash, exp/compact "
                        << id.getString() << " " << show_to_string(id));
          
          return(1);
        }
        m_prev_phi_wafer_vec[index] = hash_id;
      }
 
      if (nphi) {
        // Get next phi hash id
        ExpandedIdentifier expId = exp_id;
        expId[m_PHI_MODULE_INDEX] = next_phi;
        Identifier id = wafer_id(expId[m_BARREL_EC_INDEX],
                                 expId[m_LAYER_DISK_INDEX],
                                 expId[m_PHI_MODULE_INDEX],
                                 expId[m_ETA_MODULE_INDEX]);
        if (get_hash(id, hash_id, &wcontext)) {
          ATH_MSG_FATAL("PixelID::init_neighbors - unable to get next phi hash, exp/compact "
                        << id.getString() << " " << show_to_string(id));
          
          return(1);
        }
        m_next_phi_wafer_vec[index] = hash_id;
      }
 
      if (peta) {
        // Get previous eta hash id
        ExpandedIdentifier expId = exp_id;
        expId[m_ETA_MODULE_INDEX] = previous_eta;
        Identifier id = wafer_id(expId[m_BARREL_EC_INDEX],
                                 expId[m_LAYER_DISK_INDEX],
                                 expId[m_PHI_MODULE_INDEX],
                                 expId[m_ETA_MODULE_INDEX]);
        if (get_hash(id, hash_id, &wcontext)) {
          ATH_MSG_FATAL("PixelID::init_neighbors - unable to get previous eta hash, exp/compact "
                        << id.getString() << " " << show_to_string(id));
         
          return(1);
        }
        m_prev_eta_wafer_vec[index] = hash_id;
      }
 
      if (neta) {
        // Get next eta hash id
        ExpandedIdentifier expId = exp_id;
        expId[m_ETA_MODULE_INDEX] = next_eta;
        Identifier id = wafer_id(expId[m_BARREL_EC_INDEX],
                                 expId[m_LAYER_DISK_INDEX],
                                 expId[m_PHI_MODULE_INDEX],
                                 expId[m_ETA_MODULE_INDEX]);
        if (get_hash(id, hash_id, &wcontext)) {
          ATH_MSG_FATAL("PixelID::init_neighbors - unable to get next eta hash, exp/compact "
                        << id.getString() << " " << show_to_string(id));
         
          return(1);
        }
        m_next_eta_wafer_vec[index] = hash_id;
      }
    }
  }
  return(0);
}
 
int
PixelID::initLevelsFromDict() {
 
  if (!m_dict) {
    ATH_MSG_FATAL("PixelID::initLevelsFromDict - dictionary NOT initialized");
    return(1);
  }
 
  // Find out which identifier field corresponds to each level. Use
  // names to find each field/leve.
 
  m_INDET_INDEX = 999;
  m_PIXEL_INDEX = 999;
  m_BARREL_EC_INDEX = 999;
  m_LAYER_DISK_INDEX = 999;
  m_PHI_MODULE_INDEX = 999;
  m_ETA_MODULE_INDEX = 999;
  m_PHI_INDEX_INDEX = 999;
  m_ETA_INDEX_INDEX = 999;
 
  // Save index to a PIXEL region for unpacking
  ExpandedIdentifier id;
  id << indet_field_value() << pixel_field_value();
  if (m_dict->find_region(id, m_pixel_region_index)) {
    ATH_MSG_FATAL("PixelID::initLevelsFromDict - unable to find pixel region index: id, reg "
                  << (std::string)id << " " << m_pixel_region_index);
   
    return(1);
  }
 
  // Get levels
  const IdDictField* field = m_dict->find_field("subdet");
  if (field) {
    m_INDET_INDEX = field->index();
  } else {
    ATH_MSG_FATAL("PixelID::initLevelsFromDict - unable to find 'subdet' field");
   
    return(1);
  }
 
  field = m_dict->find_field("part");
  if (field) {
    m_PIXEL_INDEX = field->index();
  } else {
    ATH_MSG_FATAL("PixelID::initLevelsFromDict - unable to find 'part' field");
    return(1);
  }
 
  field = m_dict->find_field("barrel_endcap");
  if (field) {
    m_BARREL_EC_INDEX = field->index();
  } else {
    ATH_MSG_FATAL("PixelID::initLevelsFromDict - unable to find 'barrel_endcap' field");
    return(1);
  }
 
  field = m_dict->find_field("layer");
  if (field) {
    m_LAYER_DISK_INDEX = field->index();
  } else {
    ATH_MSG_FATAL("PixelID::initLevelsFromDict - unable to find 'layer' field");
    return(1);
  }
 
  field = m_dict->find_field("phi_module");
  if (field) {
    m_PHI_MODULE_INDEX = field->index();
  } else {
    ATH_MSG_FATAL("PixelID::initLevelsFromDict - unable to find 'phi_module' field");
    return(1);
  }
  field = m_dict->find_field("eta_module");
  if (field) {
    m_ETA_MODULE_INDEX = field->index();
  } else {
    ATH_MSG_FATAL("PixelID::initLevelsFromDict - unable to find 'eta_module' field");
    return(1);
  }
  field = m_dict->find_field("phi_index");
  if (field) {
    m_PHI_INDEX_INDEX = field->index();
  } else {
    ATH_MSG_FATAL("PixelID::initLevelsFromDict - unable to find 'phi_index' field");
    return(1);
  }
  field = m_dict->find_field("eta_index");
  if (field) {
    m_ETA_INDEX_INDEX = field->index();
  } else {
    ATH_MSG_FATAL("PixelID::initLevelsFromDict - unable to find 'eta_index' field");
    return(1);
  }
 
  // Set the field implementations: for bec, lay/disk, eta/phi mod
  // there are two kinds - shifted and non-shifted
 
  const IdDictRegion& region = m_dict->region(m_pixel_region_index);
 
  m_impl[kIndet] = region.implementation(m_INDET_INDEX);
  m_impl[kPixel] = region.implementation(m_PIXEL_INDEX);
  m_impl[kBec] = region.implementation(m_BARREL_EC_INDEX);
  m_impl[kLayDisk] = region.implementation(m_LAYER_DISK_INDEX);
  m_impl[kPhiMod] = region.implementation(m_PHI_MODULE_INDEX);
  m_impl[kEtaMod] = region.implementation(m_ETA_MODULE_INDEX);
  m_impl[kPhiIndex] = region.implementation(m_PHI_INDEX_INDEX);
  m_impl[kEtaIndex] = region.implementation(m_ETA_INDEX_INDEX);
 
 
  ATH_MSG_DEBUG("decode index and bit fields for each level:");
  for (int i{};i != nImplementations; ++i){
    ATH_MSG_DEBUG( std::left << std::setw(15) << m_implNames[i] << m_impl[i]);
  }
  
  if (msgLvl(MSG::DEBUG)){ 
    for (int i{};i != nImplementations; ++i){
      std::cout<< formatOutput(m_implNames[i], m_impl[i]);
      m_impl[i].ored_field().show();
    }
    
    //
    std::cout << "PixelID::initLevelsFromDict - found levels \n";
    std::cout << "subdet        " << m_INDET_INDEX << "\n";
    std::cout << "part          " << m_PIXEL_INDEX << "\n";
    std::cout << "barrel_endcap " << m_BARREL_EC_INDEX << "\n";
    std::cout << "layer or disk " << m_LAYER_DISK_INDEX << "\n";
    std::cout << "phi_module    " << m_PHI_MODULE_INDEX << "\n";
    std::cout << "eta_module    " << m_ETA_MODULE_INDEX << "\n";
    std::cout << "phi_index     " << m_PHI_INDEX_INDEX << "\n";
    std::cout << "eta_index     " << m_ETA_INDEX_INDEX << "\n";
  }
  return(0);
}
 
PixelID::size_type
PixelID::wafer_hash_max() const {
  return m_wafer_hash_max;
}
 
PixelID::size_type
PixelID::pixel_hash_max() const {
  return m_pixel_hash_max;
}
 
PixelID::const_id_iterator PixelID::wafer_begin() const {
  return(m_wafer_vec.begin());
}
 
PixelID::const_id_iterator PixelID::wafer_end() const {
  return(m_wafer_vec.end());
}
 
PixelID::const_expanded_id_iterator PixelID::pixel_begin() const {
  return(m_full_pixel_range.factory_begin());
}
 
PixelID::const_expanded_id_iterator PixelID::pixel_end() const {
  return(m_full_pixel_range.factory_end());
}
 
void
PixelID::get_expanded_id(const Identifier& id,
                         ExpandedIdentifier& exp_id,
                         const IdContext* context) const {
  exp_id.clear();
  exp_id = m_baseExpandedIdentifier;
  exp_id << barrel_ec(id)
         << layer_disk(id)
         << phi_module(id)
         << eta_module(id);
  if (!context || context->end_index() == m_ETA_INDEX_INDEX) {
    exp_id << phi_index(id)
           << eta_index(id);
  }
}
 
// From hash get Identifier
int
PixelID::get_id(const IdentifierHash& hash_id,
                Identifier& id,
                const IdContext* context) const {
  int result = 1;
 
  size_t begin = (context) ? context->begin_index() : 0;
  // cannot get hash if end is 0:
  size_t end = (context) ? context->end_index()  : 0;
 
  if (0 == begin) {
    // No hashes yet for ids with prefixes
    if (m_ETA_MODULE_INDEX == end) {
      if (hash_id < (unsigned int) (m_wafer_vec.end() - m_wafer_vec.begin())) {
        id = m_wafer_vec[hash_id];
        result = 0;
      }
    } else if (m_ETA_INDEX_INDEX == end) {
      // Do not know how to calculate pixel id from hash yet!!
      result = 1;
    }
  }
  return(result);
}
 
int
PixelID::get_hash(const Identifier& id,
                  IdentifierHash& hash_id,
                  const IdContext* context) const {
  // Get the hash code from either a vec (for wafers) or calculate
  // it (pixels). For the former, we convert to compact and call
  // get_hash again. For the latter, we calculate the hash from the
  // Identifier.
 
  int result = 1;
 
  hash_id = 0;
  size_t begin = (context) ? context->begin_index() : 0;
  size_t end = (context) ? context->end_index()  : 0;
  if (0 == begin) {
    // No hashes yet for ids with prefixes
    if (m_ETA_MODULE_INDEX == end) {
      hash_id = wafer_hash(id);
      if (hash_id.is_valid()) result = 0;
    } else if (context && context->end_index() == m_ETA_INDEX_INDEX) {
      // Must calculate for pixel hash
      ExpandedIdentifier new_id;
      get_expanded_id(id, new_id, context);
      hash_id = m_full_pixel_range.cardinalityUpTo(new_id);
      result = 0;
    }
  }
  return(result);
}
 
void
PixelID::test_wafer_packing() const {
 
  if (m_dict) {
    int nids = 0;
    IdContext context = wafer_context();
    const_id_iterator first = m_wafer_vec.begin();
    const_id_iterator last = m_wafer_vec.end();
    for (; first != last; ++first, ++nids) {
      Identifier id = (*first);
      ExpandedIdentifier expId;
      get_expanded_id(id, expId, &context);
      Identifier new_id = wafer_id(expId[m_BARREL_EC_INDEX],
                                   expId[m_LAYER_DISK_INDEX],
                                   expId[m_PHI_MODULE_INDEX],
                                   expId[m_ETA_MODULE_INDEX]);
      if (id != new_id) {
        ATH_MSG_ERROR("PixelID::test_wafer_packing: new and old compact id not equal. New/old/expanded ids "
                      << show_to_string(new_id) << " " << show_to_string(id) << " "
                      << (std::string) expId);
        
        continue;
      }
    }
 
    nids = 0;
    context = pixel_context();
    const_expanded_id_iterator first_pixel = pixel_begin();
    const_expanded_id_iterator last_pixel = pixel_end();
    for (; first_pixel != last_pixel && nids < 1000; ++first_pixel, ++nids) {
      const ExpandedIdentifier& exp_id = *first_pixel;
      ExpandedIdentifier new_exp_id;
 
      Identifier id = wafer_id(exp_id[m_BARREL_EC_INDEX],
                               exp_id[m_LAYER_DISK_INDEX],
                               exp_id[m_PHI_MODULE_INDEX],
                               exp_id[m_ETA_MODULE_INDEX]);
 
      get_expanded_id(id, new_exp_id, &context);
      if (exp_id[0] != new_exp_id[0] ||
          exp_id[1] != new_exp_id[1] ||
          exp_id[2] != new_exp_id[2] ||
          exp_id[3] != new_exp_id[3] ||
          exp_id[4] != new_exp_id[4] ||
          exp_id[5] != new_exp_id[5]) {
        ATH_MSG_ERROR("PixelID::test_wafer_packing: new and old expanded ids not equal. New/old/compact ids "
                      << (std::string) new_exp_id
                      << " " << (std::string) exp_id
                      << " " << show_to_string(id));
        
      }
 
      Identifier pid = pixel_id(exp_id[m_BARREL_EC_INDEX],
                                exp_id[m_LAYER_DISK_INDEX],
                                exp_id[m_PHI_MODULE_INDEX],
                                exp_id[m_ETA_MODULE_INDEX],
                                exp_id[m_PHI_INDEX_INDEX],
                                exp_id[m_ETA_INDEX_INDEX]);
      Identifier pid1 = pixel_id(barrel_ec(pid),
                                 layer_disk(pid),
                                 phi_module(pid),
                                 eta_module(pid),
                                 phi_index(pid),
                                 eta_index(pid));
      if (pid != pid1) {
        ATH_MSG_ERROR("PixelID::test_wafer_packing: new and old pixel ids not equal. New/old ids "
                      << " " << show_to_string(pid1) << " "
                      << show_to_string(pid));
       
      }
    }
 
    ATH_MSG_DEBUG("PixelID::test_wafer_packing: Successfully tested " << nids << " ids.");
   
  } else {
    ATH_MSG_ERROR("PixelID::test_wafer_packing: Unable to test wafer is packing - no dictionary has been defined.");
   
  }
}
 
 
IdContext
PixelID::wafer_context() const {
  ExpandedIdentifier id;
 
  return(IdContext(id, 0, m_ETA_MODULE_INDEX));
}
 
 
IdContext
PixelID::pixel_context() const {
  // For pixel only, the prefix is the first two levels
  return(IdContext(m_baseExpandedIdentifier, m_BARREL_EC_INDEX, m_ETA_INDEX_INDEX));
}