CaloIDHelper.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef CALOIDENTIFIER_CALOIDHELPER_H
#define CALOIDENTIFIER_CALOIDHELPER_H
 
 
#include "AtlasDetDescr/AtlasDetectorID.h"
#include "Identifier/Identifier.h"
#include "Identifier/IdentifierHash.h"
#include "Identifier/MultiRange.h" //used in the icc file
#include "Identifier/RangeIterator.h"
#include "boost/range/iterator_range.hpp"
#include <vector>
#include <set>
class IMessageSvc;
class IdDictRegion;
 
 
class CaloIDHelper
  : public AtlasDetectorID
{
public:
  enum { NOT_VALID=999999 };
 
 
  typedef Identifier::size_type  size_type ;
 
  typedef std::vector<Identifier>::const_iterator id_iterator;
  typedef boost::iterator_range<id_iterator> id_range;
 
 
 
  class HashGroup
  {
  public:
    HashGroup();
 
 
    template <class T>
    int init (T& parent,
              const std::string& type,
              const MultiRange& full_range,
              Identifier (T::*idfunc) (const ExpandedIdentifier&) const,
              size_type end_index);
              
 
    int init (const std::string& name,
              const std::set<Identifier>& ids,
              size_type end_index,
              IMessageSvc* msgSvc,
              const MultiRange* full_range = 0);
 
 
    size_type hash_max() const;
 
    id_iterator begin() const;
    id_iterator end()   const;
    id_range    range() const;
 
    Identifier id (IdentifierHash hashId) const;
 
    
    int get_hash (Identifier id, IdentifierHash& hash_id) const;
 
 
    IdentifierHash hash (Identifier id) const;
 
    const std::vector<Identifier>& ids() const;
 
    size_type end_index() const;
 
    IdContext context() const;
 
 
  private:
    std::vector<Identifier> m_id_vec;
 
    size_type m_end_index;
  };
 
 
  CaloIDHelper (const std::string& name, const std::string& group);
 
 
  const HashGroup& channels() const;
 
  const HashGroup& regions() const;
 
  Identifier channel_id (IdentifierHash hashId) const;
  Identifier region_id (IdentifierHash hashId) const;
 
 
  IdentifierHash channel_hash (Identifier channelId) const;
 
 
  IdentifierHash region_hash (Identifier regionId) 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;
 
 
  size_type channel_hash_max() const;
  size_type region_hash_max() const;
 
 
  IdContext channel_context() const;
  IdContext region_context() const;
 
 
  const std::vector<const IdDictRegion*>& dictRegions() const;
 
 
  float etaGranularity(const IdentifierHash regHash) const;
 
 
  float phiGranularity(const IdentifierHash regHash) const;
 
 
  float eta0(const IdentifierHash regHash) const;
 
 
  float phi0(const IdentifierHash regHash) const;
 
 
  const std::string& name() const;
 
  IMessageSvc* msgSvc();
 
 
 
protected:
  int initialize_base_from_dictionary (const IdDictMgr& dict_mgr,
                                       const std::string& dict_name);
 
 
  HashGroup& channels();
  HashGroup& regions();
 
 
  const IdDictDictionary* dict() const;
 
 
  int fill_vec_of_dict_regions (const std::string& group_name = "");
 
 
  virtual int get_expanded_id (const Identifier& id,
                               ExpandedIdentifier& exp_id,
                               const IdContext* context) const = 0;
 
 
private:
  std::string m_name;
 
  HashGroup m_channels;
 
  HashGroup m_regions;
 
  const IdDictDictionary* m_dict;
 
  std::vector<const IdDictRegion*> m_vecOfDictRegions;
};
 
 
#include "CaloIdentifier/CaloIDHelper.icc"
 
 
#endif // not CALOIDENTIFIER_CALOIDHELPER_H