TileHWID.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
/***************************************************************************
 Tile Calorimeter detector description package
 -----------------------------------------
 ***************************************************************************/
 
//<doc><file>   $Id: TileHWID.h,v 1.11 2008-11-03 15:25:00 solodkov Exp $
//<version> $Name: not supported by cvs2svn $
 
// TileHWID.h
//
// Atlas detector Identifier class for Tile Calorimeter (hardware identifier)
//
 
#ifndef TILEIDENTIFIER_TILEHWID_H
#define TILEIDENTIFIER_TILEHWID_H
 
#include "CaloIdentifier/TileID.h"
#include "Identifier/HWIdentifier.h"
#include "Identifier/IdentifierHash.h"
 
class TileHWID : public AtlasDetectorID {
 
public:
 
  typedef Identifier::size_type  size_type ;
      
  TileHWID(void);
 
  virtual ~TileHWID();
 
  enum        SECTION   { TILE_ONLINE = TileID::ONLINE };
  enum        ROSID     { BEAM_ROS   = 0,
                          BARREL_POS = 1,
                          BARREL_NEG = 2,
                          EXTBAR_POS = 3,
                          EXTBAR_NEG = 4 };
  enum        GAIN      { LOWGAIN  = TileID::LOWGAIN,
                          HIGHGAIN = TileID::HIGHGAIN };
 
  HWIdentifier        tilehw_id               ( void )                        const;
  HWIdentifier        ros_id                  ( int ros)                      const;
  HWIdentifier        drawer_id               ( int frag )                    const;
  HWIdentifier        drawer_id               ( int ros, int drawer )         const;
  HWIdentifier        channel_id              ( int ros, int drawer, 
                                                int channel )                 const;
  HWIdentifier        adc_id                  ( int ros, int drawer,
                                                int channel, int adc )        const;
 
  HWIdentifier        drawer_id               ( const HWIdentifier& id )      const; 
  HWIdentifier        channel_id              ( const HWIdentifier& id )      const; 
  HWIdentifier        channel_id              ( const HWIdentifier& id,
                                                int channel )                 const;
  HWIdentifier        adc_id                  ( const HWIdentifier& id,
                                                int channel, int adc )        const; 
  HWIdentifier        adc_id                  ( const HWIdentifier& id,
                                                int adc )                     const;
 
  inline HWIdentifier channel_id              ( IdentifierHash hash_id )      const
    { return m_channel_vec[hash_id]; }
 
  HWIdentifier        adc_id                  ( IdentifierHash hash_id,
                                                int adc )                     const
    { return adc_id(m_channel_vec[hash_id],adc); }
        
 
  bool                is_tilehw               ( const HWIdentifier& id )      const;
  bool                is_low_gain             ( const HWIdentifier& id )      const;
  bool                is_high_gain            ( const HWIdentifier& id )      const;
 
 
  inline int  system  ( const HWIdentifier & id )     const   { return m_system_impl.unpack(id); }
  inline int  section ( const HWIdentifier & id )     const   { return m_section_impl.unpack(id); }
  inline int  ros     ( const HWIdentifier & id )     const   { return m_ros_impl.unpack(id); }
  inline int  drawer  ( const HWIdentifier & id )     const   { return m_drawer_impl.unpack(id); }
  inline int drawerIdx( const HWIdentifier & id )     const   { 
    return std::max(0,(int)(std::upper_bound(m_drawer_vec.begin(),m_drawer_vec.end(),id) - m_drawer_vec.begin())-1); 
  }
  inline int  frag    ( const HWIdentifier & id )     const   { return ((ros(id) << 8) | drawer(id)); }
  inline int  frag    ( int ros, int drawer )         const   { return ((ros << 8) | drawer); }
  inline int  channel ( const HWIdentifier & id )     const   { return m_channel_impl.unpack(id); }
  inline int  adc     ( const HWIdentifier & id )     const   { return m_adc_impl.unpack(id); }
 
  std::string         to_string               ( const HWIdentifier & id, int level=0 )     const;
 
  IdContext    ros_context      (void) const;
  IdContext    drawer_context   (void) const;
  IdContext    channel_context  (void) const;
  IdContext    adc_context      (void) const;
 
  virtual int  get_id    (const IdentifierHash& hash_id, HWIdentifier& id, const IdContext* context = 0 ) const;
  virtual int  get_id    (const IdentifierHash& hash_id,   Identifier& id, const IdContext* context = 0 ) const
    { HWIdentifier hwid(id); int stat=get_id(hash_id, hwid, context); id = hwid.get_compact(); return stat; }
 
  virtual IdentifierHash get_hash (const HWIdentifier& id) const;
 
  virtual int  get_hash  (const HWIdentifier& id, IdentifierHash& hash_id, const IdContext* context = 0 ) const;
  virtual int  get_hash  (const   Identifier& id, IdentifierHash& hash_id, const IdContext* context = 0 ) const
    { HWIdentifier hwid(id); return get_hash(hwid, hash_id, context); }
 
  virtual IdentifierHash get_channel_hash (const HWIdentifier& id) const;
 
 
  virtual int  initialize_from_dictionary (const IdDictMgr& dict_mgr);
 
  inline size_type     ros_hash_max     (void)  const   { return m_ros_hash_max; }
  inline size_type     drawer_hash_max  (void)  const   { return m_drawer_hash_max; }
  inline size_type     channel_hash_max (void)  const   { return m_channel_hash_max; }
  inline size_type     adc_hash_max     (void)  const   { return m_adc_hash_max; }
 
  std::vector<HWIdentifier>::const_iterator ros_begin     (void) const  { return(m_ros_vec.begin()); }
  std::vector<HWIdentifier>::const_iterator ros_end       (void) const  { return(m_ros_vec.end()); }
 
  std::vector<HWIdentifier>::const_iterator drawer_begin  (void) const  { return(m_drawer_vec.begin()); }
  std::vector<HWIdentifier>::const_iterator drawer_end    (void) const  { return(m_drawer_vec.end()); }
 
  std::vector<HWIdentifier>::const_iterator channel_begin (void) const  { return(m_channel_vec.begin()); }
  std::vector<HWIdentifier>::const_iterator channel_end   (void) const  { return(m_channel_vec.end()); }
 
  std::vector<HWIdentifier>::const_iterator adc_begin     (void) const  { return(m_adc_vec.begin()); }
  std::vector<HWIdentifier>::const_iterator adc_end       (void) const  { return(m_adc_vec.end()); }
 
  enum {NOT_VALID_HASH = 64000};
 
private:
 
  int  get_expanded_id  (const HWIdentifier& id, ExpandedIdentifier& exp_id, const IdContext* context) const;
 
  int                   get_field               ( const HWIdentifier & id,
                                                  size_type index )             const;
 
  int         initLevelsFromDict(void) ;
 
  int         init_hashes(void) ;
 
  bool        drawer_id  (const HWIdentifier& ros_id,     int drawer,              HWIdentifier& drawer_id  );
  bool        channel_id (const HWIdentifier& ros_id,     int drawer, int channel, HWIdentifier& channel_id );
  bool        channel_id (const HWIdentifier& drawer_id,  int channel,             HWIdentifier& channel_id );
  bool        adc_id     (const HWIdentifier& channel_id, int adc,                 HWIdentifier& adc_id );
  int         fill_vec      (std::set<HWIdentifier> & ids, 
                             unsigned int hash_max, std::vector<HWIdentifier> & vec);
 
  size_type                     m_tile_region_index;
  size_type                     m_SYSTEM_INDEX;
  size_type                     m_SECTION_INDEX;
  size_type                     m_ROS_INDEX;
  size_type                     m_DRAWER_INDEX;
  size_type                     m_CHANNEL_INDEX;
  size_type                     m_ADC_INDEX;
 
  const IdDictDictionary*       m_dict;
 
  IdDictFieldImplementation     m_system_impl;
  IdDictFieldImplementation     m_section_impl;
  IdDictFieldImplementation     m_ros_impl;
  IdDictFieldImplementation     m_drawer_impl;
  IdDictFieldImplementation     m_channel_impl;
  IdDictFieldImplementation     m_adc_impl;
 
  MultiRange                    m_full_ros_range;
  MultiRange                    m_full_drawer_range;
  MultiRange                    m_full_channel_range;
  MultiRange                    m_full_adc_range;
  size_type                     m_ros_hash_max;
  size_type                     m_drawer_hash_max;
  size_type                     m_channel_hash_max;
  size_type                     m_adc_hash_max;
  std::vector<HWIdentifier>     m_ros_vec;
  std::vector<HWIdentifier>     m_drawer_vec;
  std::vector<HWIdentifier>     m_channel_vec;
  std::vector<HWIdentifier>     m_adc_vec;
 
  HWIdentifier          m_base_tile_ros;
 
};
 
//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( TileHWID , 2902 , 1 )
 
#endif // TILEIDENTIFIER_TILEHWID_H