Calorimeter/CaloIdentifier/CaloIdentifier/TileTBID.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
/***************************************************************************
 Tile Calorimeter detector description package
 -----------------------------------------
 ***************************************************************************/
 
//<doc><file>   $Id: TileTBID.h,v 1.1 2009-03-30 11:19:27 tsulaia Exp $
//<version> $Name: not supported by cvs2svn $
 
// TileTBID.h
//
// Atlas detector Identifier class for Tile Calorimeter
//
 
#ifndef TILEIDENTIFIER_TILETBID_H
#define TILEIDENTIFIER_TILETBID_H
 
#include "CaloIdentifier/TileID.h"
 
class TileTBID : public AtlasDetectorID {
 
public:
 
  typedef Identifier::size_type  size_type ;
      
  TileTBID(void);
 
  virtual ~TileTBID();
 
  enum        SECTION   { TILE_TESTBEAM = 4 /*TileID::TESTBEAM*/ };
  enum        RO_TYPE   { PROTO_TYPE = 2,
                          ADC_TYPE   = 3,
                          TDC_TYPE   = 4,
                          FADC_TYPE  = 5,
                          INT_TYPE   = 6 };
  enum        DET_NUM   { S_COUNTER  = 0, CIS_PAR = 0,
                          CH_COUNTER = 1, PATTERN_UNIT = 1,
                          LASER      = 2,
                          BACK_WALL  = 3,
                          SIDE_WALL  = 4,
                          CRACK_WALL = 5,
                          PHANTOM_CALO = 6 };
  
 
  Identifier          tiletb_id               ( void )                        const;
  Identifier          type_id                 ( int type)                     const;
  Identifier          type_id                 ( int type, bool checks )       const;
  Identifier          module_id               ( int type, int module )        const;
  Identifier          module_id               ( int type, int module, bool checks ) const;
  Identifier          channel_id              ( int type, int module, 
                                                int channel )                 const;
  Identifier          channel_id              ( int type, int module, 
                                                int channel,
                                                bool checks)                  const;
 
  Identifier          module_id               ( const Identifier& id )        const; 
  Identifier          channel_id              ( const Identifier& id,
                                                int channel )                 const; 
 
  bool          is_tiletb               ( const Identifier& id )        const;
 
  inline int    system  ( const Identifier & id )  const    { return m_system_impl.unpack(id); }
  inline int    section ( const Identifier & id )  const    { return m_section_impl.unpack(id); }
  inline int    type    ( const Identifier & id )  const    { return m_type_impl.unpack(id); }
  inline int    module  ( const Identifier & id )  const    { return m_module_impl.unpack(id); }
  inline int    channel ( const Identifier & id )  const    { return m_channel_impl.unpack(id); }
 
  inline int side  ( const Identifier & id )  const { return type(id); }
  inline int phi   ( const Identifier & id )  const { return module(id); }
  inline int eta   ( const Identifier & id )  const { return channel(id); }
  
 
  std::string         to_string               ( const Identifier & id, int level=0 )     const;
 
  IdContext    type_context     (void) const;
  IdContext    module_context   (void) const;
  IdContext    channel_context  (void) 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;
 
  virtual int  initialize_from_dictionary (const IdDictMgr& dict_mgr);
 
  inline size_type      type_hash_max   (void) const    { return m_type_hash_max; }
  inline size_type      module_hash_max (void) const    { return m_module_hash_max; }
  inline size_type      channel_hash_max(void) const    { return m_channel_hash_max; }
 
  std::vector<Identifier>::const_iterator type_begin     (void) const   { return(m_type_vec.begin()); }
  std::vector<Identifier>::const_iterator type_end       (void) const   { return(m_type_vec.end()); }
 
  std::vector<Identifier>::const_iterator module_begin  (void) const    { return(m_module_vec.begin()); }
  std::vector<Identifier>::const_iterator module_end    (void) const    { return(m_module_vec.end()); }
 
  std::vector<Identifier>::const_iterator channel_begin (void) const    { return(m_channel_vec.begin()); }
  std::vector<Identifier>::const_iterator channel_end   (void) const    { return(m_channel_vec.end()); }
 
  enum {NOT_VALID_HASH = 64000};
 
private:
 
  int  get_expanded_id  (const Identifier& id, ExpandedIdentifier& exp_id, const IdContext* context) const;
 
  int                   get_field               ( const Identifier & id,
                                                  size_type index )             const;
 
  int         initLevelsFromDict(void) ;
 
  int         init_hashes(void) ;
 
  bool        module_id  (const Identifier& type_id,    int module,              Identifier& module_id  );
  bool        channel_id (const Identifier& type_id,    int module, int channel, Identifier& channel_id );
  bool        channel_id (const Identifier& module_id,  int channel,             Identifier& channel_id );
  int         fill_vec      (std::set<Identifier> & ids, 
                             unsigned int hash_max, std::vector<Identifier> & vec);
 
  size_type                     m_tile_region_index;
  size_type                     m_SYSTEM_INDEX;
  size_type                     m_SECTION_INDEX;
  size_type                     m_TYPE_INDEX;
  size_type                     m_MODULE_INDEX;
  size_type                     m_CHANNEL_INDEX;
 
  const IdDictDictionary*       m_dict;
 
  IdDictFieldImplementation     m_system_impl;
  IdDictFieldImplementation     m_section_impl;
  IdDictFieldImplementation     m_type_impl;
  IdDictFieldImplementation     m_module_impl;
  IdDictFieldImplementation     m_channel_impl;
 
  MultiRange                    m_full_type_range;
  MultiRange                    m_full_module_range;
  MultiRange                    m_full_channel_range;
  size_type                     m_type_hash_max;
  size_type                     m_module_hash_max;
  size_type                     m_channel_hash_max;
  std::vector<Identifier>       m_type_vec;
  std::vector<Identifier>       m_module_vec;
  std::vector<Identifier>       m_channel_vec;
 
  Identifier            m_base_tile_type;
};
 
//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( TileTBID , 2903 , 1 )
 
#endif // TILEIDENTIFIER_TILETBID_H