TileTBID.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
/***************************************************************************
 Access to Tile Calorimeter TB data
 -----------------------------------------
 ***************************************************************************/
 
 
#include "CaloIdentifier/TileTBID.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 "CxxUtils/StrFormat.h"
 
#include <algorithm>
#include <cassert>
#include <cstdio>
#include <iostream>
 
using CxxUtils::strformat;
 
 
TileTBID::TileTBID( )
  : AtlasDetectorID("TileTBID", "tile")
    , m_tile_region_index(0)
    , m_SYSTEM_INDEX(999)
    , m_SECTION_INDEX(999)
    , m_TYPE_INDEX(999)
    , m_MODULE_INDEX(999)
    , m_CHANNEL_INDEX(999)
    , m_dict(nullptr)
    , m_type_hash_max(0)
    , m_module_hash_max(0)
    , m_channel_hash_max(0)
{
}
 
TileTBID::~TileTBID() = default;
 
//
// TileTBID methods
//
std::string
TileTBID::to_string( const Identifier & id, int level ) const
{
  IdContext context;
  switch (level) {
    case 1: case -3:
    case 2: case -2: context = type_context(); break;
    case 3: case -1: context = module_context(); break;
    case 4: case  0: context = channel_context(); break;
  default:
    return "TileTBID::to_string - unknown context";
  }    
      
  ExpandedIdentifier exp_id;
  if ( get_expanded_id(id,exp_id,&context) ) {
    return "TileTBID::to_string - can not expand ID";
  } else {
    return (std::string)(exp_id);
  }  
}
 
//
// get methods
//
int
TileTBID::get_field ( const Identifier & id, size_type index ) const
{
  int field = 0;
  if(!m_dict->unpack(id, 0, index, m_tile_region_index, field)) {
    return field;
  } else {
    return 0;
  }
}
 
//
// check methods
//
bool               
TileTBID::is_tiletb (const Identifier& id) const
{
    bool result = is_tile(id)
      && ( section(id) == TileTBID::TILE_TESTBEAM );
    
    return result;
}
 
//
// TileCal TB ID
//
Identifier
TileTBID::tiletb_id     ()      const
{
    Identifier compactID(m_base_tile_type);
    return compactID;
}
 
//
// Build type & module id
//
Identifier
TileTBID::type_id       ( int type, bool checks )      const
{
    if(checks) {
    
    // Check that id is within allowed range
 
    // Fill expanded id
    ExpandedIdentifier expId(tile_exp());
    expId << TileTBID::TILE_TESTBEAM << type;
 
    if (!m_full_type_range.match(expId)) { 
        std::string errorMessage = "TileTBID::type_id() result is not OK: ID, range = "
        + std::string(expId) + " , " + (std::string)m_full_type_range;
        throw TileID_Exception(errorMessage , 2);
    }
    }
 
    Identifier compactID(m_base_tile_type);
    m_type_impl.pack (type,compactID);
 
    return (compactID);
}
Identifier
TileTBID::type_id       ( int type )      const
{
  return type_id (type, do_checks());
}
 
 
Identifier
TileTBID::module_id       ( int type, int module, bool checks )       const
{
    if(checks) {
    
    // Check that id is within allowed range
 
    // Fill expanded id
    ExpandedIdentifier expId(tile_exp());
    expId << TileTBID::TILE_TESTBEAM << type << module;
 
    if (!m_full_module_range.match(expId)) { 
        std::string errorMessage = "TileTBID::module_id() result is not OK: ID, range = "
        + std::string(expId) + " , " + (std::string)m_full_type_range;
        throw TileID_Exception(errorMessage , 1);
    }
    }
 
    Identifier compactID(m_base_tile_type);
    m_type_impl.pack (type,compactID);
    m_module_impl.pack (module,compactID);
 
    return (compactID);
}
Identifier
TileTBID::module_id       ( int type, int module )       const
{
  return module_id (type, module, do_checks());
}
 
//
// Build channel id
//
Identifier
TileTBID::channel_id ( int type, int module, int channel, bool checks ) const
{
    if(checks) {
    
    // Check that id is within allowed range
 
    // Fill expanded id
    ExpandedIdentifier expId(tile_exp());
    expId << TileTBID::TILE_TESTBEAM << type << module << channel;
 
    if (!m_full_channel_range.match(expId)) { 
        std::string errorMessage = "TileTBID::channel_id() result is not OK: ID, range = "
        + std::string(expId) + " , " + (std::string)m_full_type_range;
        throw TileID_Exception(errorMessage , 1);
    }
    }
 
    Identifier compactID(m_base_tile_type);
    m_type_impl.pack (type,compactID);
    m_module_impl.pack (module,compactID);
    m_channel_impl.pack   (channel,compactID);
 
    return (compactID);
}
Identifier
TileTBID::channel_id ( int type, int module, int channel ) const
{
  return channel_id (type, module, channel, do_checks());
}
 
Identifier
TileTBID::module_id     ( const Identifier & any_id )   const
{
  Identifier compactId(any_id);
  m_channel_impl.reset(compactId);
  
  return (compactId);
}
 
Identifier
TileTBID::channel_id    ( const Identifier & module_id, 
                          int channel )                     const
{
    Identifier compactId(module_id);
    m_channel_impl.pack(channel,compactId);
 
    if(m_do_checks) {
    
    // Check that id is within allowed range
 
    // Fill expanded id
    ExpandedIdentifier expId;
 
    IdContext context = module_context();
    if (get_expanded_id(compactId, expId, &context)) {
        std::string errorMessage = "TileTBID::channel_id(module_id,channel) result is not OK: ID = "
        + compactId.getString() ;
        throw TileID_Exception(errorMessage , 1);
 
        //      region_id.show();
    }
 
    expId << channel;
 
    if (!m_full_channel_range.match(expId)) { 
        std::string errorMessage = "TileTBID::channel_id() result is not OK: ID, range = "
        + (std::string)expId + " , " + (std::string)m_full_type_range;
        throw TileID_Exception(errorMessage , 1);
    }
    }
 
    return compactId;
}
 
bool TileTBID::module_id  ( const Identifier& type_id,
                          int module, Identifier& module_id ) 
{
  ExpandedIdentifier id; 
  IdContext context = type_context();
  get_expanded_id(type_id, id, &context);
  id << module;
  if (!m_full_module_range.match(id)) { 
    return false;
  }
 
  Identifier compactId(0);
  if (!m_dict->pack32(id,0, id.fields() - 1,compactId)) {
    module_id = compactId;   
  }
  return true;
}
 
bool TileTBID::channel_id       ( const Identifier& type_id,
                          int module, int channel, Identifier& channel_id ) 
{
  ExpandedIdentifier id; 
  IdContext context = type_context();
  get_expanded_id(type_id, id, &context);
  id << module << channel;
  if (!m_full_channel_range.match(id)) { 
    return false;
  }
 
  Identifier compactId(0);
  if (!m_dict->pack32(id,0, id.fields() - 1,compactId)) {
    channel_id = compactId;   
  }
  return true;
}
 
bool TileTBID::channel_id       ( const Identifier& module_id,
                                  int channel, Identifier& channel_id ) 
{
  ExpandedIdentifier id; 
  IdContext context = module_context();
  get_expanded_id(module_id, id, &context);
  id << channel;
  if (!m_full_channel_range.match(id)) { 
    return false;
  }
 
  Identifier compactId(0);
  if (!m_dict->pack32(id,0, id.fields() - 1,compactId)) {
    channel_id = compactId;   
  }
  return true;
}
 
IdContext  
TileTBID::type_context  ()  const
{
    ExpandedIdentifier id;
    return {id, 0, m_TYPE_INDEX};
}
 
IdContext  
TileTBID::module_context  ()  const
{
    ExpandedIdentifier id;
    return {id, 0, m_MODULE_INDEX};
}
 
IdContext  
TileTBID::channel_context     ()  const
{
    ExpandedIdentifier id;
    return {id, 0, m_CHANNEL_INDEX};
}
 
int  TileTBID::get_id     (const IdentifierHash& hash_id, Identifier& id, const IdContext* context ) const
{
  int result = 1;
  id.clear();
 
  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) {
 
    if ( m_CHANNEL_INDEX == end ) {
      if (hash_id < (unsigned int)(m_channel_vec.end() - m_channel_vec.begin())) {
    id = m_channel_vec[hash_id];
    result = 0;
      } else {
        ATH_MSG_ERROR("get_id: channel hash_id is out of range " << hash_id
                      << " => " << m_channel_vec.size());
      }
    } else if ( m_MODULE_INDEX == end ) {
      if (hash_id < (unsigned int)(m_module_vec.end() - m_module_vec.begin())) {
    id = m_module_vec[hash_id];
    result = 0;
      } else {
        ATH_MSG_ERROR("get_id: module hash_id is out of range "
                      << hash_id << " => " << m_module_vec.size());
      }
    } else if ( m_TYPE_INDEX == end ) {
      if (hash_id < (unsigned int)(m_type_vec.end() - m_type_vec.begin())) {
    id = m_type_vec[hash_id];
    result = 0;
      } else {
        ATH_MSG_ERROR("get_id: TYPE hash_id is out of range " << hash_id
                      << " => " << m_type_vec.size());
      }
    }
  }
  return(result);
}
 
 
int  TileTBID::get_hash  (const Identifier& id, IdentifierHash& hash_id, const IdContext* context ) const
{
    
  hash_id = 0;
  int result = 1;
 
  size_t begin = (context) ? context->begin_index(): 0;
  size_t end   = (context) ? context->end_index()  : 0; 
 
  if (0 == begin) { 
    if ( m_CHANNEL_INDEX == end ) {
      std::vector<Identifier>::const_iterator it = std::lower_bound(m_channel_vec.begin(),m_channel_vec.end(),id);
      if ( it != m_channel_vec.end() ){
    hash_id = it - m_channel_vec.begin();
    result = 0;
      }
    } else if ( m_MODULE_INDEX == end ) {
      std::vector<Identifier>::const_iterator it = std::lower_bound(m_module_vec.begin(),m_module_vec.end(),id);
      if ( it != m_module_vec.end() ){
    hash_id = it - m_module_vec.begin();
    result = 0;
      }
    } else if ( m_TYPE_INDEX == end ) {
      std::vector<Identifier>::const_iterator it = std::lower_bound(m_type_vec.begin(),m_type_vec.end(),id);
      if ( it != m_type_vec.end() ){
    hash_id = it - m_type_vec.begin();
    result = 0;
      }
    }    
  }
 
  return (result);
}
 
int  TileTBID::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_DEBUG("Request to reinitialize not satisfied - tags have not changed");
    return (0);
  }
  else {
    ATH_MSG_DEBUG("(Re)initialize");
  }
 
  ATH_MSG_DEBUG("calling base initialize_from_dictionary");
 
  // init base object
  if(AtlasDetectorID::initialize_from_dictionary(dict_mgr)) return (1);
 
  // Register version of the TileCalo dictionary
  if (register_dict_tag(dict_mgr, "TileCalorimeter")) return(1);
 
  m_dict = dict_mgr.find_dictionary ("TileCalorimeter"); 
  if(!m_dict) {
    ATH_MSG_ERROR("cannot access TileCalorimeter dictionary ");
    return 1;
  }
  
  // Initialize the field indices
  if(initLevelsFromDict()) return (1);
 
 
  // Find value for the field Tile Calorimeter   
  const IdDictDictionary* atlasDict = dict_mgr.find_dictionary ("ATLAS"); 
  int tileField   = -1;
  if (atlasDict->get_label_value("subdet", "TileCalorimeter", tileField)) {
    ATH_MSG_ERROR("Could not get value for label 'TileCalorimeter' of field 'subdet' in dictionary "
                  << atlasDict->name());
    return (1);
  }
 
  // Find value for the field Tile Testbeam
  int tiletbField   = -1;
  if (m_dict->get_label_value("section", "Testbeam", tiletbField)) {
    ATH_MSG_ERROR("Could not get value for label 'Testbeam' of field 'section' in dictionary "
                  << m_dict->name());
    return (1);
  }
 
  // Set up id for region and range prefix
  ExpandedIdentifier reg_id;
  reg_id.add(tileField);
  reg_id.add(tiletbField);
  Range prefix;
 
  m_full_channel_range= m_dict->build_multirange(reg_id, prefix, "tbchannel");
  m_full_module_range = m_dict->build_multirange(reg_id, prefix, "tbmodule");
  m_full_type_range   = m_dict->build_multirange(reg_id, prefix, "type");
 
  ATH_MSG_DEBUG("initialize_from_dict : "                                );
  ATH_MSG_DEBUG(" type range -> "    << (std::string)m_full_type_range   );
  ATH_MSG_DEBUG(" module range -> "  << (std::string)m_full_module_range );
  ATH_MSG_DEBUG(" channel range -> " << (std::string)m_full_channel_range);
 
  // Setup the hash tables
  if(init_hashes()) return (1);
 
  return 0;
 
}
 
int TileTBID::get_expanded_id  (const Identifier& id, ExpandedIdentifier& exp_id, const IdContext* context) const
{
  int result = 1;
 
  size_t begin = (context) ? context->begin_index() : 0;
  size_t end   = (context) ? context->end_index()   : m_CHANNEL_INDEX;
  assert (end <= m_CHANNEL_INDEX);
 
  if (0 == end) {
    result = 0;
  }
  else if ( 0 == begin) {
    ExpandedIdentifier empty;
    result = m_dict->unpack(group(), id, empty, end, exp_id);
  }
  else {
    result = m_dict->unpack(group(), id, context->prefix_id(), end, exp_id);
  }
  return result;
}
 
int TileTBID::initLevelsFromDict()
{
  if(!m_dict) {
    ATH_MSG_ERROR("initLevelsFromDict - dictionary NOT initialized ");
    return (1);
  }
 
  // Find out which identifier field corresponds to each level.
 
  m_SYSTEM_INDEX        = 999;
  m_SECTION_INDEX       = 999;
  m_TYPE_INDEX          = 999;
  m_MODULE_INDEX        = 999;
  m_CHANNEL_INDEX       = 999;
 
  // Save index to a Tile region for unpacking
  ExpandedIdentifier expId(tile_exp());
  if (m_dict->find_region(expId,m_tile_region_index)){
    ATH_MSG_ERROR("initLevelsFromDict - unable to find tile region index: expId, reg "
                  << (std::string)expId << " " << m_tile_region_index);
    return (1);
  }
 
  // Fing a Tile region
  const IdDictField* field = m_dict->find_field("subdet") ;
  if (field) {
    m_SYSTEM_INDEX = field->index();
  }
  else {
    ATH_MSG_ERROR("initLevelsFromDict - unable to find 'subdet' field ");
    return (1);
  }
 
  field = m_dict->find_field("section") ;
  if (field) {
    m_SECTION_INDEX = field->index();
  }
  else {
    ATH_MSG_ERROR("initLevelsFromDict - unable to find 'section' field ");
    return (1);
  }
 
  field = m_dict->find_field("type") ;
  if (field) {
    m_TYPE_INDEX = field->index();
  }
  else {
    ATH_MSG_ERROR("initLevelsFromDict - unable to find 'type' field ");
    return (1);
  }
 
  field = m_dict->find_field("tbmodule") ;
  if (field) {
    m_MODULE_INDEX = field->index();
  }
  else {
    ATH_MSG_ERROR("initLevelsFromDict - unable to find 'tbmodule' field ");
    return (1);
  }
 
  field = m_dict->find_field("tbchannel") ;
  if (field) {
    m_CHANNEL_INDEX = field->index();
  }
  else {
    ATH_MSG_ERROR("initLevelsFromDict - unable to find 'tbchannel' field ");
    return (1);
  }
 
   /* Set the field implementations */
  const IdDictRegion& region = m_dict->region(m_tile_region_index);
 
  m_system_impl  = region.implementation(m_SYSTEM_INDEX);
  m_section_impl = region.implementation(m_SECTION_INDEX);
  m_type_impl    = region.implementation(m_TYPE_INDEX);
  m_module_impl  = region.implementation(m_MODULE_INDEX);
  m_channel_impl = region.implementation(m_CHANNEL_INDEX);
 
  m_base_tile_type=Identifier (0);
  m_system_impl.pack  (tile_field_value(),m_base_tile_type);
  m_section_impl.pack (TileTBID::TILE_TESTBEAM,m_base_tile_type);
 
  ATH_MSG_DEBUG("initLevelsFromDict decode index and bit fields for each level: "             );
  ATH_MSG_DEBUG(" system   [" << m_SYSTEM_INDEX   << "]  " << m_system_impl.show_to_string()  );
  ATH_MSG_DEBUG(" section  [" << m_SECTION_INDEX  << "]  " << m_section_impl.show_to_string() );
  ATH_MSG_DEBUG(" type     [" << m_TYPE_INDEX     << "]  " << m_type_impl.show_to_string()    );
  ATH_MSG_DEBUG(" module   [" << m_MODULE_INDEX   << "]  " << m_module_impl.show_to_string()  );
  ATH_MSG_DEBUG(" channel  [" << m_CHANNEL_INDEX  << "]  " << m_channel_impl.show_to_string() );
 
  return(0) ;
}
 
int TileTBID::init_hashes()
{
  // type hash
  unsigned int nids = 0;
  std::set<Identifier> ids;
  for (unsigned int i = 0; i < m_full_type_range.size(); ++i) {
    const Range& range = m_full_type_range[i];
    ConstRangeIterator rit(range);
    auto first = rit.begin();
    auto last  = rit.end();
    for (; first != last; ++first) {
      const ExpandedIdentifier& exp_id = (*first);
      Identifier id = type_id (exp_id[m_TYPE_INDEX]);
      if(!(ids.insert(id)).second){
        ATH_MSG_ERROR("init_hashes "
                      << " Error: duplicated id for type id. nids= " << nids
                      << " compact Id  " << show_to_string(id));
      }
      nids++;
    }
  }
  m_type_hash_max = m_full_type_range.cardinality();
  if ( fill_vec(ids, m_type_hash_max, m_type_vec) ) return (1);
 
  // module hash
  nids = 0;
  ids.clear();
  for (unsigned int i = 0; i < m_full_module_range.size(); ++i) {
    const Range& range = m_full_module_range[i];
    ConstRangeIterator rit(range);
    auto first = rit.begin();
    auto last  = rit.end();
    for (; first != last; ++first) {
      const ExpandedIdentifier& exp_id = (*first);
      Identifier id = module_id (exp_id[m_TYPE_INDEX], 
                                 exp_id[m_MODULE_INDEX]);
      if(!(ids.insert(id)).second){
        ATH_MSG_ERROR("init_hashes "
                      << " Error: duplicated id for module id. nids= " << nids
                      << " compact Id  " << show_to_string(id));
      }
      nids++;
    }
  }
  m_module_hash_max = m_full_module_range.cardinality();
  if ( fill_vec(ids, m_module_hash_max, m_module_vec) ) return (1);
 
  // channel hash
  nids = 0;
  ids.clear();
  for (unsigned int i = 0; i < m_full_channel_range.size(); ++i) {
    const Range& range = m_full_channel_range[i];
    ConstRangeIterator rit(range);
    auto first = rit.begin();
    auto last  = rit.end();
    for (; first != last; ++first) {
      const ExpandedIdentifier& exp_id = (*first);
      Identifier id = channel_id    (exp_id[m_TYPE_INDEX], 
                                 exp_id[m_MODULE_INDEX], 
                                 exp_id[m_CHANNEL_INDEX]);
      if(!(ids.insert(id)).second){
        ATH_MSG_ERROR("init_hashes "
                      << " Error: duplicated id for channel id. nids= " << nids
                      << " compact Id  " << show_to_string(id));
      }
      nids++;
    }
  }
  m_channel_hash_max = m_full_channel_range.cardinality();
  if ( fill_vec(ids, m_channel_hash_max, m_channel_vec) ) return (1);
 
  return (0);
}
 
int TileTBID::fill_vec  (std::set<Identifier> & ids, 
                         unsigned int hash_max, std::vector<Identifier> & vec)
{
 
  if(ids.size() != hash_max) {
 
    ATH_MSG_ERROR("fill_vec "
        << " Error: set size NOT EQUAL to hash max. size " << ids.size()
        << " hash max " << hash_max);
 
    return (1);
  }
 
  vec.resize(hash_max);
 
  std::set<Identifier>::const_iterator first = ids.begin();
  std::set<Identifier>::const_iterator last  = ids.end();
 
  int index = 0;
  for (;first != last; ++first) {
    vec[index++] = (*first);
  }
 
  return (0);
}