CaloDetDescrManager.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 CALODETDESCR_CALODETDESCRMANAGER_H
#define CALODETDESCR_CALODETDESCRMANAGER_H
 
#include "AthenaKernel/CLASS_DEF.h"
#include "AthenaKernel/CondCont.h"
#include "CaloIdentifier/CaloCell_ID.h"
#include "CaloDetDescr/CaloConstIteratorAdaptor.h"
#include <ranges>
 
class CaloCell_SuperCell_ID;
class CaloDetDescrElement;
class CaloDetDescriptor;
class CaloCellPacker_400_500_test;
 
class Identifier;
class IdentifierHash;
class CaloIdManager;
 
/*
  Detector Store Key for the manager which gets built by one of the clients which
  still need to access it at initialization. The number of such clients is very limited.
 
  If such a manager is built in a simulation job, then at this point the initial set
  of alignment corrections has already been applied to the GeoModel tree. Therefore these 
  alignments will be applied to the Calo DD too. No more alignment corrections will be
  applied to the Calo DD through the rest of the simulation job.
 
  If one of the clients builds such a manager in some other type of job (e.g., Reconstruction),
  then at this point no alignment corrections have been applied to Calo DD. Therefore the
  clients get an ideal Calo DD, which, again, will not change through the rest of the given job.
 */
constexpr static const char* caloMgrStaticKey = "CaloMgrStatic";
 
class CaloDetDescrManager_Base
{
 public:
  CaloDetDescrManager_Base();
  ~CaloDetDescrManager_Base();
  
  void initialize();
  void print() const;
 
  inline bool isInitialized() const {return true;}
  inline const std::string& lar_geometry() const {return m_lar_geometry;}
  inline void set_lar_geometry(const std::string& geom) { m_lar_geometry = geom;}
 
  const CaloCell_Base_ID*   getCaloCell_ID() const;
  const CaloIdManager* getCalo_Mgr() const;
 
  // Iterator over detector elements.
  // Value type is `const CaloDetDescrElement*'.
  using calo_element_vec = std::vector<CaloDetDescrElement*>;
  using calo_element_vec_size = calo_element_vec::size_type;
  using calo_element_const_iterator = CaloConstIteratorAdaptor<calo_element_vec::const_iterator>;
  using calo_element_range = std::ranges::subrange<calo_element_const_iterator>;
 
  // Iterator over non-const detector elements.
  using calo_nonconst_element_const_iterator = calo_element_vec::const_iterator;
  using calo_nonconst_element_range = std::ranges::subrange<calo_nonconst_element_const_iterator>;
 
  
  calo_element_vec_size       element_size()  const;
  calo_element_const_iterator element_begin() const;
  calo_element_const_iterator element_end()   const;
  calo_element_range element_range()   const;
  calo_element_const_iterator element_begin(CaloCell_ID::SUBCALO subCalo) const;
  calo_element_const_iterator element_end(CaloCell_ID::SUBCALO subCalo)   const;
  calo_element_range element_range(CaloCell_ID::SUBCALO subCalo)   const;
 
  calo_nonconst_element_range element_range_nonconst();
 
  const CaloDetDescrElement* get_element(const Identifier& cellId) const;
  CaloDetDescrElement* get_element_nonconst(const Identifier& cellId);
  const CaloDetDescrElement* get_element(IdentifierHash caloCellHash) const;
  CaloDetDescrElement* get_element_nonconst(IdentifierHash caloCellHash);
  const CaloDetDescrElement* get_element (CaloCell_ID::SUBCALO subCalo,
                                          IdentifierHash subCaloCellHash) const;
  const CaloDetDescrElement* get_element (CaloCell_ID::SUBCALO subCalo,
                                          int sampling_or_module, 
                                          bool barrel,
                                          double eta, double phi) const;
  const CaloDetDescrElement* get_element (CaloCell_ID::CaloSample sample,
                                          double eta, 
                                          double phi) const;
 
  const CaloDetDescrElement* get_element_raw (CaloCell_ID::CaloSample sample,
                                              double eta, 
                                              double phi) const;
 
  void cellsInZone(double eta_min, double eta_max, 
           double phi_min, double phi_max,
           std::vector<IdentifierHash> & cell_list) const;
    
  void cellsInZone(double eta_min, double eta_max, double phi_min,
           double phi_max, CaloCell_ID::SUBCALO subCalo,
           std::vector<IdentifierHash> & cell_list) const;
    
  void cellsInZone(double eta_min, double eta_max, double phi_min,
           double phi_max, CaloCell_ID::CaloSample sample,
           std::vector<IdentifierHash> & cell_list) const;
  
  void cellsInZone(double eta_min, double eta_max,double phi_min, 
           double phi_max, CaloCell_ID::SUBCALO subCalo,
           int sampling_or_module, 
           std::vector<IdentifierHash> & cell_list) const;
 
  void cellsInZone(double eta, double phi, int ncell_eta,
           int ncell_phi, CaloCell_ID::SUBCALO subCalo,
           int sampling_or_module, bool barrel,
           std::vector<IdentifierHash> & cell_list) const;
    
   void cellsInZone(double eta_min, double eta_max, double phi_min,
                     double phi_max, const CaloDetDescriptor* descr,
                     std::vector<IdentifierHash> & cell_list) const;
 
  bool is_in (double eta, double phi, CaloCell_ID::CaloSample sample, double& etadist) const; 
  
  static
  void build_sample (CaloCell_ID::SUBCALO subCalo, bool barrel,
             int sampling_or_module,
             CaloCell_ID::CaloSample& sample);
  static
  void decode_sample (CaloCell_ID::SUBCALO& subCalo, bool& barrel,
              int& sampling_or_module,
              CaloCell_ID::CaloSample sample);   
 
 
  // Iterator over detector descriptors.
  // Value type is `const CaloDetDescriptor*'.
  using calo_descr_vec = std::vector <CaloDetDescriptor*>;
  using calo_descr_size = calo_descr_vec::size_type;
  using calo_descr_const_iterator = CaloConstIteratorAdaptor<calo_descr_vec::const_iterator>;
  using calo_descr_range = std::ranges::subrange<calo_descr_const_iterator>;
    
 
  // Iterator over non-const detector descriptors.
  using calo_nonconst_descr_const_iterator = calo_descr_vec::const_iterator;
  using calo_nonconst_descr_range = std::ranges::subrange<calo_nonconst_descr_const_iterator>;
 
 
  calo_descr_const_iterator calo_descriptors_begin() const;
  calo_descr_const_iterator calo_descriptors_end() const;
  calo_descr_size       calo_descriptors_size() const;
  calo_descr_range      calo_descriptors_range() const;
  calo_nonconst_descr_range     calo_descriptors_range_nonconst();
 
  const CaloDetDescriptor* get_descriptor (const Identifier& regionId) const;
  CaloDetDescriptor* get_descriptor_nonconst (const Identifier& regionId);
  const CaloDetDescriptor* get_descriptor(CaloCell_ID::SUBCALO subCalo,
                                          int sampling_or_module, 
                                          bool barrel,
                                          double eta, 
                                          double phi) const;
  const CaloDetDescriptor* get_descriptor (CaloCell_ID::CaloSample sample,
                                           double eta, double phi) const;
 
  const CaloDetDescriptor* get_descriptor_raw (CaloCell_ID::CaloSample sample, 
                                               double eta, double phi) const;
 
 
  calo_descr_const_iterator   tile_descriptors_begin () const;
  calo_descr_const_iterator   tile_descriptors_end   () const;
  calo_descr_size             tile_descriptors_size  () const;
  calo_descr_range            tile_descriptors_range  () const;
  calo_nonconst_descr_range   tile_descriptors_range_nonconst  ();
 
  void set_helper (const CaloCell_Base_ID* idHelper);
  void set_helper (const CaloIdManager* idHelper);
 
  void add(CaloDetDescrElement* element);
  void add(CaloDetDescriptor* descr);
  void add(std::unique_ptr<CaloDetDescriptor> descr);
  void add_tile(CaloDetDescriptor* descr);
 
private:
  friend class CaloCellPacker_400_500_test;
  CaloDetDescrElement* release_element (IdentifierHash hash);
 
 
  const CaloCell_Base_ID*    m_cell_id;
  const CaloIdManager*  m_calo_mgr;
  
  calo_element_vec  m_element_vec;
  calo_descr_vec    m_descr_vec;
 
  std::vector <IdentifierHash> m_subCalo_min;
  std::vector <IdentifierHash> m_subCalo_max;
  std::vector <calo_element_const_iterator> m_subCalo_begin;
  std::vector <calo_element_const_iterator> m_subCalo_end;
 
  calo_descr_vec      m_tile_descr_vec;
 
  std::string m_lar_geometry;
 
  const CaloDetDescrElement* get_element_FCAL (const CaloDetDescriptor* reg,
                                               double eta, 
                                               double phi) const;
 
  const CaloDetDescrElement* get_element_FCAL_raw (const CaloDetDescriptor* reg,
                                                   double eta,
                                                   double phi) const;
 
 
};
 
 
class CaloDetDescrManager
  : public CaloDetDescrManager_Base
{
public:
  const CaloCell_ID*   getCaloCell_ID() const;
  void set_helper (const CaloCell_ID* idHelper);
  void set_helper (const CaloIdManager* idHelper);
 
};
 
CLASS_DEF( CaloDetDescrManager , 4548337 , 1 )
CONDCONT_DEF( CaloDetDescrManager , 206559529 );
 
class CaloSuperCellDetDescrManager
  : public CaloDetDescrManager_Base
{
public:
  virtual ~CaloSuperCellDetDescrManager();
 
  const CaloCell_SuperCell_ID*   getCaloCell_ID() const;
  void set_helper (const CaloCell_SuperCell_ID* idHelper);
  void set_helper (const CaloIdManager* idHelper);
 
};
 
 
CLASS_DEF( CaloSuperCellDetDescrManager , 241807251 , 1 )
CONDCONT_DEF( CaloSuperCellDetDescrManager , 70344197 );
 
inline  const CaloDetDescrElement*          
CaloDetDescrManager_Base::get_element (IdentifierHash caloCellHash) const
{
  if ( caloCellHash < m_element_vec.size() ) 
    return m_element_vec[caloCellHash] ;
  else return nullptr ;
}
                       
inline CaloDetDescrElement*         
CaloDetDescrManager_Base::get_element_nonconst (IdentifierHash caloCellHash)
{
  if ( caloCellHash < m_element_vec.size() ) 
    return m_element_vec[caloCellHash] ;
  else return nullptr ;
}
                       
 
#endif // CALODETDESCR_CALODETDESCRMANAGER_H