Calorimeter/CaloEvent/CaloEvent/CaloTowerContainer.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOEVENT_CALOTOWERCONTAINER_H
#define CALOEVENT_CALOTOWERCONTAINER_H
/********************************************************************
 
NAME:     CaloTowerContainer.h
PACKAGE:  offline/Calorimeter/CaloRec
 
AUTHORS:  H. Ma, S. Rajagopalan
CREATED:  Oct, 2000
          Originally it is LArTowerContainer in LArClusterRec 
          Moved to CaloRec package on Feb 5, 2001
 
PURPOSE:  container class for CaloTower objects.
          Baseclass: ObjectVector<CaloTower>. 
          The tower objects are stored as CaloTower in DataVector
      In addition to providing  iterators over all towers, 
      the towers (and their et and energy) can be accessed with 
          index (ieta,iphi), or in real (eta,phi) space. 
 
          There are two ways of using this container.  In standard usage,
          the towers are in a strict rectangular grid as defined
          by the CaloTowerSeg object passed to the constructor.
          In this case, the container itself creates all the contained
          towers.  Clients should not attempt to modify the container
          itself.  
 
          For efficiency, all the contained towers are either stored
          in a single vector or in a DataPool (depending on whether
          or not CALOTOWERCONTAINER_USES_DATAPOOL is defined).
          In the former case, the DataVector elements are then
          set to point into that vector.
 
          The other usage is simply as a list of towers (this is provided
          for the use of trigger software).  In this case, the default
          constructor must be used, and the ownership mode should
          be set to VIEW_ELEMENTS.  The only operations that modify
          the container that are supported are insert(), push_back(),
          and clear().
 
 
UPDATE:   MAY-11-01
      add CLID
 
********************************************************************/
 
// If CALOTOWERCONTAINER_USES_DATAPOOL is set, then CaloTowers
//  will be allocated from a DataPool.
// Otherwise, they will be allocated in an internal vector.
//
// This needs to be disabled for Hive
 
#define CALOTOWERCONTAINER_USES_DATAPOOL
 
// INCLUDE HEADER FILES:
#include "AthContainers/DataVector.h"
#include "AthenaKernel/CLASS_DEF.h"
 
#include "CaloIdentifier/CaloCell_ID.h"
 
#include "CaloEvent/CaloTower.h"
#include "CaloEvent/CaloTowerSeg.h"
#include "NavFourMom/INavigable4MomentumCollection.h"
#include "CaloEvent/CaloTowerDataVector.h"
 
#include "boost/iterator/iterator_adaptor.hpp"
#include <utility>
#include <vector>
 
 
class CaloTowerContainer : public DataVector<CaloTower> 
{
public:
  typedef DataVector<CaloTower> Base;

  typedef size_t index_t;

  // Constructors/Destructor //
 
  CaloTowerContainer();   
  CaloTowerContainer(const CaloTowerSeg& tseg, bool noTowers = false); 

  CaloTowerContainer (const CaloTowerContainer& other);

  CaloTowerContainer& operator= (const CaloTowerContainer& other);

  void swap (CaloTowerContainer& other);
 
  virtual ~CaloTowerContainer();
 

  // Initialization //

  void init();
 

  // Tower Information //

  void setCalo(const CaloCell_ID::SUBCALO& nCalo);
  size_t getCalos(std::vector<CaloCell_ID::SUBCALO>& theCalos) const;
  size_t getNumberOfCalos() const;

  double etamin() const;
  double phimin() const;
  double deta()   const;
  double dphi()   const;
  size_t neta()  const;
  size_t nphi()  const;

  const CaloTowerSeg& towerseg() const; 

  // Kinematics //
  
  double et(double theEta, double thePhi) const;
  double et(index_t etaIndex, index_t phiIndex) const;
  double et(int etaIndex, int phiIndex)             const 
    { return et((index_t)etaIndex,(index_t)phiIndex); }  // temp fix!

  double e(double theEta, double thePhi)            const
    { return this->energy(theEta,thePhi); }

  double e(index_t etaIndex, index_t phiIndex)      const
    { return this->energy(etaIndex,phiIndex); }

  double e(int etaIndex, int phiIndex)              const
    { return this->energy(etaIndex,phiIndex); }

  double energy(double theEta, double thePhi)       const;
  double energy(index_t etaIndex, index_t phiIndex) const;
  double energy(int etaIndex, int phiIndex)         const
    { return energy((index_t)etaIndex,(index_t)phiIndex); }

  // Container Management //

  index_t getTowerIndex(const CaloTower* aTower)            const;
  index_t getTowerIndex(index_t etaIndex, index_t phiIndex) const;
  index_t getTowerIndex(double theEta, double thePhi)       const;
  index_t getTowerEtaIndex(const CaloTower* aTower)         const;
  index_t getTowerEtaIndex(double theEta)                   const;
  index_t getTowerEtaIndex(index_t towerIndex)              const;
  index_t getTowerPhiIndex(const CaloTower* aTower)         const;
  index_t getTowerPhiIndex(double thePhi)                   const;
  index_t getTowerPhiIndex(index_t towerIndex)              const;

  bool   getTowerIndices(const CaloTower* aTower, 
             index_t& indexEta,
             index_t& indexPhi)           const;
  bool   getTowerIndices(double theEta, double thePhi,
             index_t& indexEta,
             index_t& indexPhi)           const;

  CaloTower*       getTower(index_t eta, index_t phi);
  const CaloTower* getTower(index_t eta, index_t phi) const;  
  CaloTower*       getTower(int eta, int phi)
    { return this->getTower(index_t(eta), index_t(phi)); }

  const CaloTower* getTower(int eta, int phi) const
    { return this->getTower(index_t(eta), index_t(phi)); }

  CaloTower*       getTower(double eta, double phi);
  const CaloTower* getTower(double eta, double phi)   const;

  CaloTower*       getTower( index_t theIndex )
    { 
      return theIndex < this->size() 
    ? (this->operator[])(theIndex) 
    : (CaloTower*)0; 
    }

  const CaloTower* getTower( index_t theIndex ) const
    { 
      return theIndex < this->size()  
    ? (this->operator[])(theIndex) 
    : (const CaloTower*)0; 
    }
 
  index_t flagOutOfRange()             const;
  bool   isOutOfRange(index_t anIndex) const;
 
 
public:
  //***********************************************************************
  // We don't want to allow clients to change pointers in the container.
  // So change DataVector operations that return lvalues to return
  // instead rvalues.
 
  using Base::operator[];
  CaloTower* operator[] (size_type n);
 
  using Base::at;
  CaloTower* at (size_type n);
 
  using Base::front;
  CaloTower* front ();
 
  using Base::back;
  CaloTower* back ();
 

  class iterator
    : public boost::iterator_adaptor<iterator,
                                     Base::iterator, 
                                     Base::value_type,
                                     Base::iterator::iterator_category,
                                     // Reference
                                     Base::value_type>
  {
  private:
    // Shorthand for the base class type.
    typedef boost::iterator_adaptor<iterator,
                                    Base::iterator,
                                    Base::value_type,
                                    Base::iterator::iterator_category,
                                    Base::value_type>
    iterator_adaptor_;
    
  public:
    iterator() {}
    iterator (Base::iterator it)  : iterator_adaptor_ (it) {}
 
    operator const_iterator() const
    { return const_iterator (this->base()); }
  };
 
 
  typedef std::reverse_iterator<iterator> reverse_iterator;
 
 
  using Base::begin;
  using Base::end;
  iterator begin();
  iterator end();
 
  using Base::rbegin;
  using Base::rend;
  reverse_iterator rbegin();
  reverse_iterator rend();
 
 
  //***********************************************************************
  // We'll be disallowing most operations that modify the container.
  // However, these operations are needed by trigger code.
  // They are only allowed when the segmentation is null and
  // the ownership policy is set to @c VIEW_ELEMENTS.
 
  void insert(iterator position, iterator first, iterator last);
  void clear(SG::OwnershipPolicy p);
  void push_back(value_type pElem);
 
 
private:
  friend class CaloTowerContainerCnv_p1;
 

  CaloTowerSeg   m_towerSeg;

  std::vector<unsigned int> m_caloRegions;
 
#ifndef CALOTOWERCONTAINER_USES_DATAPOOL
  std::vector<CaloTower> m_towers;
 
  void setTowers();
#endif

  static const index_t m_outOfRange = static_cast<index_t>(-1);
 
 
private:
  // Hide methods from DataVector that modify the container.
  template <class InputIterator>
  void assign(InputIterator first, InputIterator last);
  iterator insert(iterator position, value_type pElem);
  template <class InputIterator>
  void insert(iterator position, InputIterator first, InputIterator last);
  iterator erase(iterator position);
  iterator erase(iterator first, iterator last);
  void sort();
  template <class COMPARE>
  void sort(COMPARE comp);
  void swapElement(size_type index, value_type newElem, reference oldElem);
  void resize(size_type sz);
  void reserve (size_type n);
  void pop_back();
  void clear();
};
 
CLASS_DEF(CaloTowerContainer, 2804, 1)
SG_BASE(CaloTowerContainer, DataVector<CaloTower> );

// Inline Functions //
 
// included calorimeter
inline size_t CaloTowerContainer::getNumberOfCalos() const
{
  return m_caloRegions.size();
}
 
// tower binning
inline double CaloTowerContainer::etamin() const
{
  return m_towerSeg.etamin();
}
inline double CaloTowerContainer::deta() const
{
  return m_towerSeg.deta();
}
inline size_t CaloTowerContainer::neta() const
{
  return m_towerSeg.neta();
}
inline double CaloTowerContainer::phimin() const
{
  return m_towerSeg.phimin();
}
 
inline double CaloTowerContainer::dphi() const
{
  return m_towerSeg.dphi();
}
inline size_t CaloTowerContainer::nphi() const
{
  return m_towerSeg.nphi();
}
inline const CaloTowerSeg& CaloTowerContainer::towerseg() const
{
  return m_towerSeg;
}
 
// tower indices
inline CaloTowerContainer::index_t 
CaloTowerContainer::getTowerIndex(const CaloTower* aTower) const
{
  return aTower != 0
    ? this->getTowerIndex(aTower->eta(),aTower->phi())
    : m_outOfRange;
}
inline CaloTowerContainer::index_t 
CaloTowerContainer::getTowerIndex(index_t etaIndex,index_t phiIndex) const
{
  return m_towerSeg.etaphi(etaIndex,phiIndex);
}
inline CaloTowerContainer::index_t 
CaloTowerContainer::getTowerIndex(double theEta, double thePhi) const
{
  return this->getTowerIndex(this->getTowerEtaIndex(theEta),
                 this->getTowerPhiIndex(thePhi));
}
inline CaloTowerContainer::index_t 
CaloTowerContainer::getTowerEtaIndex(const CaloTower* aTower) const
{
  return aTower != 0 
    ? this->getTowerEtaIndex(aTower->eta())
    : m_outOfRange;
}
inline CaloTowerContainer::index_t 
CaloTowerContainer::getTowerEtaIndex(double theEta) const
{
  return m_towerSeg.etaIndex(theEta);
}
inline CaloTowerContainer::index_t
CaloTowerContainer::getTowerEtaIndex(index_t combinedIndex) const
{
  return m_towerSeg.etaIndex(combinedIndex);
}
inline CaloTowerContainer::index_t 
CaloTowerContainer::getTowerPhiIndex(const CaloTower* aTower) const
{
  return aTower != 0 
    ? this->getTowerPhiIndex(aTower->phi())
    : m_outOfRange;
}
inline CaloTowerContainer::index_t 
CaloTowerContainer::getTowerPhiIndex(double thePhi) const
{
  return m_towerSeg.phiIndex(thePhi);
}
inline CaloTowerContainer::index_t
CaloTowerContainer::getTowerPhiIndex(index_t combinedIndex) const
{
  return m_towerSeg.phiIndex(combinedIndex);
} 
 
// useful help
inline CaloTowerContainer::index_t CaloTowerContainer::flagOutOfRange() const 
{
  return m_outOfRange;
}
inline bool CaloTowerContainer::isOutOfRange(index_t anIndex) const
{
  return anIndex >= this->size() || anIndex == m_outOfRange;
}
 
inline CaloTower* CaloTowerContainer::operator[] (size_type n)
{
  return Base::operator[](n);
}
 
inline CaloTower* CaloTowerContainer::at (size_type n)
{
  return Base::at(n);
}
 
inline CaloTower* CaloTowerContainer::front ()
{
  return Base::front();
}
 
inline CaloTower* CaloTowerContainer::back ()
{
  return Base::back();
}
 
inline CaloTowerContainer::iterator CaloTowerContainer::begin()
{
  return iterator (Base::begin());
}
 
inline CaloTowerContainer::iterator CaloTowerContainer::end()
{
  return iterator (Base::end());
}
 
inline CaloTowerContainer::reverse_iterator CaloTowerContainer::rbegin()
{
  return reverse_iterator (end());
}
 
inline CaloTowerContainer::reverse_iterator CaloTowerContainer::rend()
{
  return reverse_iterator (begin());
}
 

#endif