LArMCSym.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARRAWCONDITIONS_LARMCSYM_H
#define LARRAWCONDITIONS_LARMCSYM_H
 
 
#include "Identifier/HWIdentifier.h"
#include "Identifier/Identifier32.h"
#include "Identifier/IdentifierHash.h"
#include "LArIdentifier/LArOnlineID_Base.h"
#include "CaloIdentifier/CaloCell_Base_ID.h"
 
class LArMCSym
{
public:
  LArMCSym() = delete;
 
 
  LArMCSym(const LArOnlineID_Base* onlId, 
       const CaloCell_Base_ID* caloId,
       std::vector<HWIdentifier>&& oflHashtoSymOnl,
       std::vector<HWIdentifier>&& onlHashtoSymOnl,
       std::vector<HWIdentifier>&& symIds
       );
 
 
  static constexpr size_t NO_INDEX = static_cast<size_t> (-1);
   
 
  HWIdentifier ZPhiSymOfl(const Identifier notSymOffId) const {
    if (m_caloCellID->is_tile(notSymOffId)) return HWIdentifier();
    const IdentifierHash h=m_caloCellID->calo_cell_hash(notSymOffId);
    return ZPhiSymOfl(h);
  }
 
 
  HWIdentifier ZPhiSymOfl(const IdentifierHash notSymOffHash) const {
    assert(notSymOffHash < m_oflHashtoSymOnl.size());
    return HWIdentifier (m_oflHashtoSymOnl[notSymOffHash].first);
  }
  
 
  size_t ZPhiSymOflIndex(const Identifier notSymOffId) const {
    if (m_caloCellID->is_tile(notSymOffId)) return NO_INDEX;
    const IdentifierHash h=m_caloCellID->calo_cell_hash(notSymOffId);
    return ZPhiSymOflIndex(h);
  }
 
  size_t ZPhiSymOflIndex(const IdentifierHash notSymOffHash) const {
    assert(notSymOffHash < m_oflHashtoSymOnl.size());
    return m_oflHashtoSymOnl[notSymOffHash].second;
  }
  
 
  HWIdentifier ZPhiSymOnl(const HWIdentifier notSymOnlId) const {
    const IdentifierHash h=m_onlineID->channel_Hash(notSymOnlId);
    return ZPhiSymOnl(h);
  }
 
 
  HWIdentifier ZPhiSymOnl(const IdentifierHash notSymOnlHash) const {
    assert(notSymOnlHash < m_onlHashtoSymOnl.size());
    return HWIdentifier (m_onlHashtoSymOnl[notSymOnlHash].first);
  }
 
 
  size_t ZPhiSymOnlIndex(const HWIdentifier notSymOnlId) const {
    const IdentifierHash h=m_onlineID->channel_Hash(notSymOnlId);
    return ZPhiSymOnlIndex(h);
  }
 
 
  size_t ZPhiSymOnlIndex(const IdentifierHash notSymOnlHash) const {
    assert(notSymOnlHash < m_onlHashtoSymOnl.size());
    return m_onlHashtoSymOnl[notSymOnlHash].second;
  }
 
 
  const std::vector<HWIdentifier>& symIds() const {
    return m_symIds;
  }
 
  std::pair<size_t,size_t> hashMax() const {
    return std::make_pair(m_onlHashtoSymOnl.size(),m_oflHashtoSymOnl.size());
  }
 
 
 
 private:
  typedef std::pair<Identifier32::value_type, uint32_t> IdPair_t;
  std::vector<IdPair_t>
  initIndices (const std::vector<HWIdentifier>& ids,
               const std::vector<HWIdentifier>& symIds) const;
 
 
  const LArOnlineID_Base* m_onlineID;
  const CaloCell_Base_ID* m_caloCellID;
  const std::vector<IdPair_t> m_oflHashtoSymOnl;
  const std::vector<IdPair_t> m_onlHashtoSymOnl;
  const std::vector<HWIdentifier> m_symIds;
 
};
 
#include "AthenaKernel/CLASS_DEF.h"
CLASS_DEF( LArMCSym , 33771274 , 1 )
#include "AthenaKernel/CondCont.h"
CONDCONT_DEF( LArMCSym, 159334782 );
 
#endif