LArElectrodeID.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARIDENTIFIER_LARELECTRODEID_H
#define LARIDENTIFIER_LARELECTRODEID_H
 
#include "AthenaKernel/CLASS_DEF.h"
#include "AtlasDetDescr/AtlasDetectorID.h"
#include "Identifier/HWIdentifier.h"
#include "Identifier/IdentifierHash.h"
#include "Identifier/Range.h"
#include "IdDict/IdDictFieldImplementation.h"
#include "IdDict/IdDictDefs.h"
#include "LArIdentifier/LArOnlID_Exception.h"
#include <vector>
#include <iostream>
#include <algorithm>
 
class IdentifierHash;
class Range;
 
class LArElectrodeID : public AtlasDetectorID {
 public:
  
 
  typedef Identifier::size_type  size_type;
  
 
  LArElectrodeID(void);
  ~LArElectrodeID(void); 
  
  HWIdentifier ElectrodeId( int det, int side, int mod, int phi, int eta, int gap, int elec ) const;
  HWIdentifier ElectrodeId( IdentifierHash electrode_hash )const;
  IdentifierHash electrodeHash( HWIdentifier electrode_id ) const;
 
  std::vector<HWIdentifier>::const_iterator electrode_begin(void) const;
  std::vector<HWIdentifier>::const_iterator electrode_end(void) const; 
 
  size_type  electrodeHashMax (void) const;
 
  virtual int initialize_from_dictionary (const IdDictMgr& dict_mgr);
  
  int detector ( const HWIdentifier id) const;
  int zside    ( const HWIdentifier id) const;
  int module   ( const HWIdentifier id) const;
  int hv_phi   (const HWIdentifier id) const;
  int hv_eta   (const HWIdentifier id) const;
  int gap      ( const HWIdentifier id) const;
  int electrode( const HWIdentifier id) const;
 
 
  bool isEMB(const HWIdentifier id) const;
  bool isEMBPS(const HWIdentifier id) const;
  bool isEMEC(const HWIdentifier id) const;
  bool isEMECinWHEEL(const HWIdentifier id) const;
  bool isEMECoutWHEEL(const HWIdentifier id) const;
  bool isEMECPS(const HWIdentifier id) const;
  bool isHEC(const HWIdentifier id) const;
  bool isFCAL( const HWIdentifier id) const;
  bool isFCAL1(const HWIdentifier id) const;
  bool isFCAL2(const HWIdentifier id) const;
  bool isFCAL3(const HWIdentifier id) const;
  bool isEMBPUR(const HWIdentifier id) const;
  bool isECPUR(const HWIdentifier id) const;
 
  IdContext    electrodeContext(void) const;
  
  
 private:
  
  
  enum {NOT_VALID_HASH = 256000};
  
  IdentifierHash electrode_hash_binary_search(HWIdentifier elecId) const;
  
  /* Check methods */
  void  electrodeId_checks(int det, int side, int mod, int phi, int eta, int hvgap, int elec )const;
  
  /* create expanded HWIdentifier from HWIdentifier (return == 0 for OK) */
  int  get_expanded_id (const HWIdentifier& id, ExpandedIdentifier& exp_id, 
            const IdContext* context) const;
  
  /* init() hashes */
  int  initLevelsFromDict(void) ;
  int  init_hashes(void);
 
  /* Member Data index */
  size_type m_larElectrodeRegion_index;
  size_type m_larelectrode_index;
  size_type m_atlas_index;     
  size_type m_configuration_index;     
  size_type m_detector_index;     
  size_type m_zside_index;
  size_type m_module_index;      
  size_type m_hvphi_index;      
  size_type m_hveta_index;      
  size_type m_hvgap_index;      
  size_type m_electrode_index;    
  
  const IdDictDictionary*       m_dict;
  MultiRange                    m_full_larelectrode_range;
  MultiRange                    m_full_electrode_range;
  size_type                     m_electrodeHashMax;
  std::vector<HWIdentifier>     m_electrode_vec;
  
  IdDictFieldImplementation     m_atlas_impl;
  IdDictFieldImplementation     m_configuration_impl;
  IdDictFieldImplementation     m_detector_impl;
  IdDictFieldImplementation     m_zside_impl;
  IdDictFieldImplementation     m_module_impl;
  IdDictFieldImplementation     m_hvphi_impl;
  IdDictFieldImplementation     m_hveta_impl;
  IdDictFieldImplementation     m_hvgap_impl;
  IdDictFieldImplementation     m_electrode_impl;
 
};
static const int s_larconfig_value = 1 ;
 
//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( LArElectrodeID , 80757351 , 1 )
 
 
 
 
//=====================
// Inline Definitions
//=====================
     
     
/* Identifier Definition Inline */
inline HWIdentifier LArElectrodeID::ElectrodeId (int det, int zside, int mod, int phi, 
                         int eta, int gap, int elec ) const 
/*============================================================================== */
{
  HWIdentifier result(0);
  /*Pack fields independently */
  m_atlas_impl.pack       (lar_field_value(), result);
  m_configuration_impl.pack(s_larconfig_value, result);
  m_detector_impl.pack    (det    , result);
  m_zside_impl.pack       (zside  , result);
  m_module_impl.pack      (mod    , result);
  m_hvphi_impl.pack       (phi    , result);
  m_hveta_impl.pack       (eta    , result);
  m_hvgap_impl.pack       (gap    , result);
  m_electrode_impl.pack   (elec   , result);
  return result;
}
 
inline HWIdentifier LArElectrodeID::ElectrodeId(IdentifierHash electrodeHashId) const
/*===================================================================*/
{
    return(m_electrode_vec[electrodeHashId]);
}
 
 
inline IdentifierHash LArElectrodeID::electrodeHash (HWIdentifier hvId) const
/*=============================================================================== */
{
    std::vector<HWIdentifier>::const_iterator it = std::lower_bound(m_electrode_vec.begin(),m_electrode_vec.end(),hvId);
    if ( it != m_electrode_vec.end() ){
    return (it - m_electrode_vec.begin());
    }
    return (0);
}
 
inline LArElectrodeID::size_type LArElectrodeID::electrodeHashMax (void) const
/*====================================================================*/
{
  return m_electrodeHashMax;
}
 
 
inline std::vector<HWIdentifier>::const_iterator LArElectrodeID::electrode_begin(void) const
/*====================================================================*/
{
  return(m_electrode_vec.begin());
}
 
inline std::vector<HWIdentifier>::const_iterator LArElectrodeID::electrode_end(void) const
/*==================================================================*/
{
  return(m_electrode_vec.end());
}
 
 
inline int LArElectrodeID::detector(const HWIdentifier id)const
/*===========================================================*/
{
  return (m_detector_impl.unpack(id));
}
 
inline int LArElectrodeID::zside(const HWIdentifier id)const
/*===========================================================*/
{
  return (m_zside_impl.unpack(id));
}
 
 
inline int LArElectrodeID::module(const HWIdentifier id)const
/*===========================================================*/
{
  return (m_module_impl.unpack(id));
}
 
inline int LArElectrodeID::hv_phi(const HWIdentifier id)const
/*===========================================================*/
{
  return (m_hvphi_impl.unpack(id));
}
 
inline int LArElectrodeID::hv_eta(const HWIdentifier id)const
/*===========================================================*/
{
  return (m_hveta_impl.unpack(id));
}
 
inline int LArElectrodeID::gap(const HWIdentifier id)const
/*===========================================================*/
{
  return (m_hvgap_impl.unpack(id));
}
 
inline int LArElectrodeID::electrode(const HWIdentifier id)const
/*===========================================================*/
{
  return (m_electrode_impl.unpack(id));
}
 
 
// ==========================
//   HEC
// ==========================
//
inline bool LArElectrodeID::isHEC( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  return( 
     det == 4
     );
}
 
 
// ==========================
//   FCAL 
// ==========================
//
inline bool LArElectrodeID::isFCAL( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  //int hveta= hv_eta(id);
  return( 
     det == 5 
     );
}
// ==========================
//   FCAL-S1 
// ==========================
//
inline bool LArElectrodeID::isFCAL1( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  int hveta = hv_eta(id);
  return( 
     det == 5 && hveta == 1 
     );
}
 
// ==========================
//   FCAL-S2 
// ==========================
//
inline bool LArElectrodeID::isFCAL2( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  int hveta = hv_eta(id);
  return( 
     det == 5 && hveta == 2
     );
}
// ==========================
//   FCAL-S3 
// ==========================
//
inline bool LArElectrodeID::isFCAL3( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  int hveta = hv_eta(id);
  return( 
     det == 5 && hveta == 3
     );
}
 
// ==========================
//   EMBPUR 
// ==========================
//
inline bool LArElectrodeID::isEMBPUR( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  return( 
     det == 6
     );
}
 
// ==========================
//   ECPUR 
// ==========================
//
inline bool LArElectrodeID::isECPUR( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  return( 
     det == 7
     );
}
 
 
// ==========================
//   EMEC 
// ==========================
//
inline bool LArElectrodeID::isEMEC( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  return( 
     det == 2
     );
}
inline bool LArElectrodeID::isEMECinWHEEL( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  int eta = hv_eta(id);
  return( 
     det == 2 && eta >= 7
     );
}
inline bool LArElectrodeID::isEMECoutWHEEL( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  int eta = hv_eta(id);
  return( 
     det == 2 && eta < 7
     );
}
 
// ==========================
//   EMECPS 
// ==========================
//
inline bool LArElectrodeID::isEMECPS( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  return( 
     det == 3
     );
}
 
// ==========================
//   EMB
// ==========================
//
inline bool LArElectrodeID::isEMB( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  return( 
     det == 0
     );
}
 
 
// ==========================
//   EMBPS
// ==========================
//
inline bool LArElectrodeID::isEMBPS( const HWIdentifier id ) const
/*================================================================*/
{
  int det = detector(id);
  return( 
     det == 1
     );
}
 
 
 
 
 
#endif //LARELECTRODEID_H