CaloDM_ID.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "CaloIdentifier/CaloDM_ID.h"
#include "IdDict/IdDictField.h"
#include "IdDict/IdDictMgr.h"
#include "IdDict/IdDictRegion.h"
#include "IdDict/IdDictDictionary.h"
#include "AtlasDetDescr/AtlasDetectorID.h"
#include "CxxUtils/StrFormat.h"
#include "Identifier/IdentifierHash.h"
#include "Identifier/RangeIterator.h"
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <set>
#include <string>
 
 
using CxxUtils::strformat;
 
 
CaloDM_ID::CaloDM_ID() :
    AtlasDetectorID("CaloDM_ID", "DM_Reg")
  , m_calodm_region_index(0)
  , m_CALO_INDEX(999) 
  , m_DETZSIDE_INDEX(999)
  , m_DMAT_INDEX(999) 
  , m_SAMPLING_INDEX(999) 
  , m_REGION_INDEX(999) 
  , m_ETA_INDEX(999)
  , m_PHI_INDEX(999)
  , m_dict(nullptr)
  , m_lar_zone_hash_max(0) 
  , m_lar_region_hash_max(0)
  , m_tile_zone_hash_max(0) 
  , m_tile_region_hash_max(0) 
 
{
 
}
 
CaloDM_ID:: ~CaloDM_ID()= default;
 
 
int CaloDM_ID::eta_min(const Identifier& id) const
{
  ExpandedIdentifier expId;
  IdContext cntxt = region_context();
  if(!get_expanded_id(id, expId, &cntxt)) {
    int result = -999;
    const MultiRange * zoneRange = nullptr ;
    if ( is_lar(id) ) {
      zoneRange = &(m_full_lar_zone_range) ;
    } else {
      assert ( is_tile(id) );
      zoneRange = &(m_full_tile_zone_range) ;
    }
    for (unsigned int i = 0; i < (*zoneRange).size(); ++i) {
      const Range& range = (*zoneRange)[i];
      if (range.match(expId)) {
    const Range::field& eta_field = range[m_ETA_INDEX];
    if (not eta_field.empty()) {
      int etamin = eta_field.get_minimum();
      if (-999 == result) {
        result = etamin;
      }
      else {
        if (etamin < result) result = etamin;
      }
    }
      }
    }
    return (result);
  }
  return (-999);
}
 
int CaloDM_ID::eta_max(const Identifier& id) const
{
  ExpandedIdentifier expId;
  IdContext cntxt = region_context();
  if(!get_expanded_id(id, expId, &cntxt)) {
    int result = -999;
    const MultiRange * zoneRange = nullptr ;
    if ( is_lar(id) ) {
      zoneRange = &(m_full_lar_zone_range) ;
    } else {
      assert ( is_tile(id) );
      zoneRange = &(m_full_tile_zone_range) ;
    }
    for (unsigned int i = 0; i < (*zoneRange).size(); ++i) {
      const Range& range = (*zoneRange)[i];
      if (range.match(expId)) {
    const Range::field& eta_field = range[m_ETA_INDEX];
    if (not eta_field.empty()) {
      int etamax = eta_field.get_maximum();
      if (result < etamax) result = etamax;
    }
      }
    }
    return (result);
  }
  return (-999);  // default
}
 
int CaloDM_ID::phi_min(const Identifier& id) const
{
  ExpandedIdentifier expId;
  IdContext cntxt = region_context();
  if(!get_expanded_id(id, expId, &cntxt)) {
    int result = -999;
    const MultiRange * zoneRange = nullptr ;
    if ( is_lar(id) ) {
      zoneRange = &(m_full_lar_zone_range) ;
    } else {
      assert ( is_tile(id) );
      zoneRange = &(m_full_tile_zone_range) ;
    }
    for (unsigned int i = 0; i < (*zoneRange).size(); ++i) {
      const Range& range = (*zoneRange)[i];
      if (range.match(expId)) {
    const Range::field& phi_field = range[m_PHI_INDEX];
    if (not phi_field.empty()) {
      int phimin = phi_field.get_minimum();
      if (-999 == result) {
        result = phimin;
      }
      else {
        if (phimin < result) result = phimin;
      }
    }
      }
    }
    return (result);
  }
  return (-999);
}
 
int CaloDM_ID::phi_max(const Identifier& id) const
{
  ExpandedIdentifier expId;
  IdContext cntxt = zone_context();
  if(!get_expanded_id(id, expId, &cntxt)) {
    int result = -999;
    const MultiRange * zoneRange = nullptr ;
    if ( is_lar(id) ) {
      zoneRange = &(m_full_lar_zone_range) ;
    } else {
      assert ( is_tile(id) );
      zoneRange = &(m_full_tile_zone_range) ;
    }
    for (unsigned int i = 0; i < (*zoneRange).size(); ++i) {
      const Range& range = (*zoneRange)[i];
      if (range.match(expId)) {
    const Range::field& phi_field = range[m_PHI_INDEX];
    if (not phi_field.empty()) {
      int phimax = phi_field.get_maximum();
      if (result < phimax) result = phimax;
    }
      }
    }
    return (result);
  }
  return (-999);  // default
}
 
 
/*===================================================================*/
int  CaloDM_ID::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 the Calorimeter dictionary
  if (register_dict_tag(dict_mgr, "Calorimeter")) return(1);
 
  m_dict = dict_mgr.find_dictionary ("Calorimeter"); 
  if(!m_dict) {
    ATH_MSG_ERROR(" initialize_from_dict - cannot access Calorimeter dictionary ");
    return 1;
  }
  
  // Initialize the field indices
  if(initLevelsFromDict()) return (1);
 
 
  // Find values for the calo, LArDM (neg) and TileDM (neg) fields
  int caloValue   = -1;
  if (m_dict->get_label_value("subdet", "Calorimeter", caloValue)) 
    {
      ATH_MSG_ERROR("Could not get value for label 'Calorimeter' of field 'subdet' in dictionary "
                    << m_dict->name());
      return (1);
    }
 
  int lardmCaloValue   = -1;
  // negative half
  if (m_dict->get_label_value("DetZside", "negative_DMLar_side", lardmCaloValue)) 
    {
      ATH_MSG_ERROR("Could not get value for label 'negative_DMLar_side' of field 'DetZside' in dictionary "
                    << m_dict->name());
      return (1);
    }
 
  int tiledmCaloValue   = -1;
  // negative half
  if (m_dict->get_label_value("DetZside", "negative_DMTile_side", tiledmCaloValue)) 
    {
      ATH_MSG_ERROR("Could not get value for label 'negative_DMTile_side' of field 'DetZside' in dictionary "
                    << m_dict->name());
    return (1);
    }
 
 
  // Set up id for region and range prefix
 
  // NOTE: negative value is good enough to get multirange since the
  // regions are symmetric in +/-eta
 
  // LAr
  ExpandedIdentifier reg_id;
  reg_id.add(caloValue);
  reg_id.add(lardmCaloValue); 
  Range prefix;
  m_full_lar_region_range = m_dict->build_multirange(reg_id, prefix, "DMregion");
  m_full_lar_zone_range = m_dict->build_multirange(reg_id, prefix, "phivalue");
    
  // Tile
  ExpandedIdentifier reg_id2;
  reg_id2.add(caloValue);
  reg_id2.add(tiledmCaloValue); 
  Range prefix2;
  m_full_tile_region_range = m_dict->build_multirange(reg_id2, prefix2, "DMregion");
  m_full_tile_zone_range = m_dict->build_multirange(reg_id2, prefix2, "phivalue");
 
  ATH_MSG_DEBUG("CaloDM_ID::initialize_from_dict : ");
  ATH_MSG_DEBUG("LAr zone range -> " << (std::string)m_full_lar_zone_range);
  ATH_MSG_DEBUG("LAr region range -> " << (std::string)m_full_lar_region_range);
  ATH_MSG_DEBUG("Tile zone range -> " << (std::string)m_full_tile_zone_range);
  ATH_MSG_DEBUG("Tile region range -> " << (std::string)m_full_tile_region_range);
 
 
  // Setup the hash tables
  if(init_lar_hashes()) return (1);
  if(init_tile_hashes()) return (1);
  
  // Setup for hash calculation
 
  // Regions have uniform eta/phi granularity 
  // The lookup table only needs to contain the
  // hash offset for each region, the first eta index
  // and the number of phi cells.
 
  // The implementation requires:
 
  //   1) a lookup table for each region containing hash offset,
  //      etamin and nphi
  //   2) a decoder to access the "index" corresponding to the
  //      pnz/samp/reg fields. These fields use 6 bits, so the
  //      vector has a length of 64 for 16 regions.
 
 
  // Create decoder for fields pnz to region
  IdDictFieldImplementation::size_type bits = 
    m_calodm_impl.bits() +
    m_dmat_impl.bits() +
    m_sampling_impl.bits() +
    m_region_impl.bits();
  IdDictFieldImplementation::size_type bits_offset = m_calodm_impl.bits_offset();
  m_pnz_reg_impl.set_bits(bits, bits_offset);
  int size = (1 << bits);
 
  //      std::cout << "pnz_reg        "  
  //        << m_pnz_reg_impl.show_to_string() << std::endl; 
  //      std::cout << "size " << size << std::endl;
    
  //    std::cout << "pnz_reg "  << m_pnz_reg_impl.decode_index()  << " " 
  //      << (std::string)m_pnz_reg_impl.ored_field()  << " " 
  //      << std::hex << m_pnz_reg_impl.mask() << " " 
  //      << m_pnz_reg_impl.zeroing_mask() << " " 
  //      << std::dec << m_pnz_reg_impl.shift()
  //      << " " << m_pnz_reg_impl.bits() << " " <<m_pnz_reg_impl.bits_offset()
  //      << std::endl;
  
 
  // Set up vector as lookup table for lar hash calculation. 
  m_lar_hash_calcs.resize(size);
 
  for (unsigned int i = 0; i < m_lar_region_hash_max; ++i) {
    Identifier regId = lar_region_id(i) ;
    HashCalc hc;
    int etamin = eta_min(regId);
    if(etamin < 0) 
      {
        etamin = 0;
        ATH_MSG_WARNING(" seting etamin to 0 because actual value not found for regId " << show_to_string(regId));
      }
    Identifier min = zone_id ( regId, etamin, 0);
    IdentifierHash min_hash = lar_zone_hash_binary_search(min);
    hc.m_hash   = min_hash;
    hc.m_etamin = etamin;
    hc.m_nphi   = phi_max(min)+1 ;
    m_lar_hash_calcs[m_pnz_reg_impl.unpack(min)] = hc;
 
    if (m_pnz_reg_impl.unpack(min) >= size) 
      {
        ATH_MSG_WARNING("min > " << size << " "
                        << i << " "
                        << show_to_string(min) << " " 
                        << m_pnz_reg_impl.unpack(min));
      }
  }
 
  // Check lar hash calculation
  for (unsigned int i = 0; i < m_lar_zone_hash_max; ++i) {
    Identifier id = lar_zone_id(i);
    if (lar_zone_hash(id) != i) 
      {
        ATH_MSG_ERROR("lar zone ranges, id, hash, i = "
                      << show_to_string(id) << ", " 
                      << lar_zone_hash(id) << ", " 
                      << i);
      }
  }
  
  // Set up vector as lookup table for tile hash calculation. 
  m_tile_hash_calcs.resize(size);
 
  for (unsigned int i = 0; i < m_tile_region_hash_max; ++i) {
    Identifier regId = tile_region_id(i) ;
    HashCalc hc;
    int etamin = eta_min(regId);
    if(etamin < 0) 
      {
        etamin = 0;
        ATH_MSG_WARNING("seting etamin to 0 because actual value not found for regId " << show_to_string(regId));
      }
    Identifier min = zone_id ( regId, etamin, 0);
    IdentifierHash min_hash = tile_zone_hash_binary_search(min);
    hc.m_hash   = min_hash;
    hc.m_etamin = etamin;
    hc.m_nphi   = phi_max(min)+1 ;
    m_tile_hash_calcs[m_pnz_reg_impl.unpack(min)] = hc;
 
    if (m_pnz_reg_impl.unpack(min) >= size) 
      {
        ATH_MSG_WARNING("min > " << size << " "
                        << i << " "
                        << show_to_string(min) << " "
                        << m_pnz_reg_impl.unpack(min) << " ");
      }
  }
 
  // Check tile hash calculation
  for (unsigned int i = 0; i < m_tile_zone_hash_max; ++i) {
    Identifier id = tile_zone_id(i);
    if (tile_zone_hash(id) != i) 
      {
        ATH_MSG_ERROR("tile zone ranges, id, hash, i = "
                      << show_to_string(id) << ", "
                      << tile_zone_hash(id) << ", "
                      << i);
      }
  }
  return 0;
 
}
 
  int  CaloDM_ID::get_expanded_id  (const Identifier& id, ExpandedIdentifier& exp_id, const IdContext* context) const
{
    // We assume that the context is >= region
    exp_id.clear();
    exp_id << calo_field_value()
       << pos_neg_z(id)
           << dmat(id)
       << sampling(id)
       << region(id);
    if(context && context->end_index() >= m_ETA_INDEX) {
    exp_id << eta(id);
    if(context->end_index() >= m_PHI_INDEX) {
        exp_id << phi(id);
    }
    }
    return (0);
}
 
IdContext       
CaloDM_ID::region_context             () const
{
    ExpandedIdentifier id;
    return {id, 0, m_REGION_INDEX};
}
 
IdContext       
CaloDM_ID::zone_context              () const
{
    ExpandedIdentifier id;
    return {id, 0, m_PHI_INDEX};
}
 
 
void CaloDM_ID::lar_region_id_checks (int pos_neg_z, int dmat, int sampling, int region)const
{
  // Fill expanded id
  ExpandedIdentifier id(calo_exp());
  id << pos_neg_z << dmat << sampling << region ;
  
  if (!m_full_lar_region_range.match(id)) { 
    std::string errorMessage = "CaloDM_ID::lar_region_id() result is not OK: ID, range = "
      + std::string(id) + " , " + (std::string)m_full_lar_zone_range;
    throw CaloID_Exception(errorMessage , 3);
  }
}
 
void CaloDM_ID::tile_region_id_checks (int pos_neg_z, int dmat, int sampling, int region)const
{
  // Fill expanded id
  ExpandedIdentifier id(calo_exp());
  id << pos_neg_z << dmat << sampling << region ;
  
  if (!m_full_tile_region_range.match(id)) { 
    std::string errorMessage = "CaloDM_ID::tile_region_id() result is not OK: ID, range = "
      + std::string(id) + " , " + (std::string)m_full_tile_zone_range;
    throw CaloID_Exception(errorMessage , 3);
  }
}
 
 
 
 void CaloDM_ID::lar_zone_id_checks   ( int pos_neg_z, int dmat, int sampling, int region,
                    int eta,       int phi ) const
{  
  // Fill expanded id
  ExpandedIdentifier id(calo_exp());
  id << pos_neg_z << dmat << sampling << region << eta << phi;
 
  if (!m_full_lar_zone_range.match(id)) { 
    std::string errorMessage = "CaloDM_ID::lar_zone_id() result is not OK: ID, range = "
      + std::string(id) + " , " + (std::string)m_full_lar_zone_range;
    throw CaloID_Exception(errorMessage , 4);
  }
}
 
 void CaloDM_ID::tile_zone_id_checks   ( int pos_neg_z, int dmat, int sampling, int region,
                     int eta,       int phi ) const
{  
  // Fill expanded id
  ExpandedIdentifier id(calo_exp());
  id << pos_neg_z << dmat << sampling << region << eta << phi;
 
  if (!m_full_tile_zone_range.match(id)) { 
    std::string errorMessage = "CaloDM_ID::tile_zone_id() result is not OK: ID, range = "
      + std::string(id) + " , " + (std::string)m_full_tile_zone_range;
    throw CaloID_Exception(errorMessage , 4);
  }
}
 
 
void CaloDM_ID::zone_id_checks   ( const Identifier& regionId,
                   int eta,  int phi ) const
{
  // Fill expanded id
    ExpandedIdentifier id; 
 
    IdContext context = region_context();
    if (get_expanded_id(regionId, id, &context)) {
      std::string errorMessage = "CaloDM_ID::zone_id(regionId) result is not OK: ID= "
                           + show_to_string(regionId) ;
      throw CaloID_Exception(errorMessage , 4);
    }
 
    id << eta << phi;
 
    if(is_lar(regionId)) {
      if (!m_full_lar_zone_range.match(id)) {
    std::string errorMessage = "CaloDM_ID::zone_id(regionId) result is not OK: ID, range = "
      + std::string(id) + " , " + (std::string)m_full_lar_zone_range;
    throw CaloID_Exception(errorMessage , 4);
      }
    } else if(is_tile(regionId)) {
      if (!m_full_tile_zone_range.match(id)) {
    std::string errorMessage = "CaloDM_ID::zone_id(regionId) result is not OK: ID, range = "
      + std::string(id) + " , " + (std::string)m_full_tile_zone_range;
    throw CaloID_Exception(errorMessage , 4);
      }
    }
}
 
 
/*=======================================*/
int   CaloDM_ID::initLevelsFromDict()
/*=======================================*/
{
  std::string strg;
  std::stringstream strm;
  if(!m_dict) {
    ATH_MSG_ERROR("initLevelsFromDict - dictionary NOT initialized ");
    return (1);
  }
 
  // Find out which identifier field corresponds to each level.
 
  m_CALO_INDEX       = 999 ;
  m_DETZSIDE_INDEX   = 999 ;
  m_DMAT_INDEX       = 999 ;   
  m_SAMPLING_INDEX   = 999 ; 
  m_REGION_INDEX     = 999 ;
  m_ETA_INDEX        = 999 ;
  m_PHI_INDEX        = 999 ;
 
  // Save index to a LArDM region for unpacking - search with region name
  const IdDictRegion* reg = m_dict->find_region("DM_4_1_0_0");
  if (reg) 
    {
      m_calodm_region_index = reg->index();
    }
  else
    {
      ATH_MSG_ERROR("initLevelsFromDict - unable to find lardm region ");
      return (1);
    }
  
  
  // Fing a CaloDM region
  const IdDictField* field = m_dict->find_field("subdet") ;
  if (field) {
    m_CALO_INDEX = field->index();
  }
  else 
    {
      ATH_MSG_ERROR("initLevelsFromDict - unable to find 'subdet' field ");
      return (1);
    }
  
  field = m_dict->find_field("DetZside") ;
  if (field) 
    {
      m_DETZSIDE_INDEX = field->index();
    }
  else
    {
      ATH_MSG_ERROR("initLevelsFromDict - unable to find 'DetZside' field ");
      return (1);
    }
 
  field = m_dict->find_field("DMvalue") ;
  if (field) 
    {
      m_DMAT_INDEX = field->index();
    }
  else 
    {
      ATH_MSG_ERROR("initLevelsFromDict - unable to find 'DMvalue' field ");
      return (1);
    }
 
 
 field = m_dict->find_field("samplingvalue") ;
  if (field) 
    {
      m_SAMPLING_INDEX = field->index();
    }
  else
    {
      ATH_MSG_ERROR("initLevelsFromDict - unable to find 'samplingvalue' field ");
      return (1);
    }
  
  field = m_dict->find_field("DMregion") ;
  if (field) 
    {
      m_REGION_INDEX = field->index();
    }
  else 
    {
      ATH_MSG_ERROR("initLevelsFromDict - unable to find 'DMregion' field ");
      return (1);
    }
 
  field = m_dict->find_field("DMEta") ;
  if (field) {
    m_ETA_INDEX = field->index();
  }
  else 
    {
      ATH_MSG_ERROR("initLevelsFromDict - unable to find 'DMEta' field ");
      return (1);
    }
 
  field = m_dict->find_field("phivalue") ;
  if (field) 
    {
      m_PHI_INDEX = field->index();
    }
  else 
    {
      ATH_MSG_ERROR("initLevelsFromDict - unable to find 'phivalue' field ");
      return (1);
    }
 
 
  // Set the field implementations
 
  const IdDictRegion& region = m_dict->region(m_calodm_region_index);
 
  m_calo_impl     = region.implementation(m_CALO_INDEX);
  m_calodm_impl   = region.implementation(m_DETZSIDE_INDEX);
  m_dmat_impl     = region.implementation(m_DMAT_INDEX);
  m_sampling_impl = region.implementation(m_SAMPLING_INDEX);
  m_region_impl   = region.implementation(m_REGION_INDEX);
  m_eta_impl      = region.implementation(m_ETA_INDEX);
  m_phi_impl      = region.implementation(m_PHI_INDEX);
 
  ATH_MSG_DEBUG("decode index and bit fields for each level: ");
  ATH_MSG_DEBUG("calo      "  << m_calo_impl.show_to_string());
  ATH_MSG_DEBUG("detzside  "  << m_calodm_impl.show_to_string());
  ATH_MSG_DEBUG("dmat      "  << m_dmat_impl.show_to_string());
  ATH_MSG_DEBUG("samp      "  << m_sampling_impl.show_to_string());
  ATH_MSG_DEBUG("reg       "  << m_region_impl.show_to_string());
  ATH_MSG_DEBUG("eta       "  << m_eta_impl.show_to_string());
  ATH_MSG_DEBUG("phi       "  << m_phi_impl.show_to_string());
 
  return(0) ;
}
 
/*=======================================*/
int   CaloDM_ID::init_lar_hashes()
/*=======================================*/
{
  std::string strg;
  std::stringstream strm;
 
  // zone hash
  m_lar_zone_hash_max = m_full_lar_zone_range.cardinality();
  m_lar_zone_vec.resize(m_lar_zone_hash_max);
  unsigned int nids = 0;
  std::set<Identifier> ids;
  for (unsigned int i = 0; i < m_full_lar_zone_range.size(); ++i) {
    const Range& range = m_full_lar_zone_range[i];
    ConstRangeIterator rit(range);
    auto first = rit.begin();
    auto last  = rit.end();
    for (; first != last; ++first) {
      const ExpandedIdentifier& exp_id = (*first);
      Identifier zon_id = zone_id   ( exp_id[m_DETZSIDE_INDEX],
                      exp_id[m_DMAT_INDEX], 
                      exp_id[m_SAMPLING_INDEX], 
                      exp_id[m_REGION_INDEX] ,
                      exp_id[m_ETA_INDEX] ,
                      exp_id[m_PHI_INDEX] ) ;
      if(!(ids.insert(zon_id)).second)
    {
      ATH_MSG_ERROR(" init_lar_hashes "
                    << " duplicated id for lardm id. nids= " << nids
                    << " compact Id  " << show_to_string(zon_id));
    }
      nids++;
    }
  }
  if(ids.size() != m_lar_zone_hash_max) 
    {
      ATH_MSG_ERROR(" init_lar_hashes "
                    << " set size NOT EQUAL to hash max. size " << ids.size()
                    << " hash max " << m_lar_zone_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_lar_zone_vec.size(); ++first) {
    m_lar_zone_vec[nids] = (*first) ;
    nids++;
  }
 
  // region hash
  m_lar_region_hash_max = m_full_lar_region_range.cardinality();
  m_lar_region_vec.resize(m_lar_region_hash_max);
  nids = 0;
  ids.clear();
  for (unsigned int i = 0; i < m_full_lar_region_range.size(); ++i) {
    const Range& range = m_full_lar_region_range[i];
    ConstRangeIterator rit(range);
    auto first = rit.begin();
    auto last  = rit.end();
    for (; first != last; ++first) {
      const ExpandedIdentifier& exp_id = (*first);
      //     std::cout << "exp_id = " << (std::string)exp_id << std::endl;
      Identifier reg_id = region_id   ( exp_id[m_DETZSIDE_INDEX],
                    exp_id[m_DMAT_INDEX], 
                    exp_id[m_SAMPLING_INDEX], 
                    exp_id[m_REGION_INDEX] );
      if(!(ids.insert(reg_id)).second)
    {
      ATH_MSG_ERROR(" init_lar_hashes (regions) "
                    << " duplicated id for region id. nids= " << nids
                    << " compact Id  " << show_to_string(reg_id));
    }
      nids++;
    }
  }
  if(ids.size() != m_lar_region_hash_max) 
    {
      ATH_MSG_ERROR(" init_lar_hashes "
          << " set size NOT EQUAL to region hash max. size " << ids.size()
                    << " region hash max " << m_lar_region_hash_max);
      return (1);
    }
 
  nids=0;
  first = ids.begin();
  last  = ids.end();
  for (;first != last && nids < m_lar_region_vec.size(); ++first) {
    m_lar_region_vec[nids] = (*first) ;
    nids++;
  }
 
  return (0);
                   
}
 
/*=====================================*/
int   CaloDM_ID::init_tile_hashes()
/*=====================================*/
{
  std::string strg;
  std::stringstream strm;
 
  // zone hash
  m_tile_zone_hash_max = m_full_tile_zone_range.cardinality();
  m_tile_zone_vec.resize(m_tile_zone_hash_max);
  unsigned int nids = 0;
  std::set<Identifier> ids;
  for (unsigned int i = 0; i < m_full_tile_zone_range.size(); ++i) {
    const Range& range = m_full_tile_zone_range[i];
    ConstRangeIterator rit(range);
    auto first = rit.begin();
    auto last  = rit.end();
    for (; first != last; ++first) {
      const ExpandedIdentifier& exp_id = (*first);
      Identifier zon_id = zone_id   ( exp_id[m_DETZSIDE_INDEX],
                      exp_id[m_DMAT_INDEX], 
                      exp_id[m_SAMPLING_INDEX], 
                      exp_id[m_REGION_INDEX] ,
                      exp_id[m_ETA_INDEX] ,
                      exp_id[m_PHI_INDEX] ) ;
      /*
      std::cout << "detZside,dmat,samp,reg,eta,phi= " 
        <<exp_id[m_DETZSIDE_INDEX] << ", "
        <<exp_id[m_DMAT_INDEX] << ", "
        <<exp_id[m_SAMPLING_INDEX] << ", "
        <<exp_id[m_REGION_INDEX] << ", "
        <<exp_id[m_ETA_INDEX] << ", "
        <<exp_id[m_PHI_INDEX];
      std::cout << std::endl;
      std::cout << "tile zon_id= " << show_to_string(zon_id) << std::endl;
      */
      if(!(ids.insert(zon_id)).second)
    {
      ATH_MSG_ERROR(" init_tile_hashes "
                    << " duplicated id for tiledm id. nids= " << nids
                    << " compact Id  " << show_to_string(zon_id));
    }
      nids++;
    }
  }
  if(ids.size() != m_tile_zone_hash_max) 
    {
      ATH_MSG_ERROR(" init_tile_hashes "
                    << " set size NOT EQUAL to hash max. size " << ids.size()
                    << " hash max " << m_tile_zone_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_tile_zone_vec.size(); ++first) {
    m_tile_zone_vec[nids] = (*first) ;
    nids++;
  }
 
  // region hash
  m_tile_region_hash_max = m_full_tile_region_range.cardinality();
  m_tile_region_vec.resize(m_tile_region_hash_max);
  nids = 0;
  ids.clear();
  for (unsigned int i = 0; i < m_full_tile_region_range.size(); ++i) {
    const Range& range = m_full_tile_region_range[i];
    ConstRangeIterator rit(range);
    auto first = rit.begin();
    auto last  = rit.end();
    for (; first != last; ++first) {
      const ExpandedIdentifier& exp_id = (*first);
      //     std::cout << "exp_id = " << (std::string)exp_id << std::endl;
      Identifier reg_id = region_id   ( exp_id[m_DETZSIDE_INDEX],
                    exp_id[m_DMAT_INDEX], 
                    exp_id[m_SAMPLING_INDEX], 
                    exp_id[m_REGION_INDEX] );
      if(!(ids.insert(reg_id)).second)
        {
          ATH_MSG_ERROR(" init_tile_hashes (regions) "
                        << " duplicated id for region id. nids= " << nids
                        << " compact Id  " << show_to_string(reg_id));
        }
      nids++;
    }
  }
  if(ids.size() != m_tile_region_hash_max) 
    {
      ATH_MSG_ERROR(" init_tile_hashes "
                    << " set size NOT EQUAL to region hash max. size " << ids.size()
                    << " region hash max " << m_tile_region_hash_max);
      return (1);
    }
 
  nids=0;
  first = ids.begin();
  last  = ids.end();
  for (;first != last && nids < m_tile_region_vec.size(); ++first) {
    m_tile_region_vec[nids] = (*first) ;
    nids++;
  }
 
  return (0);
                   
}