LArMiniFCAL_ID.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARMiniFCAL_ID_H
#define LARMiniFCAL_ID_H
 
#include "AthenaKernel/CLASS_DEF.h"
#include "AtlasDetDescr/AtlasDetectorID.h"
#include "Identifier/IdentifierHash.h"
#include "IdDict/IdDictFieldImplementation.h"
#include "IdDict/IdDictDefs.h"
 
#include "CaloIdentifier/CaloIDHelper.h"
#include "CaloIdentifier/LArID_Exception.h"
#include "CaloIdentifier/LArNeighbours.h"
 
#include "boost/range/iterator_range.hpp"
#include <vector>
#include <algorithm>
#include <set>
 
 
class Range;
class LArMiniFCAL_region;
 
class LArMiniFCAL_ID : public CaloIDHelper
{
public:
        
  typedef Identifier::size_type  size_type ;
 
  LArMiniFCAL_ID();
        
  ~LArMiniFCAL_ID();
 
  bool        is_initialized() const;
 
  Identifier  module_id (const ExpandedIdentifier& exp_id) const ;
 
  Identifier  channel_id (const ExpandedIdentifier& exp_id) const ;
 
  Identifier  module_id ( int pos_neg, int module ) const ;
  Identifier  module_id ( int pos_neg, int module, bool checks ) const ;
 
  Identifier  channel_id( int pos_neg,  int module,  int depth,
                          int eta,      int phi ) const ;
  Identifier  channel_id( int pos_neg,  int module,  int depth,
                          int eta,      int phi, bool checks ) const ;
 
  Identifier  module_id (const Identifier id ) const;
     
  Identifier  channel_id( const Identifier moduleId, int depth,
                          int eta, int phi) const ;
  Identifier  channel_id( const Identifier moduleId, int depth,
                          int eta, int phi, bool checks) const ;
                             
  bool is_supercell (const Identifier channelId) const;
                                 
  Identifier module_id  (IdentifierHash module_hash_id) const;
 
  IdentifierHash module_hash  (Identifier module_id) const;
 
  IdentifierHash channel_hash_binary_search (Identifier channelId) const;
 
  size_type     module_hash_max () const;
 
  typedef std::vector<Identifier>::const_iterator id_iterator;
  typedef boost::iterator_range<id_iterator> id_range;
 
  id_iterator mod_begin    () const;
  id_iterator mod_end      () const;
  id_range    mod_range    () const;
 
  id_iterator minifcal_begin    () const;
  id_iterator minifcal_end      () const;
  id_range    minifcal_range    () const;
 
  const std::vector<Identifier>& channel_ids() const;
 
  const std::vector<Identifier>& module_ids() const;
 
                             
  int         pos_neg         (const Identifier id)const; 
  int         module          (const Identifier id)const;
  int         depth            (const Identifier id)const;
  int         eta             (const Identifier id)const;
  int         phi             (const Identifier id)const; 
 
  int eta_min(const Identifier regId) const;
  int eta_max(const Identifier regId) const;
  int phi_min(const Identifier regId) const;
  int phi_max(const Identifier regId) const;
  
  int    get_neighbours(const IdentifierHash id, const LArNeighbours::neighbourOption& option, std::vector<IdentifierHash>& neighbourList) const;
 
  IdContext    module_context   () const;
 
  virtual int  initialize_from_dictionary (const IdDictMgr& dict_mgr);
 
  using CaloIDHelper::channel_id;
  using CaloIDHelper::channel_hash;
  // Inherited from CaloIDHelper:
  // 
  //Identifier channel_id (IdentifierHash hashId) const;
  //Identifier region_id (IdentifierHash hashId) const;
  //IdentifierHash channel_hash (Identifier channelId) const;
  //IdentifierHash region_hash (Identifier regionId) const;
  //size_type channel_hash_max() const;
  //size_type region_hash_max() const;
  //IdContext channel_context() const;
  //IdContext region_context() const;
  //const std::vector<const IdDictRegion*>& dictRegions() const;
  //float etaGranularity(const IdentifierHash regHash) const;
  //float phiGranularity(const IdentifierHash regHash) const;
  //float eta0(const IdentifierHash regHash) const;
  //float phi0(const IdentifierHash regHash) const;
  //virtual int get_id (const IdentifierHash& hash_id,
  //                    Identifier& id,
  //                    const IdContext* context = 0 ) const;
  //virtual int  get_hash  (const Identifier& id,
  //                        IdentifierHash& hash_id,
  //                        const IdContext* context = 0 ) const;
 
 
private:    
 
          
  enum {NOT_VALID_HASH = 64000};
 
  int phi_min_init(const Identifier regId) const;
 
  std::vector<std::set<IdentifierHash> >  m_neighbors_2d_vec;
  std::vector<std::set<IdentifierHash> >  m_neighbors_3d_next_vec;
  std::vector<std::set<IdentifierHash> >  m_neighbors_3d_prev_vec;
 
  // Check methods
 
  void  module_id_checks      ( int pos_neg, int module ) const;
  void  channel_id_checks     ( int pos_neg,  int module,
                                int depth,  int eta,      int phi ) const;
  void  channel_id_checks     ( const Identifier moduleId,
                                int depth, int eta, int phi) const;
                             
  virtual int  get_expanded_id  (const Identifier& id, ExpandedIdentifier& exp_id, const IdContext* context) const;
 
  int         initLevelsFromDict();
 
  int         init_hashes();
 
  int         init_neighbors_from_file(const std::string& filename, std::vector<std::set<IdentifierHash> > &vec);
 
  int         init_neighbors_2d(const std::string& filename)
    { 
      return init_neighbors_from_file(filename, m_neighbors_2d_vec);
    }
 
  int         init_neighbors_3d_next(const std::string& filename)
    { 
      return init_neighbors_from_file(filename, m_neighbors_3d_next_vec);
    }
 
  int         init_neighbors_3d_prev(const std::string& filename)
    { 
      return init_neighbors_from_file(filename, m_neighbors_3d_prev_vec);
    }
 
  int         init_neighbors(const IdDictMgr& dict_mgr) ;
 
  // flag to protect for when helper hasn't been able to be
  // initialized - no description in xml dictionary
  bool                          m_is_initialized;  
  size_type                     m_fcal_region_index;
  size_type                     m_LAR_INDEX;
  size_type                     m_MiniFCAL_INDEX;
  size_type                     m_POSNEG_INDEX;
  size_type                     m_MODULE_INDEX;
  size_type                     m_DEPTH_INDEX;
  size_type                     m_ETA_INDEX;
  size_type                     m_PHI_INDEX;
 
  MultiRange                    m_full_channel_range;
  MultiRange                    m_full_module_range;
  MultiRange                    m_full_depth_range;
 
  bool                          m_two_sym_sides;
 
  std::vector<short int>        m_vecOfCellInfo;
  std::vector<short int>        m_vecOfPhiMin;
 
 
  IdDictFieldImplementation     m_lar_impl;
  IdDictFieldImplementation     m_fcal_impl;
  IdDictFieldImplementation     m_pn_impl;
  IdDictFieldImplementation     m_module_impl;
  IdDictFieldImplementation     m_depth_impl;
  IdDictFieldImplementation     m_eta_impl;
  IdDictFieldImplementation     m_phi_impl;
 
  IdDictFieldImplementation     m_pn_mod_impl;
 
};
 
//using the macro below we can assign an identifier (and a version)
//This is required and checked at compile time when you try to record/retrieve
CLASS_DEF( LArMiniFCAL_ID , 79264204  , 1 )
 
 
//--------------------
// Inline definitions
//--------------------
 
//----------------------------------------------------------------------------
inline bool
LArMiniFCAL_ID::is_initialized() const
{
    return m_is_initialized;
}
 
//----------------------------------------------------------------------------
inline Identifier 
LArMiniFCAL_ID::module_id (const ExpandedIdentifier& exp_id) const 
{
  return this->module_id   ( exp_id[m_POSNEG_INDEX],
                             exp_id[m_MODULE_INDEX] );
}
 
//----------------------------------------------------------------------------
inline Identifier 
LArMiniFCAL_ID::channel_id (const ExpandedIdentifier& exp_id) const 
{
  return this->channel_id (exp_id[m_POSNEG_INDEX],
                           exp_id[m_MODULE_INDEX], 
                           exp_id[m_DEPTH_INDEX],
                           exp_id[m_ETA_INDEX],
                           exp_id[m_PHI_INDEX]);
}
 
//----------------------------------------------------------------------------
inline Identifier 
LArMiniFCAL_ID::module_id (int pos_neg, int module, bool checks) const 
{
 
    Identifier result(0);
 
    // Do checks 
    if(checks) {
        module_id_checks ( pos_neg, module );
    }
 
    // Pack fields independently
    m_lar_impl.pack      (lar_field_value(),      result);
    m_fcal_impl.pack     (lar_fcal_field_value(), result);
    m_pn_impl.pack       (pos_neg,                result);
    m_module_impl.pack   (module,                 result);
 
    return result;
}
 
inline Identifier 
LArMiniFCAL_ID::module_id (int pos_neg, int module) const 
{
  return module_id (pos_neg, module, do_checks());
}
 
//----------------------------------------------------------------------------
inline Identifier 
LArMiniFCAL_ID::channel_id   ( int pos_neg, int module, int depth,
                               int eta,     int phi,
                               bool checks ) const 
{  
 
    // Do checks 
    if(checks) {
        channel_id_checks( pos_neg, module, depth, eta, phi );
    }
 
    Identifier result(0);
    // Pack fields independently
    m_lar_impl.pack      (lar_field_value(),      result);
    m_fcal_impl.pack     (lar_fcal_field_value(), result);
    m_pn_impl.pack       (pos_neg,                result);
    m_module_impl.pack   (module,                 result);
    m_depth_impl.pack    (depth,                  result);
    m_eta_impl.pack      (eta,                    result);
    m_phi_impl.pack      (phi,                    result);
 
    return result;
}
 
inline Identifier 
LArMiniFCAL_ID::channel_id   ( int pos_neg, int module, int depth,
                               int eta,     int phi ) const
{
  return channel_id (pos_neg, module, depth, eta, phi, do_checks());
}
 
//----------------------------------------------------------------------------
inline Identifier 
LArMiniFCAL_ID::module_id   ( const Identifier channelId ) const 
{
 
  Identifier result(channelId);
  //  reset depth/eta/phi
  m_depth_impl.reset(result);
  m_eta_impl.reset(result);
  m_phi_impl.reset(result);
  return (result);
}
 
//----------------------------------------------------------------------------
inline Identifier 
LArMiniFCAL_ID::channel_id   ( const Identifier module_id, int depth,
                               int eta,       int phi,
                               bool checks) const 
{
    // Do checks 
    if(checks) {
      channel_id_checks( module_id, depth, eta, phi );
    }
 
    Identifier result(module_id);
 
    // Reset the fields and then set the values
    m_depth_impl.reset   (result);
    m_eta_impl.reset     (result);
    m_phi_impl.reset     (result);
    m_depth_impl.pack    (depth, result);
    m_eta_impl.pack      (eta, result);
    m_phi_impl.pack      (phi, result);
 
    return result;
}
 
inline Identifier 
LArMiniFCAL_ID::channel_id   ( const Identifier module_id, int depth,
                               int eta,       int phi) const
{
  return channel_id (module_id, depth, eta, phi, do_checks());
}
 
//----------------------------------------------------------------------------
inline Identifier LArMiniFCAL_ID::module_id    (IdentifierHash module_hash_id) const
{
  return region_id(module_hash_id);
}
 
//----------------------------------------------------------------------------
inline IdentifierHash LArMiniFCAL_ID::module_hash (Identifier module_id) const
{
  return region_hash (module_id);
}
 
//----------------------------------------------------------------------------
inline IdentifierHash LArMiniFCAL_ID::channel_hash_binary_search  (Identifier channelId) const
{
  return channel_hash (channelId);
}
 
//----------------------------------------------------------------------------
inline LArMiniFCAL_ID::size_type     LArMiniFCAL_ID::module_hash_max () const
{
  return region_hash_max();
}
 
//----------------------------------------------------------------------------
inline LArMiniFCAL_ID::id_iterator LArMiniFCAL_ID::mod_begin    () const
{
  return regions().begin();
}
 
//----------------------------------------------------------------------------
inline LArMiniFCAL_ID::id_iterator LArMiniFCAL_ID::mod_end      () const
{
  return regions().end();
}
 
//----------------------------------------------------------------------------
inline LArMiniFCAL_ID::id_range LArMiniFCAL_ID::mod_range() const
{
  return regions().range();
}
 
//----------------------------------------------------------------------------
inline LArMiniFCAL_ID::id_iterator LArMiniFCAL_ID::minifcal_begin    () const
{
  return channels().begin();
}
 
//----------------------------------------------------------------------------
inline LArMiniFCAL_ID::id_iterator LArMiniFCAL_ID::minifcal_end      () const
{
  return channels().end();
}
 
//----------------------------------------------------------------------------
inline LArMiniFCAL_ID::id_range LArMiniFCAL_ID::minifcal_range() const
{
  return channels().range();
}
 
//----------------------------------------------------------------------------
inline const std::vector<Identifier>& LArMiniFCAL_ID::channel_ids() const
{
  return channels().ids();
}
 
//----------------------------------------------------------------------------
inline const std::vector<Identifier>& LArMiniFCAL_ID::module_ids() const
{
  return regions().ids();
}
 
//----------------------------------------------------------------------------
inline int LArMiniFCAL_ID::pos_neg         (const Identifier id)const
{
  return (m_pn_impl.unpack(id));
}
 
//----------------------------------------------------------------------------
inline int LArMiniFCAL_ID::module              (const Identifier id)const
{
  return (m_module_impl.unpack(id));
}
 
//----------------------------------------------------------------------------
inline int LArMiniFCAL_ID::depth             (const Identifier id)const
{
  int result = m_depth_impl.unpack(id);
  return(result);
}
 
//----------------------------------------------------------------------------
inline int LArMiniFCAL_ID::eta               (const Identifier id)const
{
  int result = m_eta_impl.unpack(id);
  return(result);
}
 
//----------------------------------------------------------------------------
inline int LArMiniFCAL_ID::phi(const Identifier id)const
{
  int result = m_phi_impl.unpack(id);
  return(result);
}
 
//----------------------------------------------------------------------------
inline int LArMiniFCAL_ID::phi_min(const Identifier modId) const
{
  IdentifierHash modHash = module_hash(modId);
  unsigned int index = modHash;
  return (m_vecOfPhiMin[index]);
}
 
//----------------------------------------------------------------------------
inline bool LArMiniFCAL_ID::is_supercell(const Identifier /*channelId*/) const
{
  return false;
}
 
#endif // LARMiniFCAL_ID_H