LArOnlineID_Base.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARONLINEID_BASE_H
#define LARONLINEID_BASE_H
 
#include "AtlasDetDescr/AtlasDetectorID.h"
#include "IdDict/IdDictFieldImplementation.h"
#include "Identifier/HWIdentifier.h"
#include "Identifier/IdentifierHash.h"
#include "Identifier/MultiRange.h"
#include "AthenaKernel/CLASS_DEF.h"
#include "boost/range/iterator_range.hpp"
#include <vector>
 
 
 
 
class LArOnlineID_Base : public AtlasDetectorID
{
 public:        
 
  using size_type = Identifier::size_type;
  
  using id_iterator = std::vector<HWIdentifier>::const_iterator;
  using id_range = boost::iterator_range<id_iterator>;
 
  LArOnlineID_Base(const std::string& name,
                   const std::string& group,
                   bool is_slar);
  virtual ~LArOnlineID_Base();
  
  HWIdentifier feedthrough_Id( int barrel_ec, int pos_neg, int feedthrough) const;
  HWIdentifier feedthrough_Id( int barrel_ec, int pos_neg, int feedthrough,
                               bool checks) const;
  
  HWIdentifier feedthrough_Id(IdentifierHash feedthroughHash) const;
 
  IdentifierHash feedthrough_Hash(HWIdentifier feedthroughId) const;
 
  id_iterator feedthrough_begin() const;
  id_iterator feedthrough_end  () const;
  id_range    feedthrough_range() const;
 
 
 
  HWIdentifier feb_Id(int barrel_ec,
              int pos_neg,
              int feedthrough, 
              int slot) const;
  HWIdentifier feb_Id(int barrel_ec,
              int pos_neg,
              int feedthrough, 
              int slot,
                      bool checks) const;
  HWIdentifier feb_Id(IdentifierHash febHash) const;    
 
  IdentifierHash feb_Hash(HWIdentifier febId) const;
 
  id_iterator feb_begin() const;
  id_iterator feb_end  () const;
  id_range    feb_range() const;
 
 
 
  HWIdentifier channel_Id(int barrel_ec,
              int pos_neg,
              int feedthrough, 
              int slot,
              int channel) const;
  HWIdentifier channel_Id(int barrel_ec,
              int pos_neg,
              int feedthrough, 
              int slot,
              int channel,
                          bool checks) const;
  HWIdentifier channel_Id(IdentifierHash channelHash) const;    
 
  IdentifierHash channel_Hash(HWIdentifier channelId) const;
 
  id_iterator channel_begin() const;
  id_iterator channel_end  () const;
  id_range    channel_range() const;
  
 
  HWIdentifier feedthrough_Id(const HWIdentifier Id) const ;
  HWIdentifier feb_Id(const HWIdentifier channelId) const ;
  HWIdentifier feb_Id(const HWIdentifier feedthroughId, int slot) const ;
  HWIdentifier channel_Id(const HWIdentifier feedthroughId, int slot, int channel) const;
  HWIdentifier channel_Id(const HWIdentifier feedthroughId, int slot, int channel,
                          bool checks) const;
  HWIdentifier channel_Id(const HWIdentifier febId, int channel) const;
  HWIdentifier channel_Id(const HWIdentifier febId, int channel,
                          bool checks) const;
 
 
  size_type  feedthroughHashMax () const;
  size_type  febHashMax () const;
  size_type  channelHashMax () const;
 
  HWIdentifier calib_module_Id(int barrel_ec,
                   int pos_neg,
                   int feedthrough, 
                   int slot ) const;
  HWIdentifier calib_module_Id(IdentifierHash calibModuleHash) const;   
  IdentifierHash calib_module_Hash(HWIdentifier calibModuleId) const;
 
  id_iterator calib_module_begin() const;
  id_iterator calib_module_end  () const;
  id_range    calib_module_range() const;
 
 
  HWIdentifier calib_channel_Id(int barrel_ec,
                int pos_neg,
                int feedthrough, 
                int slot,
                int channel ) const;
  HWIdentifier calib_channel_Id(IdentifierHash calibChannelHash) const; 
  id_iterator calib_channel_begin() const;
  id_iterator calib_channel_end  () const;
  id_range    calib_channel_range() const;
 
 
  HWIdentifier calib_module_Id(const HWIdentifier ChannelId) const ;
  HWIdentifier calib_module_Id(const HWIdentifier FeedthroughId, int slot) const ;
  HWIdentifier calib_channel_Id(const HWIdentifier FeedthroughId, int slot, int channel ) const ;
  HWIdentifier calib_channel_Id(const HWIdentifier febId, int ChannelId) const ;
 
  IdentifierHash calib_channel_Hash (HWIdentifier channelId) const ;
 
  size_type  calibModuleHashMax () const;
 
  size_type  calibChannelHashMax () const;
 
 
  /* recommended methods */
  bool  isEMBchannel             (const HWIdentifier id) const;
  virtual bool  isEMECchannel    (const HWIdentifier id) const = 0; // differs for Main and DT
  virtual bool  isHECchannel     (const HWIdentifier id) const = 0; // differs for Main and DT
  bool  isFCALchannel            (const HWIdentifier id) const;
  virtual bool  isEMECIW         (const HWIdentifier id) const = 0; // differs for Main and DT
  virtual bool  isEMECOW         (const HWIdentifier id) const = 0; // differs for Main and DT
  bool  isEMBPS                  (const HWIdentifier id) const;
  bool  isEMECPS                 (const HWIdentifier id) const;
  bool  isPS                     (const HWIdentifier id) const;
  bool  isNotWarmCableConnected  (const HWIdentifier id) const;
  bool  isCalibration            (const HWIdentifier id) const;
 
  /* To be used with care */
  bool  isHecOnline              (const HWIdentifier id) const;
  bool  isHecOnlineFebId         (const HWIdentifier febId) const;
  bool  isEMECinHECchannel       (const HWIdentifier id) const;
 
  /* obsolete */
  bool  isEmBarrelOnline         (const HWIdentifier id) const;
  bool  isEmEndcapOnline         (const HWIdentifier id) const;
  bool  isEndcapOnline           (const HWIdentifier id) const;
  bool  isFcalOnline             (const HWIdentifier id) const;
  bool  isEmEndcapStandardOnline (const HWIdentifier id) const;
  bool  isEmEndcapSpecialOnline  (const HWIdentifier id) const;
 
  int   channelInSlotMax         (const HWIdentifier Id) const;
 
  std::string feedthrough_name(const HWIdentifier id ) const;
 
  std::string channel_name(const HWIdentifier id ) const;
    
  int barrel_ec(const HWIdentifier id)const;  
 
  int pos_neg(const HWIdentifier id)const; 
 
  int feedthrough(const HWIdentifier id)const; 
 
  int slot(const HWIdentifier id)const;  
 
  int channel(const HWIdentifier id)const;  
 
  int is_slar(const HWIdentifier id)const;
 
 
  bool isValidId(const HWIdentifier id) const;
 
  virtual int  initialize_from_dictionary (const IdDictMgr& dict_mgr);
 
 
  IdContext    cryostatEndContext() const;
  IdContext    feedthroughContext() const;
  IdContext    febContext() const;
  IdContext    channelContext() const;
 
protected:    
/*==== */
     
  enum {NOT_VALID_HASH = 256000};
  bool m_this_is_slar;
 
  IdentifierHash feb_Hash_binary_search(HWIdentifier channelId) const;
 
  IdentifierHash channel_Hash_binary_search(HWIdentifier channelId) const;
 
  // Check methods
  void  channel_Id_checks(int barrel_ec, 
              int pos_neg,
              int feedthrough,
              int slot,
              int channel ) const;
 
  void  channel_Id_checks(const HWIdentifier feedthroughId,
              int slot,
              int channel ) const;
 
  void  channel_Id_checks(const HWIdentifier febId,
              int channel ) const;
 
  void  feb_Id_checks(int barrel_ec, int pos_neg, int feedthrough, int slot ) const;
 
  void  feedthrough_Id_checks(int barrel_ec, int pos_neg, int feedthrough ) const; 
 
  int  get_expanded_id  (const HWIdentifier& id, 
             ExpandedIdentifier& exp_id, 
             const IdContext* context) const;
  int  get_expanded_calib_id  (const HWIdentifier& id, 
                   ExpandedIdentifier& exp_id, 
                   const IdContext* context) const;
  int  initLevelsFromDict(const std::string& group_name) ;
  int  init_hashes();
  int  init_calib_hashes();
 
  size_type m_laronlineRegion_index;   // LArOnline_region
  size_type m_lar_index;               // LAr
  size_type m_laronline_index;         // 4
  size_type m_bec_index;               // [0 Barrel, 1 Endcap]
  size_type m_side_index;              // [-1 negative-side, 1 positive-side]
  size_type m_feedthrough_index;       // [0,31] or [0,24]
  size_type m_slot_index;              // [1,15] 
  size_type m_channel_in_slot_index;   // [0,127]
  size_type m_slar_index;              // [0,1]
 
  const IdDictDictionary*       m_dict;
  MultiRange                    m_full_laronline_range;
  MultiRange                    m_full_feedthrough_range;
  MultiRange                    m_full_feb_range;
  MultiRange                    m_full_channel_range;
  size_type                     m_feedthroughHashMax;
  size_type                     m_febHashMax;
  size_type                     m_channelHashMax;
 
  std::vector<HWIdentifier>     m_feedthrough_vec;
  std::vector<HWIdentifier>     m_feb_vec;
  std::vector<HWIdentifier>     m_channel_vec;
 
  /* Calib */
  MultiRange                    m_full_calib_laronline_range;
  MultiRange                    m_full_calib_module_range;
  size_type                     m_calibModuleHashMax;
  size_type                     m_calibChannelHashMax;
  std::vector<HWIdentifier>     m_calib_module_vec;
  std::vector<HWIdentifier>     m_calib_channel_vec;
 
  IdDictFieldImplementation     m_lar_impl;
  IdDictFieldImplementation     m_laronline_impl;
  IdDictFieldImplementation     m_bec_impl;
  IdDictFieldImplementation     m_side_impl;
  IdDictFieldImplementation     m_feedthrough_impl;
  IdDictFieldImplementation     m_slot_impl;
  IdDictFieldImplementation     m_channel_in_slot_impl;
  IdDictFieldImplementation     m_bec_ft_impl;
  IdDictFieldImplementation     m_bec_slot_impl;
  IdDictFieldImplementation     m_slar_impl;
 
  class HashCalc
  {
  public:
    HashCalc() : m_hash(0) {}
    IdentifierHash m_hash;
  };
  class HashCalcFeb
  {
  public:
    HashCalcFeb() : m_hash(0) {}
    IdentifierHash m_hash;
    std::vector<int> m_slot_values; // need to save slot values for enumerated slot field
  };
  std::vector<HashCalcFeb>      m_feb_hash_calcs;
  std::vector<HashCalc>         m_chan_hash_calcs;
  
};
 
static const int s_lar_online_field_value = 4 ;
static const int s_lar_onlineCalib_field_value = 5 ;
 
//=====================
// Inline Definitions
//=====================
 
inline IdentifierHash LArOnlineID_Base::feb_Hash_binary_search (HWIdentifier febId) const
/*=============================================================================== */
{
    std::vector<HWIdentifier>::const_iterator it = std::lower_bound(m_feb_vec.begin(),m_feb_vec.end(),febId);
    if ( it != m_feb_vec.end() ){
    return (it - m_feb_vec.begin());
    }
    return (0);
}
 
 
inline IdentifierHash LArOnlineID_Base::channel_Hash_binary_search (HWIdentifier channelId) const
/*=========================================================================*/
{
  std::vector<HWIdentifier>::const_iterator it = std::lower_bound(m_channel_vec.begin(),m_channel_vec.end(),channelId);
  if ( it != m_channel_vec.end() ){
    return (it - m_channel_vec.begin());
  }
  return(0) ;
}
 
/* CALIB inline Identifiers */
/*==========================*/
 
inline HWIdentifier LArOnlineID_Base::calib_module_Id(int barrel_ec, int pos_neg, 
                         int feedthrough, int slot ) const 
/*=============================================================== */
{
  HWIdentifier result(0);  
  /*Pack fields independently */
  m_lar_impl.pack        (lar_field_value(), result);
  m_laronline_impl.pack  (5                , result);
  m_bec_impl.pack        (barrel_ec        , result);
  m_side_impl.pack       (pos_neg          , result);
  m_feedthrough_impl.pack(feedthrough      , result);
  m_slot_impl.pack       (slot             , result); 
  return result;
}
 
inline HWIdentifier LArOnlineID_Base::calib_module_Id(const HWIdentifier feedthroughId , int slot) const
/*==================================================================================== */
{
  HWIdentifier result(feedthroughId);
  /* Pack fields independently */
  m_slot_impl.reset           (result);
  m_slot_impl.pack            (slot  , result);
  return(result);
}
 
inline HWIdentifier LArOnlineID_Base::calib_module_Id(const HWIdentifier calibChannelId ) const
/*======================================================================= */
{
  HWIdentifier result(calibChannelId);
  m_channel_in_slot_impl.reset(result);
  return(result);
}
 
inline HWIdentifier LArOnlineID_Base::calib_module_Id(IdentifierHash calibModuleHashId) const
/*=========================================================================== */
{
  return(m_calib_module_vec[calibModuleHashId]);
}
 
inline IdentifierHash LArOnlineID_Base::calib_module_Hash (HWIdentifier calibModuleId) const
/*=============================================================================== */
{
    std::vector<HWIdentifier>::const_iterator it = std::lower_bound(m_calib_module_vec.begin(),m_calib_module_vec.end(),calibModuleId);
    if ( it != m_calib_module_vec.end() ){
    return (it - m_calib_module_vec.begin());
    }
    return (0);
}
 
inline HWIdentifier LArOnlineID_Base::calib_channel_Id( int barrel_ec, int pos_neg, int feedthrough, 
                           int slot,      int channel ) const 
/*============================================================================== */
{  
  HWIdentifier result(0);
  /* Pack fields independently */
  m_lar_impl.pack            (lar_field_value()    , result);
  m_laronline_impl.pack      (5                    , result);
  m_bec_impl.pack            (barrel_ec            , result);
  m_side_impl.pack           (pos_neg              , result);
  m_feedthrough_impl.pack    (feedthrough          , result);
  m_slot_impl.pack           (slot                 , result);
  m_channel_in_slot_impl.pack(channel              , result);
 
  return result;
}
 
inline HWIdentifier LArOnlineID_Base::calib_channel_Id(const HWIdentifier feedthroughId,int slot,int channel) const 
/*==================================================================================================== */
{  
  HWIdentifier result(feedthroughId);
  /* Pack fields independently */
  m_slot_impl.reset           (result);
  m_channel_in_slot_impl.reset(result);
  m_slot_impl.pack            (slot  , result);
  m_channel_in_slot_impl.pack (channel, result);
 
  return result;
}
 
inline HWIdentifier LArOnlineID_Base::calib_channel_Id(const HWIdentifier febId, int channel) const 
/*======================================================================================= */
{  
  HWIdentifier result(febId);
  /* Pack fields independently */
  m_channel_in_slot_impl.reset(result);
  m_channel_in_slot_impl.pack (channel, result);
 
  return result;
}
inline HWIdentifier LArOnlineID_Base::calib_channel_Id(IdentifierHash channelHashId) const
/*===================================================================*/
{
    return(m_calib_channel_vec[channelHashId]);
}
 
inline IdentifierHash LArOnlineID_Base::calib_channel_Hash (HWIdentifier channelId) const
/*=========================================================================*/
{
  std::vector<HWIdentifier>::const_iterator it = std::lower_bound(m_calib_channel_vec.begin(),m_calib_channel_vec.end(),channelId);
  if ( it != m_calib_channel_vec.end() ){
    return (it - m_calib_channel_vec.begin());
  }
  return(0) ;
}
 
/* Calib */
inline LArOnlineID_Base::size_type LArOnlineID_Base::calibModuleHashMax () const
/*=======================================================================*/
{
  return m_calibModuleHashMax;
}
inline LArOnlineID_Base::size_type LArOnlineID_Base::calibChannelHashMax () const
/*====================================================================*/
{
  return m_calibChannelHashMax;
}
 
 
 
 
 
/* Calib */
inline LArOnlineID_Base::id_iterator LArOnlineID_Base::calib_module_begin() const
/*====================================================================*/
{
  return(m_calib_module_vec.begin());
}
inline LArOnlineID_Base::id_iterator LArOnlineID_Base::calib_module_end() const
/*==================================================================*/
{
  return(m_calib_module_vec.end());
}
inline LArOnlineID_Base::id_range LArOnlineID_Base::calib_module_range() const
/*==================================================================*/
{
  return id_range (calib_module_begin(), calib_module_end());
}
 
inline LArOnlineID_Base::id_iterator LArOnlineID_Base::calib_channel_begin() const
/*======================================================================*/
{
  return(m_calib_channel_vec.begin());
}
inline LArOnlineID_Base::id_iterator LArOnlineID_Base::calib_channel_end() const
/*======================================================================*/
{
  return(m_calib_channel_vec.end());
}
inline LArOnlineID_Base::id_range LArOnlineID_Base::calib_channel_range() const
/*======================================================================*/
{
  return id_range (calib_channel_begin(), calib_channel_end());
}
 
 
 
//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( LArOnlineID_Base , 28598761 , 1 )
 
 
#endif // LARONLINE_ID_BASE_H