CaloTowerSeg.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 CALOEVENT_CALOTOWERSEG_H
#define CALOEVENT_CALOTOWERSEG_H
/********************************************************************
 
NAME:     CaloTowerSeg
PACKAGE:  offline/Calorimeter/CaloRec
 
AUTHORS:  S. Rajagopalan 
CREATED:  Oct, 2000
          Originally it is LArTowerSeg in LArClusterRec
      Moved to CaloRec on Feb 5, 2001  by H.Ma 
 
PURPOSE:  
      Store segmentation for the tower configuration.
          Constructor takes segmentation parameters. 
      Public methods for accessing the limits, and tower sizes,
      and check bounds. 
      
MODIFIED: indices now unsigned integers; ranges [1,size]
 
********************************************************************/
 
// INCLUDE HEADER FILES:
 
#include <cmath>
#include <cstdlib>
 
#include "CaloGeoHelpers/CaloPhiRange.h"
 
class CaloTowerSeg 
{
  public:

  typedef size_t index_t;

  static const index_t outOfRange = static_cast<index_t> (-1);
 

  CaloTowerSeg():
    m_neta(0),m_nphi(0),
    m_etamin(0.),m_etamax(0.),
    m_phimin(0.),m_phimax(0.), 
    m_deta(0),m_dphi(0)
  {} 

  CaloTowerSeg(index_t neta, index_t nphi, double etamin, double etamax,
           double phimin=s_range.phi_min(), 
           double phimax=s_range.phi_max()):
    m_neta(neta),m_nphi(nphi),
    m_etamin(etamin),m_etamax(etamax),
    m_phimin(phimin),m_phimax(phimax) 
  {
    m_deta = (etamax-etamin)/neta;
    m_dphi = (phimax > phimin ? phimax-phimin : s_range.diff (phimax, phimin))/nphi;
  }; 

  ~CaloTowerSeg ()
    { 
    
    };
 
  // Use implicit copy ctor and assignment.
       
 
  index_t neta() const;
  index_t nphi() const;
  double deta() const;
  double dphi() const;
  double etamin() const; 
  double etamax() const; 
  double phimin() const; 
  double phimax() const; 

  bool  inbound(index_t etaInd,index_t phiInd) const; 
  bool  inbound(double etaVal,double phiVal) const; 

  index_t etaphi(index_t etaInd,index_t phiInd) const;  

  double eta(index_t etaInd) const;    
  index_t etaIndex(double etaVal) const;
  index_t etaIndex(index_t comInd) const;

  double phi(index_t phiInd) const;    
  index_t phiIndex(double phiVal) const;
  index_t phiIndex(index_t comInd) const;
 

  class SubSeg
  {
  public:
    typedef CaloTowerSeg::index_t index_t;

    SubSeg (const CaloTowerSeg& parent,
            index_t etamin, index_t etamax,
            index_t phimin, index_t phimax);

    index_t etamin() const;

    index_t etamax() const;

    index_t phimin() const;

    index_t phimax() const;

    size_t neta() const;

    size_t nphi() const;

    size_t size() const;
 
    const CaloTowerSeg& parent() const { return m_parent; }
 

    CaloTowerSeg segmentation() const;
 
 
  private:
    const CaloTowerSeg& m_parent;

    index_t m_etamin;
    index_t m_etamax;
    index_t m_phimin;
    index_t m_phimax;
  };
 

  template <class TOWER_ITERATOR>
  class SubSegIterator
    : public TOWER_ITERATOR
  {
  public:
    static
    SubSegIterator make (TOWER_ITERATOR beg, const SubSeg& subseg);
 

    SubSegIterator (const TOWER_ITERATOR& it,
                    size_t nphi,
                    size_t nphi_skip,
                    size_t phipos);
 

    SubSegIterator& operator++ ();
 

    size_t itower() const;
 
                    
  private:
    size_t m_nphi;
    size_t m_nphi_skip;
    size_t m_phipos;
    size_t m_phipos2;
    size_t m_itower;
  };
 
 

  SubSeg subseg (double eta, double deta, double phi, double dphi) const;
 
 
 private:
  friend class CaloTowerSegCnv_p1;
 
 
  // --------------------------
  // Segmentation parameters 
  // ------------------------

  index_t   m_neta;    
  index_t   m_nphi; 

  double m_etamin; 
  double m_etamax;
  double m_phimin;
  double m_phimax;

  double m_deta;  
  double m_dphi;
 
  // Can get rid of this when we move to the new CaloDetDescr
  // in which all CaloPhiRange methods are static.
  static const CaloPhiRange s_range;
};
 
// ----------------------------------------
// returns parameters
// ----------------------------------------
inline CaloTowerSeg::index_t CaloTowerSeg::neta() const
{
    return m_neta; 
}
 
inline CaloTowerSeg::index_t CaloTowerSeg::nphi() const
{
    return m_nphi; 
}
 
inline double CaloTowerSeg::deta() const
{
  return m_deta;
}
 
inline double CaloTowerSeg::dphi() const
{
  return m_dphi;
}
 
inline double CaloTowerSeg::etamin() const 
{
  return m_etamin;
}
 
inline double CaloTowerSeg::etamax() const 
{
  return m_etamax;
}
 
inline double CaloTowerSeg::phimin() const 
{
  return m_phimin;
}
 
inline double CaloTowerSeg::phimax() const 
{
  return m_phimax;
}
 
inline bool CaloTowerSeg::inbound(index_t etaInd, index_t phiInd) const 
{
  return 
    etaInd >= 1 && etaInd <= m_neta && 
    phiInd >= 1 && phiInd <= m_nphi; 
}
 
inline bool CaloTowerSeg::inbound(double etaVal, double phiVal) const 
{
  if ( ! ( etaVal >= m_etamin && etaVal <= m_etamax ) ) return false;
  if (m_phimax > m_phimin)
    return phiVal >= m_phimin && phiVal <= m_phimax;
  else
    return phiVal <= m_phimax || phiVal >= m_phimin;
}
 
 
// combined index 
inline size_t CaloTowerSeg::etaphi(index_t etaInd,index_t phiInd) const
{
  return this->inbound(etaInd,phiInd) 
    ? (etaInd-1) * m_nphi + (phiInd-1) 
    : outOfRange; 
}
 
// individual indices
inline CaloTowerSeg::index_t CaloTowerSeg::etaIndex(double etaVal) const
{
  return ( etaVal >= m_etamin && etaVal <= m_etamax )
    ? (index_t)floor( ( etaVal - m_etamin ) / m_deta ) + 1
    : outOfRange;
}
inline CaloTowerSeg::index_t CaloTowerSeg::etaIndex(index_t comInd) const
{
  return (index_t)(comInd/m_nphi) + 1;
}
inline CaloTowerSeg::index_t CaloTowerSeg::phiIndex(double phiVal) const
{
  if (m_phimax > m_phimin)
    return ( phiVal >= m_phimin && phiVal <= m_phimax )
      ? (index_t)floor( ( phiVal - m_phimin ) / m_dphi ) + 1
      : outOfRange;
  else
    return ( phiVal >= m_phimin || phiVal <= m_phimax )
      ? (index_t)floor( s_range.diff ( phiVal, m_phimin ) / m_dphi ) + 1
      : outOfRange;
}
inline CaloTowerSeg::index_t CaloTowerSeg::phiIndex(index_t comInd) const
{
  return (index_t)(comInd % m_nphi) + 1;
}
 
// index to real space conversion.
inline double CaloTowerSeg::eta(index_t etaInd) const 
{
 return  m_etamin + (etaInd-0.5) * m_deta ; 
}
 
inline double CaloTowerSeg::phi(index_t phiInd) const 
{
  double ret = m_phimin + (phiInd-0.5) * m_dphi;
  if (m_phimin > m_phimax)
    ret = s_range.fix (ret);
  return ret;
}
 
 
//************************************************************************
 

inline
CaloTowerSeg::SubSeg::index_t
CaloTowerSeg::SubSeg::etamin() const
{
  return m_etamin;
}
 

inline
CaloTowerSeg::SubSeg::index_t
CaloTowerSeg::SubSeg::etamax() const
{
  return m_etamax;
}
 

inline
CaloTowerSeg::SubSeg::index_t
CaloTowerSeg::SubSeg::phimin() const
{
  return m_phimin;
}
 

inline
CaloTowerSeg::SubSeg::index_t
CaloTowerSeg::SubSeg::phimax() const
{
  return m_phimax;
}
 

inline
size_t CaloTowerSeg::SubSeg::neta() const
{
  return m_etamax - m_etamin + 1;
}
 

inline
size_t CaloTowerSeg::SubSeg::size() const
{
  return neta() * nphi();
}
 
 
//************************************************************************
 

template <class TOWER_ITERATOR>
CaloTowerSeg::SubSegIterator<TOWER_ITERATOR>
CaloTowerSeg::SubSegIterator<TOWER_ITERATOR>::make
   (TOWER_ITERATOR beg, const SubSeg& subseg)
{
  const CaloTowerSeg& parent = subseg.parent();
  size_t itower;
  size_t phipos;
 
  if (subseg.phimax() < subseg.phimin()) {
    // phi wraparound case
    itower = parent.etaphi (subseg.etamin(), 1);
    phipos = subseg.nphi() - subseg.phimax();
  }
  else {
    // no phi wrapping
    itower = parent.etaphi (subseg.etamin(), subseg.phimin());
    phipos = 0;
  }
 
  // Should never happen, but check explicitly to prevent a coverity warning.
  if (itower == outOfRange) std::abort();
 
  beg += itower;
  return SubSegIterator (beg,
                         subseg.nphi(),
                         parent.nphi() - subseg.nphi() + 1,
                         phipos);
}
 

template <class TOWER_ITERATOR>
// cppcheck-suppress uninitMemberVar  ; get bogus cppcheck warnings here.
CaloTowerSeg::SubSegIterator<TOWER_ITERATOR>::SubSegIterator
  (const TOWER_ITERATOR& it,
   size_t nphi,
   size_t nphi_skip,
   size_t phipos)
  : TOWER_ITERATOR (it),
    m_nphi (nphi),
    m_nphi_skip (nphi_skip),
    m_phipos (phipos),
    m_phipos2 (0),
    m_itower (0)
{
}
 

template <class TOWER_ITERATOR>
inline
CaloTowerSeg::SubSegIterator<TOWER_ITERATOR>&
CaloTowerSeg::SubSegIterator<TOWER_ITERATOR>::operator++ ()
{
  // Advance phi position.
  ++m_phipos;
  if (m_phipos < m_nphi) {
    // Not to the gap yet; just advance underlying iterator.
    TOWER_ITERATOR::operator++();
  }
  else {
    // At the gap.  Skip ahead by the size of the gap,
    // and reset the phi position.
    m_phipos = 0;
    TOWER_ITERATOR::operator+= (m_nphi_skip);
  }
  
  // Bump the tower index counter when we wrap around in phi.
  if (++m_phipos2 >= m_nphi) {
    m_phipos2 = 0;
    m_itower += m_nphi;
  }
 
  return *this;
}
 

template <class TOWER_ITERATOR>
inline
size_t
CaloTowerSeg::SubSegIterator<TOWER_ITERATOR>::itower() const
{
  return m_itower + m_phipos;
}
                    
 
//************************************************************************
 

#endif