CaloCell_Base_ID.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
/**
 * @file CaloIdentifier/CaloCell_Base_ID.icc
 * @author scott snyder <snyder@bnl.gov>
 * @date Jul, 2012
 * @brief Helper base class for offline cell identifiers
 */
 
 
//--------------------
// Inline definitions
//--------------------
 
//----------------------------------------------------------------------------
inline  Identifier  
CaloCell_Base_ID::region_id     (const int subCalo, 
                 const int barec_or_posneg, 
                                 const int sampling_or_fcalmodule, 
                                 const int region_or_dummy,
                                 bool checks) const
{
  Identifier result(0);  // this returns a pixel identifier [2.1.-2.0.0]
  if( subCalo == LAREM ) {
    return m_emHelper->region_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, checks);
  } 
  else if( subCalo == LARHEC ) {
    return m_hecHelper->region_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, checks);
  } 
  else if( subCalo == LARFCAL ) {
    return m_fcalHelper->module_id(barec_or_posneg, sampling_or_fcalmodule, checks);
  } 
  else if( subCalo == LARMINIFCAL ) {
    return m_minifcalHelper->module_id(barec_or_posneg, sampling_or_fcalmodule, checks);
  } 
  else if( subCalo == TILE ) {
    return m_tileHelper->region_id(barec_or_posneg, sampling_or_fcalmodule, checks);
  } 
  else {
    return(result);
  }
}
 
inline  Identifier  
CaloCell_Base_ID::region_id     (const int subCalo, 
                 const int barec_or_posneg, 
                                 const int sampling_or_fcalmodule, 
                                 const int region_or_dummy ) const
{
  return region_id (subCalo, barec_or_posneg, sampling_or_fcalmodule,
                    region_or_dummy, do_checks());
}
 
//----------------------------------------------------------------------------
inline Identifier 
CaloCell_Base_ID::cell_id (const int subCalo, 
                           const int barec_or_posneg, 
                           const int sampling_or_fcalmodule,
                           const int region_or_dummy,
                           const int eta,
                           const int phi,
                           bool checks) const
{
  Identifier result(0);
  if( subCalo == LAREM ) {
    return m_emHelper->channel_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, eta, phi, checks);
  } 
  else if( subCalo == LARHEC ) {
    return m_hecHelper->channel_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, eta, phi, checks);
  } 
  else if( subCalo == LARFCAL ) {
    return m_fcalHelper->channel_id(barec_or_posneg, sampling_or_fcalmodule, eta, phi, checks);
  } 
  else if( subCalo == LARMINIFCAL ) {
    return m_minifcalHelper->channel_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, eta, phi, checks);
  } 
  else if( subCalo == TILE ) {
    return m_tileHelper->cell_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, eta, phi, checks);
  } 
  else {
    return(result);
  }
}
 
inline Identifier 
CaloCell_Base_ID::cell_id (const int subCalo, 
                           const int barec_or_posneg, 
                           const int sampling_or_fcalmodule,
                           const int region_or_dummy,
                           const int eta,
                           const int phi) const
{
  return cell_id (subCalo, barec_or_posneg, sampling_or_fcalmodule,
                  region_or_dummy, eta, phi, do_checks());
}
 
//----------------------------------------------------------------------------
inline Identifier 
CaloCell_Base_ID::region_id ( const Identifier cellId ) const 
{
  Identifier result(0);
  if(m_emHelper->is_lar_em(cellId)) {
    return m_emHelper->region_id(cellId);
  } 
  else if(m_emHelper->is_lar_hec(cellId)) {
    return m_hecHelper->region_id(cellId);
  } 
  else if(m_emHelper->is_lar_minifcal(cellId)) { 
    // must do minifcal before fcal because miniFCAL IS FCAL
    return m_minifcalHelper->module_id(cellId);
  } 
  else if(m_emHelper->is_lar_fcal(cellId)) {
    return m_fcalHelper->module_id(cellId);
  } 
  else if(m_emHelper->is_tile(cellId)) {
    return m_tileHelper->region_id(cellId);
  } 
  else {
    return(result);
  }
}
 
//----------------------------------------------------------------------------
inline Identifier 
CaloCell_Base_ID::cell_id (const Identifier regionId,
                           const int eta,
                           const int phi,
                           int depth,
                           bool checks) const 
{
  Identifier result(0);
  if(m_emHelper->is_lar_em(regionId)) {
    return m_emHelper->channel_id(regionId,eta,phi,checks);
  } 
  else if(m_emHelper->is_lar_hec(regionId)) {
    return m_hecHelper->channel_id(regionId,eta,phi,checks);
  } 
  else if(m_emHelper->is_lar_minifcal(regionId)) {
    // must do minifcal before fcal because miniFCAL IS FCAL
    return m_minifcalHelper->channel_id(regionId, depth,eta,phi,checks);
  } 
  else if(m_emHelper->is_lar_fcal(regionId)) {
    return m_fcalHelper->channel_id(regionId,eta,phi,checks);
  } 
  else {
    return(result);
  }
}
 
inline Identifier 
CaloCell_Base_ID::cell_id (const Identifier regionId,
                           const int eta,
                           const int phi,
                           int depth) const
{
  return cell_id (regionId, eta, phi, depth, do_checks());
}
 
//----------------------------------------------------------------------------
inline Identifier 
CaloCell_Base_ID::region_id    (const IdentifierHash caloRegionHash) const
{
  return(m_region_vec[caloRegionHash]);
}
 
//----------------------------------------------------------------------------
inline Identifier 
CaloCell_Base_ID::region_id (const int subCalo,
                             const IdentifierHash subCaloRegionHash) const
{
    return(m_region_vec[subCaloRegionHash + m_reg_min[subCalo]]);
}
 
//----------------------------------------------------------------------------
inline Identifier 
CaloCell_Base_ID::cell_id    (const IdentifierHash caloCellHash) const
{
    return(m_cell_vec[caloCellHash]);
}
 
//----------------------------------------------------------------------------
inline Identifier 
CaloCell_Base_ID::cell_id    (const int subCalo, const IdentifierHash subCaloCellHash) const
{
    return(m_cell_vec[subCaloCellHash + m_cell_min[subCalo]]);
}
 
//----------------------------------------------------------------------------
inline IdentifierHash 
CaloCell_Base_ID::calo_region_hash (const Identifier regionId) const
{
    std::vector<Identifier>::const_iterator it = std::lower_bound(m_region_vec.begin(),m_region_vec.end(),regionId);
    if ( it != m_region_vec.end() ){
      return (it - m_region_vec.begin());
    }
    return (NOT_VALID);
}
 
//----------------------------------------------------------------------------
inline IdentifierHash 
CaloCell_Base_ID::subcalo_region_hash (const Identifier regionId, int& subCalo) const
{
  subCalo = LAREM ;
  if(is_hec(regionId)) {
    subCalo = LARHEC ;
  } 
  else     if (is_minifcal(regionId)) {
    // must do minifcal before fcal because miniFCAL IS FCAL
    subCalo = LARMINIFCAL ;
  }
  else     if (is_fcal(regionId)) {
    subCalo = LARFCAL ;
  }
  else     if (is_tile(regionId)) {
    subCalo = TILE ;
  }
  std::vector<Identifier>::const_iterator it = std::lower_bound(m_region_vec.begin(),m_region_vec.end(),regionId);
  if ( it != m_region_vec.end() ){
    return (it - m_region_vec.begin() - m_reg_min[subCalo]);
  }
  return (NOT_VALID);
}
 
//----------------------------------------------------------------------------
inline IdentifierHash 
CaloCell_Base_ID::subcalo_cell_hash (const Identifier cellId, int& subCalo) const
{
  subCalo = get_subcalo (cellId);
  switch (subCalo) {
 
  // LArEM / HEC have subdetector-specific optimized methods.
  case LAREM:
    return m_emHelper->channel_hash (cellId);
  case LARHEC:
    return m_hecHelper->channel_hash (cellId);
  case LARFCAL:
  case TILE:
  case LARMINIFCAL:
    return m_helpers[subCalo]->channel_hash (cellId);
  default:
    return NOT_VALID;
  }
}
 
//----------------------------------------------------------------------------
inline IdentifierHash 
CaloCell_Base_ID::calo_cell_hash (const Identifier cellId) const
{
  int subcalo;
  IdentifierHash hash = subcalo_cell_hash (cellId, subcalo);
  if (hash != NOT_VALID)
    return m_cell_min[subcalo] + hash;
  return NOT_VALID;
}
 
//----------------------------------------------------------------------------
inline CaloCell_Base_ID::size_type     CaloCell_Base_ID::calo_cell_hash_max () const
{
  return m_cell_hash_max;
}
 
//----------------------------------------------------------------------------
inline CaloCell_Base_ID::size_type     CaloCell_Base_ID::calo_region_hash_max () const
{
  return m_region_hash_max;
}
 
//----------------------------------------------------------------------------
inline  void CaloCell_Base_ID::calo_cell_hash_range (const Identifier id, IdentifierHash& caloCellMin, IdentifierHash& caloCellMax) const
{
  if(m_emHelper->is_lar_em(id)) {
    caloCellMin = m_cell_min[LAREM];
    caloCellMax = m_cell_max[LAREM];
  } 
  else if(m_emHelper->is_lar_hec(id)) {
    caloCellMin = m_cell_min[LARHEC];
    caloCellMax = m_cell_max[LARHEC];
  } 
  else if(m_emHelper->is_lar_minifcal(id)) {
    // must do minifcal before fcal because miniFCAL IS FCAL
    caloCellMin = m_cell_min[LARMINIFCAL];
    caloCellMax = m_cell_max[LARMINIFCAL];
  } 
  else if(m_emHelper->is_lar_fcal(id)) {
    caloCellMin = m_cell_min[LARFCAL];
    caloCellMax = m_cell_max[LARFCAL];
  } 
  else if(m_emHelper->is_tile(id)) {
    caloCellMin = m_cell_min[TILE];
    caloCellMax = m_cell_max[TILE];
  } 
  else {
    caloCellMin = NOT_VALID;
    caloCellMax = NOT_VALID;
  } 
}
 
//----------------------------------------------------------------------------
inline  void CaloCell_Base_ID::calo_reg_hash_range (const Identifier id, IdentifierHash& caloRegMin, IdentifierHash& caloRegMax) const
{
  if(m_emHelper->is_lar_em(id)) {
    caloRegMin = m_reg_min[LAREM];
    caloRegMax = m_reg_max[LAREM];
  } 
  else if(m_emHelper->is_lar_hec(id)) {
    caloRegMin = m_reg_min[LARHEC];
    caloRegMax = m_reg_max[LARHEC];
  } 
  else if(m_emHelper->is_lar_minifcal(id)) {
    // must do minifcal before fcal because miniFCAL IS FCAL
    caloRegMin = m_reg_min[LARMINIFCAL];
    caloRegMax = m_reg_max[LARMINIFCAL];
  } 
  else if(m_emHelper->is_lar_fcal(id)) {
    caloRegMin = m_reg_min[LARFCAL];
    caloRegMax = m_reg_max[LARFCAL];
  } 
  else if(m_emHelper->is_tile(id)) {
    caloRegMin = m_reg_min[TILE];
    caloRegMax = m_reg_max[TILE];
  } 
  else {
    caloRegMin = NOT_VALID;
    caloRegMax = NOT_VALID;
  } 
}
 
//----------------------------------------------------------------------------
inline  void CaloCell_Base_ID::calo_cell_hash_range (const int subCalo, IdentifierHash& caloCellMin, IdentifierHash& caloCellMax) const
{
    caloCellMin = m_cell_min[subCalo];
    caloCellMax = m_cell_max[subCalo];
}
 
//----------------------------------------------------------------------------
inline  void CaloCell_Base_ID::calo_reg_hash_range (const int subCalo, IdentifierHash& caloRegMin, IdentifierHash& caloRegMax) const
{
    caloRegMin = m_reg_min[subCalo];
    caloRegMax = m_reg_max[subCalo];
}
 
//----------------------------------------------------------------------------
inline IdentifierHash CaloCell_Base_ID::subcalo_cell_hash   ( const IdentifierHash caloHash, int& subCalo) const
{
  if(caloHash < m_cell_max[LAREM]) {
    subCalo = LAREM;
  }
  else if(caloHash < m_cell_max[LARHEC] ) {
    subCalo = LARHEC;
  }
  else if(caloHash < m_cell_max[LARFCAL] ) {
    subCalo = LARFCAL;
  }
  else if(caloHash < m_cell_max[TILE] ) {
    subCalo = TILE;
  }
  else if(caloHash < m_cell_max[LARMINIFCAL] ) {
    subCalo = LARMINIFCAL;
  }
  else {
    subCalo = NOT_VALID;
    return(NOT_VALID);
  }
  return( caloHash - m_cell_min[subCalo]) ;
}
 
//----------------------------------------------------------------------------
inline IdentifierHash CaloCell_Base_ID::subcalo_region_hash   ( const IdentifierHash caloHash, int& subCalo) const
{
  if(caloHash < m_reg_max[LAREM]) {
    subCalo = LAREM;
  }
  else if(caloHash < m_reg_max[LARHEC] ) {
    subCalo = LARHEC;
  }
  else if(caloHash < m_reg_max[LARFCAL] ) {
    subCalo = LARFCAL;
  }
  else if(caloHash < m_reg_max[TILE] ) {
    subCalo = TILE;
  }
  else if(caloHash < m_reg_max[LARMINIFCAL] ) {
    subCalo = LARMINIFCAL;
  }
  else {
    subCalo = NOT_VALID;
    return(NOT_VALID);
  }
  return( caloHash - m_reg_min[subCalo]) ;
}
 
//----------------------------------------------------------------------------
inline IdentifierHash CaloCell_Base_ID::calo_cell_hash   (const int subCalo, const IdentifierHash subCaloHash) const
{
  return( subCaloHash + m_cell_min[subCalo]) ;
}
 
 
//----------------------------------------------------------------------------
inline IdentifierHash CaloCell_Base_ID::calo_region_hash   (const int subCalo, const IdentifierHash subCaloHash) const
{
  return( subCaloHash + m_reg_min[subCalo]) ;
}
 
//----------------------------------------------------------------------------
inline CaloCell_Base_ID::id_iterator CaloCell_Base_ID::cell_begin   () const
{
  return(m_cell_vec.begin());
}
 
//----------------------------------------------------------------------------
inline CaloCell_Base_ID::id_iterator CaloCell_Base_ID::cell_end     () const
{
  return(m_cell_vec.end());
}
 
//----------------------------------------------------------------------------
inline CaloCell_Base_ID::id_range CaloCell_Base_ID::cell_range     () const
{
  return id_range (cell_begin(), cell_end());
}
 
//----------------------------------------------------------------------------
inline
CaloCell_Base_ID::id_iterator
CaloCell_Base_ID::cell_begin    (const int subCalo) const
{
  return m_helpers[subCalo]->channels().begin();
}
 
//----------------------------------------------------------------------------
inline
CaloCell_Base_ID::id_iterator
CaloCell_Base_ID::cell_end    (const int subCalo) const
{
  return m_helpers[subCalo]->channels().end();
}
 
//----------------------------------------------------------------------------
inline
CaloCell_Base_ID::id_range
CaloCell_Base_ID::cell_range    (const int subCalo) const
{
  return m_helpers[subCalo]->channels().range();
}
 
//----------------------------------------------------------------------------
inline
CaloCell_Base_ID::id_iterator
CaloCell_Base_ID::reg_begin    () const
{
  return(m_region_vec.begin());
}
 
//----------------------------------------------------------------------------
inline
CaloCell_Base_ID::id_iterator
CaloCell_Base_ID::reg_end      () const
{
  return(m_region_vec.end());
}
 
//----------------------------------------------------------------------------
inline
CaloCell_Base_ID::id_range
CaloCell_Base_ID::reg_range      () const
{
  return id_range (reg_begin(), reg_end());
}
 
//----------------------------------------------------------------------------
inline
CaloCell_Base_ID::id_iterator
CaloCell_Base_ID::reg_begin    (const int subCalo) const
{
  return m_helpers[subCalo]->regions().begin();
}
 
//----------------------------------------------------------------------------
inline
CaloCell_Base_ID::id_iterator
CaloCell_Base_ID::reg_end    (const int subCalo) const
{
  return m_helpers[subCalo]->regions().end();
}
 
//----------------------------------------------------------------------------
inline
CaloCell_Base_ID::id_range
CaloCell_Base_ID::reg_range    (const int subCalo) const
{
  return m_helpers[subCalo]->regions().range();
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_em(const Identifier id) const
{
  return m_emHelper->is_lar_em(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_em(const IdentifierHash caloHash) const
{
  bool result=false;
  if(caloHash < m_cell_max[LAREM]) result=true;
  return result;
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_em_barrel(const Identifier id) const
{
  return m_emHelper->is_em_barrel(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_em_endcap(const Identifier id) const
{
  return m_emHelper->is_em_endcap(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_em_endcap_inner(const Identifier id) const
{
  return m_emHelper->is_em_endcap_inner(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_em_endcap_outer(const Identifier id) const
{
  return m_emHelper->is_em_endcap_outer(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_hec(const Identifier id) const
{
  return m_emHelper->is_lar_hec(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_hec(const IdentifierHash caloHash) const
{
  bool result=false;
  if(caloHash >= m_cell_min[LARHEC] && 
     caloHash <  m_cell_max[LARHEC] ) result=true;
  return result;
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_fcal(const Identifier id) const
{
  return m_emHelper->is_lar_fcal(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_fcal(const IdentifierHash caloHash) const
{
  bool result=false;
  if(caloHash >= m_cell_min[LARFCAL] && caloHash < m_cell_max[LARFCAL] ) result=true;
  return result;
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_minifcal(const Identifier id) const
{
  return m_emHelper->is_lar_minifcal(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_minifcal(const IdentifierHash caloHash) const
{
  bool result=false;
  if(caloHash >= m_cell_min[LARMINIFCAL] && caloHash < m_cell_max[LARMINIFCAL] ) result=true;
  return result;
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_tile(const ExpandedIdentifier& id) const
{
  return m_emHelper->is_tile(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_tile(const Identifier id) const
{
  return m_emHelper->is_tile(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_tile(const IdentifierHash caloHash) const
{
  bool result=false;
  if(caloHash >= m_cell_min[TILE] && caloHash < m_cell_max[TILE] ) result=true;
  return result;
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_tile_barrel(const Identifier id) const
{
  return m_tileHelper->is_tile_barrel(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_tile_extbarrel(const Identifier id) const
{
  return m_tileHelper->is_tile_extbarrel(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_tile_gap(const Identifier id) const
{
  return m_tileHelper->is_tile_gap(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_tile_gapscin(const Identifier id) const
{
  return m_tileHelper->is_tile_gapscin(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_tile_positive(const Identifier id) const
{
  return m_tileHelper->is_positive(id);
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_tile_negative(const Identifier id) const
{
  return m_tileHelper->is_negative(id);
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::sub_calo         (const Identifier id)const
{
  if(m_emHelper->is_lar_em(id)) {
    return LAREM;
  } 
  else if(m_emHelper->is_lar_hec(id)) {
    return LARHEC;
  } 
  else if(m_emHelper->is_lar_minifcal(id)) {
    // must do minifcal before fcal because miniFCAL IS FCAL
    return LARMINIFCAL;
  } 
  else if(m_emHelper->is_lar_fcal(id)) {
    return LARFCAL;
  } 
  else if(m_emHelper->is_tile(id)) {
    return TILE;
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::sub_calo         (const IdentifierHash caloHash)const
{
  int result = NOT_VALID;
  if(caloHash < m_cell_max[LAREM]) {
    result = LAREM;
  }
  else if(caloHash < m_cell_max[LARHEC] ) {
    result = LARHEC;
  }
  else if(caloHash < m_cell_max[LARFCAL] ) {
    result = LARFCAL;
  }
  else if(caloHash < m_cell_max[TILE] ) {
    result = TILE;
  }
  else if(caloHash < m_cell_max[LARMINIFCAL] ) {
    result = LARMINIFCAL;
  }
  return result;
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::pos_neg         (const Identifier id)const
{
  if(m_emHelper->is_lar_em(id)) {
    return m_emHelper->barrel_ec(id);
  } 
  else if(m_emHelper->is_lar_hec(id)) {
    return m_hecHelper->pos_neg(id);
  } 
  else if(m_emHelper->is_lar_minifcal(id)) {
    // must do minifcal before fcal because miniFCAL IS FCAL
    return m_minifcalHelper->pos_neg(id);
  } 
  else if(m_emHelper->is_lar_fcal(id)) {
    return m_fcalHelper->pos_neg(id);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::section         (const Identifier id)const
{
  if(m_emHelper->is_tile(id)) {
    return m_tileHelper->section(id);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::sampling             (const Identifier id)const
{
  if(m_emHelper->is_lar_em(id)) {
    return m_emHelper->sampling(id);
  } 
  else if(m_emHelper->is_lar_hec(id)) {
    return m_hecHelper->sampling(id);
  } 
  else if(m_emHelper->is_lar_minifcal(id)) {
    // must do minifcal before fcal because miniFCAL IS FCAL
    return m_minifcalHelper->depth(id);
  } 
  else if(m_emHelper->is_lar_fcal(id)) {
    return m_fcalHelper->module(id);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::side             (const Identifier id)const
{
  if(m_emHelper->is_tile(id)) {
    return m_tileHelper->side(id);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::region              (const Identifier id)const
{
  if(m_emHelper->is_lar_em(id)) {
    return m_emHelper->region(id);
  } 
  else if(m_emHelper->is_lar_hec(id)) {
    return m_hecHelper->region(id);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::module              (const Identifier id)const
{
  if(m_emHelper->is_tile(id)) {
    return m_tileHelper->module(id);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::eta(const Identifier id)const
{
  if(m_emHelper->is_lar_em(id)) {
    return m_emHelper->eta(id);
  } 
  else if(m_emHelper->is_lar_hec(id)) {
    return m_hecHelper->eta(id);
  } 
  else if(m_emHelper->is_lar_minifcal(id)) {
    // must do minifcal before fcal because miniFCAL IS FCAL
    return m_minifcalHelper->eta(id);
  } 
  else if(m_emHelper->is_lar_fcal(id)) {
    return m_fcalHelper->eta(id);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::tower(const Identifier id)const
{
  if(m_emHelper->is_tile(id)) {
    return m_tileHelper->tower(id);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::phi(const Identifier id)const
{
  if(m_emHelper->is_lar_em(id)) {
    return m_emHelper->phi(id);
  } 
  else if(m_emHelper->is_lar_hec(id)) {
    return m_hecHelper->phi(id);
  } 
  else if(m_emHelper->is_lar_minifcal(id)) {
    // must do minifcal before fcal because miniFCAL IS FCAL
    return m_minifcalHelper->phi(id);
  } 
  else if(m_emHelper->is_lar_fcal(id)) {
    return m_fcalHelper->phi(id);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::sample(const Identifier id)const
{
  if(m_emHelper->is_tile(id)) {
    return m_tileHelper->sample(id);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline bool CaloCell_Base_ID::is_supercell(const Identifier id)const
{
  if(m_emHelper->is_lar_em(id)) {
    return m_emHelper->is_supercell(id);
  }
  else if(is_hec(id)) {
    return m_hecHelper->is_supercell(id);
  }
  else if(m_emHelper->is_lar_fcal(id)) {
    return m_fcalHelper->is_supercell(id);
  }
  else if(is_tile(id)) {
    return m_tileHelper->is_supercell(id);
  }
  
  return false;
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::eta_min(const Identifier regId) const
{
  if(m_emHelper->is_lar_em(regId)) {
    return m_emHelper->eta_min(regId);
  } 
  else if(m_emHelper->is_lar_hec(regId)) {
    return m_hecHelper->eta_min(regId);
  } 
  else if(m_emHelper->is_lar_minifcal(regId)) {
    // must do minifcal before fcal because miniFCAL IS FCAL 
    return m_minifcalHelper->eta_min(regId);
  } 
  else if(m_emHelper->is_lar_fcal(regId)) {
    return m_fcalHelper->eta_min(regId);
  } 
  else if(m_emHelper->is_tile(regId)) {
    return m_tileHelper->eta_min(regId);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::eta_max(const Identifier regId) const
{
  if(m_emHelper->is_lar_em(regId)) {
    return m_emHelper->eta_max(regId);
  } 
  else if(m_emHelper->is_lar_hec(regId)) {
    return m_hecHelper->eta_max(regId);
  } 
  else if(m_emHelper->is_lar_minifcal(regId)) {
    // must do minifcal before fcal because miniFCAL IS FCAL 
    return m_minifcalHelper->eta_max(regId);
  } 
  else if(m_emHelper->is_lar_fcal(regId)) {
    return m_fcalHelper->eta_max(regId);
  } 
  else if(m_emHelper->is_tile(regId)) {
    return m_tileHelper->eta_max(regId);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::phi_min(const Identifier regId) const
{
  if(m_emHelper->is_lar_em(regId)) {
    return m_emHelper->phi_min(regId);
  } 
  else if(m_emHelper->is_lar_hec(regId)) {
    return m_hecHelper->phi_min(regId);
  } 
  else if(m_emHelper->is_lar_minifcal(regId)) {
    // must do minifcal before fcal because miniFCAL IS FCAL 
    return m_minifcalHelper->phi_min(regId);
  } 
  else if(m_emHelper->is_lar_fcal(regId)) {
    return m_fcalHelper->phi_min(regId);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline int CaloCell_Base_ID::phi_max(const Identifier regId) const
{
  if(m_emHelper->is_lar_em(regId)) {
    return m_emHelper->phi_max(regId);
  } 
  else if(m_emHelper->is_lar_hec(regId)) {
    return m_hecHelper->phi_max(regId);
  } 
  else if(m_emHelper->is_lar_minifcal(regId)) {
    // must do minifcal before fcal because miniFCAL IS FCAL 
    return m_minifcalHelper->phi_max(regId);
  } 
  else if(m_emHelper->is_lar_fcal(regId)) {
    return m_fcalHelper->phi_max(regId);
  } 
  else if(m_emHelper->is_tile(regId)) {
    return m_tileHelper->phi_max(regId);
  } 
  else {
    return(NOT_VALID);
  }
}
 
//----------------------------------------------------------------------------
inline float CaloCell_Base_ID::etaGranularity(const Identifier regId) const
{
  int subcalo = 0;
  IdentifierHash regHash = subcalo_region_hash (regId, subcalo);
  if (regHash == NOT_VALID) return NOT_VALID;
  return m_helpers[subcalo]->etaGranularity (regHash);
}
 
//----------------------------------------------------------------------------
inline float CaloCell_Base_ID::phiGranularity(const Identifier regId) const
{
  int subcalo = 0;
  IdentifierHash regHash = subcalo_region_hash (regId, subcalo);
  if (regHash == NOT_VALID) return NOT_VALID;
  return m_helpers[subcalo]->phiGranularity (regHash);
}
 
//----------------------------------------------------------------------------
inline float CaloCell_Base_ID::eta0(const Identifier regId) const
{
  int subcalo = 0;
  IdentifierHash regHash = subcalo_region_hash (regId, subcalo);
  if (regHash == NOT_VALID) return NOT_VALID;
  return m_helpers[subcalo]->eta0 (regHash);
}
 
//----------------------------------------------------------------------------
inline float CaloCell_Base_ID::phi0(const Identifier regId) const
{
  int subcalo = 0;
  IdentifierHash regHash = subcalo_region_hash (regId, subcalo);
  if (regHash == NOT_VALID) return NOT_VALID;
  return m_helpers[subcalo]->phi0 (regHash);
}
 
//---------------------------------------------------------------------------
inline int CaloCell_Base_ID::GetSubCaloName(const std::string& SubCaloName )const 
{
  if(SubCaloName=="LAREM"){
    return(LAREM);
  }
  else if(SubCaloName=="LARHEC"){
    return(LARHEC);
  } 
  else if(SubCaloName=="LARMINIFCAL"){
    return(LARMINIFCAL);
  }
  else if(SubCaloName=="LARFCAL"){
    return(LARFCAL);
  }
  else if(SubCaloName=="TILE"){
    return(TILE);
  }
  else{
    return(NOT_VALID);
  }
}
 
 
//---------------------------------------------------------------------------
inline
CaloCell_Base_ID::SUBCALO
CaloCell_Base_ID::get_subcalo (Identifier id) const
{
  if (m_emHelper->is_lar_em(id))
    return LAREM;
  else if (m_emHelper->is_lar_hec(id))
    return LARHEC;
  else if (m_emHelper->is_lar_minifcal (id)) {
    // must do minifcal before fcal because miniFCAL IS FCAL 
    return LARMINIFCAL;
  }
  else if (m_emHelper->is_lar_fcal (id))
    return LARFCAL;
  else if (m_emHelper->is_tile (id))
    return TILE;
  return NOT_VALID;
}