CaloIDHelper.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "AthenaKernel/getMessageSvc.h"
#include "CaloIdentifier/CaloIDHelper.h"
#include "IdDict/IdDictDictionary.h"
#include "IdDict/IdDictMgr.h"
#include "IdDict/IdDictRegion.h"
#include "Identifier/Range.h"
#include "GaudiKernel/MsgStream.h"
 
 

CaloIDHelper::HashGroup::HashGroup ()
  : m_end_index(99999)
{
}
 

int CaloIDHelper::HashGroup::init (const std::string& name,
                                   const std::set<Identifier>& ids,
                                   size_type end_index,
                                   const MultiRange* full_range)
{
  m_end_index = end_index;
  if (full_range && full_range->cardinality() != ids.size()) {
    MsgStream log(Athena::getMessageSvc(), name);
    log << MSG::ERROR << "set size " << ids.size()
        << " not equal to hash max " << full_range->cardinality() << endmsg;
    return 1;
  }
  m_id_vec.assign (ids.begin(), ids.end());
  return 0;
}
 

int CaloIDHelper::HashGroup::get_hash (Identifier id,
                                       IdentifierHash& hash_id) const
{
  std::vector<Identifier>::const_iterator it = std::lower_bound(m_id_vec.begin(),m_id_vec.end(),id);
  if ( it != m_id_vec.end() ){
    hash_id = it - m_id_vec.begin();
    return 0;
  }
  return 1;
}
 

IdContext CaloIDHelper::HashGroup::context() const
{
  ExpandedIdentifier id;
  return IdContext (id, 0, m_end_index);
}
 
 
//*************************************************************************
 

CaloIDHelper::CaloIDHelper (const std::string& name,
                            const std::string& group)
  : AtlasDetectorID (name, group),
    m_name (name),
    m_dict(nullptr)
{
}
 

int CaloIDHelper::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;
  size_t end   = (context) ? context->end_index()  : 0; 
 
  if (0 == begin) { 
    const HashGroup* hg = nullptr;
    if (m_channels.end_index() == end) hg = &m_channels;
    else if (m_regions.end_index() == end) hg = &m_regions;
 
    if (hg) {
      if (hash_id < hg->hash_max()) {
    id = hg->id (hash_id);
    result = 0;
      }
    }
  }
 
  return(result);
}
 

int CaloIDHelper::get_hash  (const Identifier& id, IdentifierHash& hash_id, const IdContext* context ) const
{
  hash_id = IdentifierHash();
 
  size_t begin = (context) ? context->begin_index(): 0;
  size_t end   = (context) ? context->end_index()  : 0; 
 
  if (0 == begin) { 
    const HashGroup* hg = nullptr;
    if (m_channels.end_index() == end) hg = &m_channels;
    else if (m_regions.end_index() == end) hg = &m_regions;
 
    if (hg)
      return hg->get_hash (id, hash_id);
  }
 
  return 1;
}
 

float CaloIDHelper::etaGranularity(const IdentifierHash regHash) const
{
  if (regHash >= m_vecOfDictRegions.size()) return NOT_VALID;
  return m_vecOfDictRegions.at(regHash)->deta();
}
 

float CaloIDHelper::phiGranularity(const IdentifierHash regHash) const
{
  if (regHash >= m_vecOfDictRegions.size()) return NOT_VALID;
  return  2. * M_PI / m_vecOfDictRegions.at(regHash)->dphi();
}
 

float CaloIDHelper::eta0(const IdentifierHash regHash) const
{
  if (regHash >= m_vecOfDictRegions.size()) return NOT_VALID;
  return (m_vecOfDictRegions.at(regHash)->eta0());
}
 

float CaloIDHelper::phi0(const IdentifierHash regHash) const
{
  if (regHash >= m_vecOfDictRegions.size()) return NOT_VALID;
  return (m_vecOfDictRegions.at(regHash)->phi0());
}
 

int
CaloIDHelper::initialize_base_from_dictionary (const IdDictMgr& dict_mgr,
                                               const std::string& dict_name)
{
  // init base object
  if(AtlasDetectorID::initialize_from_dictionary(dict_mgr)) return (1);
 
  // Register version of dictionary 
  if (register_dict_tag(dict_mgr, dict_name)) return(1);
 
  m_dict = dict_mgr.find_dictionary (dict_name);
  if(!m_dict) {
    ATH_MSG_ERROR("cannot access " << dict_name <<  "dictionary");
    return 1;
  }
  return 0;
}
 

int
CaloIDHelper::fill_vec_of_dict_regions (const std::string& group_name /*= ""*/)
{
  m_vecOfDictRegions.clear();
  m_vecOfDictRegions.reserve (regions().hash_max());
  IdContext region_cntxt = region_context();
  ExpandedIdentifier expRegId;
  for (Identifier id : regions().range()) {
    if(!get_expanded_id(id, expRegId, &region_cntxt)) {
      m_vecOfDictRegions.push_back (m_dict->find_region(expRegId,group_name));
    }
  }
  // cppcheck-suppress assertWithSideEffect
  assert (m_vecOfDictRegions.size() == regions().hash_max());
  return 0;
}