CaloTowerGeometry.h

Go to the documentation of this file.

// -*- c++ -*-
#ifndef CALOREC_CALOTOWERGEOMETRY_H
#define CALOREC_CALOTOWERGEOMETRY_H
 
/* Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration */
 
#include "Identifier/IdentifierHash.h"
 
#include "CaloGeoHelpers/CaloPhiRange.h"
 
#include "CaloDetDescr/CaloDetDescrElement.h"
#include "CaloDetDescr/CaloDetDescrManager.h"
 
#include "GaudiKernel/MsgStream.h"
 
#include <string>
#include <vector>
#include <cmath>
#include <array>
#include <tuple>
#include <fstream>
 
class CaloTowerGeometry {
public:
  typedef std::size_t                  uint_t;           
  typedef IdentifierHash::value_type   index_t;          
  typedef std::tuple<index_t,double>   element_t;        
  typedef std::vector<element_t>       elementvector_t;  
  typedef std::vector<elementvector_t> elementmap_t;     
 
  friend class CaloTowerGeometryCondAlg;

  CaloTowerGeometry(const CaloDetDescrManager* caloDDM);
 
  CaloTowerGeometry() = delete;
  StatusCode initialize(MsgStream& msg);                 
 
  // --- Full documentation of this block after end of class definition!
  StatusCode      access(IdentifierHash cellHash,std::vector<index_t>& towerIdx,std::vector<double>& towerWghts) const;
  elementvector_t getTowers(IdentifierHash cellHash)                                                             const; 

  uint_t maxCellHash()      const; 
  uint_t totalNumberCells() const; 
  uint_t etaBins()          const; 
  double etaMin()           const; 
  double etaMax()           const; 
  double etaWidth()         const; 
  uint_t phiBins()          const; 
  double phiMin()           const; 
  double phiMax()           const; 
  double phiWidth()         const; 
  uint_t towerBins()        const; 
  double towerArea()        const; 

  index_t etaIndex(IdentifierHash cellHash)          const; 
  index_t etaIndex(double eta)                       const; 
  index_t etaIndexFromTowerIndex(index_t towerIdx)   const; 
  index_t phiIndex(IdentifierHash cellHash)          const; 
  index_t phiIndex(double phi)                       const; 
  index_t phiIndexFromTowerIndex(index_t towerIdx)   const; 
  index_t towerIndex(IdentifierHash cellHash)        const; 
  index_t towerIndex(double eta,double phi)          const; 
  index_t towerIndex(index_t etaIdx,index_t phiIdx)  const; 
  index_t towerIndex(const element_t& elm)           const; 
  index_t invalidIndex()                             const; 
  bool    isInvalidIndex(index_t idx)                const; 
  bool    isInvalidIndex(index_t idx,index_t maxIdx) const; 
  bool    isInvalidEtaIndex(index_t idx)             const; 
  bool    isInvalidPhiIndex(index_t idx)             const; 
  bool    isInvalidTowerIndex(index_t idx)           const; 

  double towerEtaLocal(index_t etaIndex)    const; 
  double towerPhiLocal(index_t phiIndex)    const; 
  double towerEta(index_t towerIndex)       const; 
  double towerPhi(index_t towerIndex)       const; 
  double invalidValue()                     const; 
  bool   isInvalidValue(double val)         const; 

  double  cellWeight(const element_t& elm)                     const; 
  double  cellWeight(IdentifierHash cellHash,index_t towerIdx) const; 

  elementmap_t::const_iterator begin() const;  
  elementmap_t::const_iterator end()   const;  
  size_t                       size()  const;  
  bool                         empty() const;  
 
private:

  StatusCode f_setupTowerGrid(MsgStream& msg);                                                              
  StatusCode f_setupTowerGridFCal(const CaloDetDescrElement* pCaloDDE, MsgStream& msg); 
  StatusCode f_setupTowerGridProj(const CaloDetDescrElement* pCaloDDE, MsgStream& msg); 
  double     f_assign(IdentifierHash cellHash,index_t towerIdx,double wgt);                   

  const CaloDetDescrManager* m_caloDDM;               
 
protected:

  elementmap_t m_towerLookup;   
  double       m_towerEtaWidth; 
  double       m_towerPhiWidth; 
  double       m_towerArea;     
  uint_t       m_towerBins;     
  uint_t       m_maxCellHash;   
  uint_t       m_numberOfCells{}; 
  
  uint_t m_towerEtaBins; 
  double m_towerEtaMin;  
  double m_towerEtaMax;  
  bool   m_adjustEta;    
  uint_t m_towerPhiBins; 
  double m_towerPhiMin;  
  double m_towerPhiMax;  
  double m_fcal1Xslice;  
  double m_fcal1Yslice;  
  double m_fcal2Xslice;  
  double m_fcal2Yslice;  
  double m_fcal3Xslice;  
  double m_fcal3Yslice;  

  const static index_t m_invalidIndex;                                       
  const static double  m_invalidValue;                                       
  const CaloDetDescrManager* f_caloDDM()                        const; 
 
  const CaloDetDescrElement* f_caloDDE(IdentifierHash cellHash) const; 
 
  double f_cellEta(IdentifierHash cellHash)                     const; 
 
  double f_cellPhi(IdentifierHash cellHash)                     const; 

  std::array<double,3> m_ndxFCal{}; 
  std::array<double,3> m_ndyFCal{}; 
  std::array<double,3> m_wgtFCal{}; 
};
 
#include "AthenaKernel/CLASS_DEF.h"
CLASS_DEF( CaloTowerGeometry, 9072807, 1 )
#include "AthenaKernel/CondCont.h"
CONDCONT_DEF(CaloTowerGeometry, 52208619);
 
 
 
//-------------------------------------------------//
// Documentation for grouped methods and functions //
// (removed from before/after method for better    //
// formatting by doxygen in html).                 //
//-------------------------------------------------//


 
//---------------------//
// Class documentation //
//---------------------//

 
//------------------//
// Inline Functions //
//------------------//
 
//---------------------------//
// Control and configuration //
//---------------------------//
inline CaloTowerGeometry::index_t CaloTowerGeometry::invalidIndex() const { return m_invalidIndex; }
 
//------------------------------------//
// Public access to tower descriptors //
//------------------------------------//
inline CaloTowerGeometry::uint_t CaloTowerGeometry::maxCellHash()      const { return m_maxCellHash;   }
inline CaloTowerGeometry::uint_t CaloTowerGeometry::totalNumberCells() const { return m_numberOfCells; }  
 
inline CaloTowerGeometry::uint_t CaloTowerGeometry::etaBins()          const { return m_towerEtaBins;  }
inline double                       CaloTowerGeometry::etaMin()           const { return m_towerEtaMin;   }
inline double                       CaloTowerGeometry::etaMax()           const { return m_towerEtaMax;   }
inline double                       CaloTowerGeometry::etaWidth()         const { return m_towerEtaWidth; }
 
inline CaloTowerGeometry::uint_t CaloTowerGeometry::phiBins()          const { return m_towerPhiBins;  }
inline double                       CaloTowerGeometry::phiMin()           const { return m_towerPhiMin;   }
inline double                       CaloTowerGeometry::phiMax()           const { return m_towerPhiMax;   }
inline double                       CaloTowerGeometry::phiWidth()         const { return m_towerPhiWidth; }
 
inline CaloTowerGeometry::uint_t CaloTowerGeometry::towerBins()        const { return m_towerBins;     }
inline double                       CaloTowerGeometry::towerArea()        const { return m_towerArea;     } 
 
//----------------//
// Index checking //
//----------------//
inline bool CaloTowerGeometry::isInvalidIndex(index_t idx)                const { return idx == invalidIndex(); }
inline bool CaloTowerGeometry::isInvalidIndex(index_t idx,index_t maxIdx) const { return idx == invalidIndex() || idx >= maxIdx; }
inline bool CaloTowerGeometry::isInvalidEtaIndex(index_t idx)             const { return isInvalidIndex(idx,m_towerEtaBins); }
inline bool CaloTowerGeometry::isInvalidPhiIndex(index_t idx)             const { return isInvalidIndex(idx,m_towerPhiBins); }
inline bool CaloTowerGeometry::isInvalidTowerIndex(index_t idx)           const { return isInvalidIndex(idx,m_towerBins); }
 
//------------------------------//
// Index retrieval/construction //
//------------------------------// 
 
inline CaloTowerGeometry::index_t CaloTowerGeometry::towerIndex(IdentifierHash cellHash)       const { return towerIndex(etaIndex(cellHash),phiIndex(cellHash)); }
inline CaloTowerGeometry::index_t CaloTowerGeometry::towerIndex(double eta,double phi)         const { return towerIndex(etaIndex(eta),phiIndex(phi)); }
inline CaloTowerGeometry::index_t CaloTowerGeometry::towerIndex(index_t etaIdx,index_t phiIdx) const { return !isInvalidEtaIndex(etaIdx) && !isInvalidPhiIndex(phiIdx) ? phiIdx+etaIdx*m_towerPhiBins :  invalidIndex(); } 
 
inline CaloTowerGeometry::index_t CaloTowerGeometry::towerIndex(const element_t& elm)          const { return std::get<0>(elm); }
 
inline CaloTowerGeometry::index_t CaloTowerGeometry::etaIndexFromTowerIndex(index_t towerIdx)  const { return (index_t)(towerIdx/phiBins()); }
inline CaloTowerGeometry::index_t CaloTowerGeometry::phiIndexFromTowerIndex(index_t towerIdx)  const { return (index_t)(towerIdx%phiBins()); } 
 
//-----------------------------//
// Access to tower description //
//-----------------------------//
 
inline double CaloTowerGeometry::invalidValue()                const { return m_invalidValue; }
inline bool   CaloTowerGeometry::isInvalidValue(double val)    const { return val == invalidValue(); }
inline double CaloTowerGeometry::towerEtaLocal(index_t etaIdx) const { return !isInvalidEtaIndex(etaIdx) ? etaMin()+(static_cast<double>(etaIdx)+0.5)*etaWidth() : invalidValue(); }
inline double CaloTowerGeometry::towerPhiLocal(index_t phiIdx) const { return !isInvalidPhiIndex(phiIdx) ? phiMin()+(static_cast<double>(phiIdx)+0.5)*phiWidth() : invalidValue(); }
inline double CaloTowerGeometry::towerEta(index_t towerIdx)    const { return towerEtaLocal(etaIndexFromTowerIndex(towerIdx)); }
inline double CaloTowerGeometry::towerPhi(index_t towerIdx)    const { return towerPhiLocal(phiIndexFromTowerIndex(towerIdx)); }  
 
inline CaloTowerGeometry::elementmap_t::const_iterator CaloTowerGeometry::begin() const { return m_towerLookup.begin(); }
inline CaloTowerGeometry::elementmap_t::const_iterator CaloTowerGeometry::end()   const { return m_towerLookup.end(); }
inline size_t                                             CaloTowerGeometry::size()  const { return m_towerLookup.size(); }
inline bool                                               CaloTowerGeometry::empty() const { return m_towerLookup.empty(); }
 
//-------------------//
// Other data access //
//-------------------//
inline double CaloTowerGeometry::cellWeight(const element_t& elm)                   const { return std::get<1>(elm); }
 
 
//----------------------------------//
// Internal functions and accessors //
//----------------------------------//
inline const CaloDetDescrManager* CaloTowerGeometry::f_caloDDM()                        const { return m_caloDDM; } 
inline const CaloDetDescrElement* CaloTowerGeometry::f_caloDDE(IdentifierHash cellHash) const { return f_caloDDM()->get_element(cellHash); }
 
inline double CaloTowerGeometry::f_cellEta(IdentifierHash cellHash) const { return f_caloDDE(cellHash)->eta(); }
inline double CaloTowerGeometry::f_cellPhi(IdentifierHash cellHash) const { return CaloPhiRange::fix(f_caloDDE(cellHash)->phi()); }
 
#endif