SiliconID.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */
 
#ifndef INDETIDENTIFIER_XXX_SILICONID_H
#define INDETIDENTIFIER_XXX_SILICONID_H
 
#include "AtlasDetDescr/AtlasDetectorID.h"
#include "Identifier/Identifier.h"
#include "Identifier/IdentifierHash.h"
#include "Identifier/IdHelper.h"
#include "InDetIdentifier/PixelID.h"
#include "InDetIdentifier/SCT_ID.h"
#include "AthenaKernel/CLASS_DEF.h"
 
 
 
class SiliconID final: public AtlasDetectorID
{
public:
 
  typedef Identifier::size_type size_type;
 
 
  SiliconID();
  SiliconID(const PixelID* pixel_helper, const SCT_ID* sct_helper);
  ~SiliconID();
 
 
  Identifier wafer_id(IdentifierHash wafer_hash) const;
 
  IdentifierHash wafer_hash(Identifier wafer_id) const;
 
  size_type wafer_hash_max() const;
 
  bool is_barrel(const Identifier& id) const;
 
  bool is_blayer(const Identifier& id) const;
 
  bool is_hash_pixel(IdentifierHash wafer_hash) const;
 
 
 
 
  virtual int get_id(const IdentifierHash& hash_id,
                     Identifier& id,
                     const IdContext* context = 0) const override final;
 
  virtual int get_hash(const Identifier& id,
                       IdentifierHash& hash_id,
                       const IdContext* context = 0) const override final;
 
  virtual int initialize_from_dictionary(const IdDictMgr& dict_mgr) override final;
 
  int test_wafer_hashes() const;
private:
  size_type m_wafer_hash_max;
  size_type m_pixel_wafer_hash_max;
  const PixelID* m_pixel_helper;
  const SCT_ID* m_sct_helper;
};
 
 
 
//using the macros 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(SiliconID, 129452393, 1)
 
//----------------------------------------------------------------------------
inline Identifier
SiliconID::wafer_id(IdentifierHash wafer_hash) const {
  // Identifier from hash
  if (wafer_hash < m_pixel_wafer_hash_max) {
    // Pixel hash
    return(m_pixel_helper->wafer_id(wafer_hash));
  } else if (wafer_hash < m_wafer_hash_max) {
    // SCT hash
    return(m_sct_helper->wafer_id(wafer_hash - m_pixel_wafer_hash_max));
  }
  // return invalid Identifier
  Identifier result;
  return(result);
}
 
//----------------------------------------------------------------------------
inline IdentifierHash
SiliconID::wafer_hash(Identifier wafer_id) const {
  // wafer hash from id
  if (is_pixel(wafer_id)) {
    // Pixel id
    return(m_pixel_helper->wafer_hash(wafer_id));
  } else {
    // SCT hash + pixel hash max
    return(m_sct_helper->wafer_hash(wafer_id) + m_pixel_wafer_hash_max);
  }
}
 
//----------------------------------------------------------------------------
inline SiliconID::size_type
SiliconID::wafer_hash_max() const {
  // Hash table maximum sizes
  return(m_wafer_hash_max);
}
 
//----------------------------------------------------------------------------
inline bool
SiliconID::is_barrel(const Identifier& id) const {
  if (is_pixel(id)) {
    // Pixel id
    return(m_pixel_helper->is_barrel(id));
  } else {
    // SCT
    return(m_sct_helper->is_barrel(id));
  }
}
 
//----------------------------------------------------------------------------
inline bool
SiliconID::is_blayer(const Identifier& id) const {
  if (is_pixel(id)) {
    // Pixel id
    return(m_pixel_helper->is_blayer(id));
  } else {
    // SCT
    return(false);
  }
}
 
//----------------------------------------------------------------------------
inline bool
SiliconID::is_hash_pixel(IdentifierHash wafer_hash) const {
  // Identifier from hash
  if (wafer_hash < m_pixel_wafer_hash_max) {
    // Pixel hash
    return(true);
  }
  // SCT hash
  return(false);
}
 
#endif // INDETIDENTIFIER_SILICONID_H