CaloSum.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOEVENT_CALOSUM_H
#define CALOEVENT_CALOSUM_H
 
#include "CaloEvent/CaloBinDescriptor.h"
#include "CaloGeoHelpers/CaloSampling.h"
 
#include <utility>
#include <vector>
#include <map>
 
class CaloCell;
 
class CaloSum
{
 public:
 
  enum CaloRegion 
    {
      Central       = 0x01, 
      EndCap        = 0x02, 
      Forward       = 0x04, 
      Em            = 0x08, 
      Had           = 0x10, 
      UnknownRegion = 0xff  
    };
 
  enum CaloVarType
    {
      E           = 0x01,   
      EDensity    = 0x02,   
      EFraction   = 0x04,   
      Et          = 0x08,   
      EtFraction  = 0x10,   
      UnknownType = 0xff    
    };
 
  typedef std::pair<CaloRegion,CaloSampling::CaloSample>            key_t;
 
  typedef std::vector<double>                                      data_t;
  typedef data_t::iterator                                    data_iter_t;
  typedef data_t::const_iterator                        data_const_iter_t;
 
  typedef std::vector<data_t>                                       bin_t;
  typedef bin_t::iterator                                      bin_iter_t;
  typedef bin_t::const_iterator                          bin_const_iter_t;
 
  typedef std::map<key_t,bin_t>                                   store_t;
  typedef store_t::iterator                                  store_iter_t;
  typedef store_t::const_iterator                      store_const_iter_t;
 
  typedef std::pair<double,double>                                range_t;
  typedef std::vector<range_t>                               range_cont_t;
  typedef std::map<CaloRegion,range_cont_t>                   range_map_t;
 
  //
  // Embedded Iterator //
    //
    //  class CaloSumIterator
    //    {
    //    public:
    //      CaloSumIterator(store_t& theStore) 
    //  : m_store(&theStore)
    //  , m_actual(theStore.begin())
    //  { };
    //
    //      ~CaloSumIterator() { };
    //
      // positioning iterator
    //      CaloSumIterator begin() { m_actual = m_store->begin(); return *this; }
    //      CaloSumIterator end()   { m_actual = m_store->end();   return *this; }
    //      CaloSumIterator next()  { m_actual++; return *this; }
    //      CaloSumIterator prev()  { m_actual--; return *this; }
    //
      // bi-directional iterator advancement
    //      CaloSumIterator operator++()    { return this->next(); }
    //      CaloSumIterator operator++(int) { return this->next(); }
    //      CaloSumIterator operator--()    { return this->prev(); }
    //      CaloSumIterator operator--(int) { return this->prev(); }
    //      
      // comparators
    //      bool operator==(const CaloSumIterator& anOtherIter) const
    //  { return m_actual == anOtherIter.m_actual; }
    //      bool operator==(CaloSumIterator& anOtherIter)
    //  { return m_actual == anOtherIter.m_actual; }
    //      bool operator!=(const CaloSumIterator& anOtherIter ) const
    //  { return m_actual != anOtherIter.m_actual; }
    //      bool operator!=(CaloSumIterator& anOtherIter )
    //  { return m_actual != anOtherIter.m_actual; }
    //
      // data access
    //      store_const_iter_t& operator*()  const { return m_actual; }
    //      store_const_iter_t& operator->() const { return m_actual; } 
    //
    //    private:
    //      
    //      const store_t*     m_store;
    //      store_const_iter_t m_actual;
    //    };
 
    //  typedef CaloSumIterator   const_iterator;
  typedef store_const_iter_t        const_iterator;
 
  CaloSum();
 
  CaloSum(CaloVarType                      varType,
      const CaloBinDescriptor<double>& theBins,
      size_t                           numberOfSums = 1);
//  /*! \brief Useful constructor
//   *
//   * \overload
//   *
//   * Constructor allows to give a list of regions.
//   */
  //  CaloSum(CaloVarType                      varType,
  //      const CaloBinDescriptor<double>& theBins,
  //      const std::vector<CaloRegion>&   theRegions,
  //      size_t                           numberOfSums = 1 );
  virtual ~CaloSum();
 
  // Configuration //
 
  virtual bool setRegion(const CaloSum::CaloRegion& theRegion,
             double etaLow, double etaHigh);
  virtual bool setRegion(const CaloSum::CaloRegion& theRegion,
             const std::vector<double>& etaLow,
             const std::vector<double>& etaHigh);
 
  virtual CaloRegion getRegion(double theEta) const;
 
  virtual bool       getRange(const CaloRegion&    theRegion,
                  std::vector<double>& lowEtas,
                  std::vector<double>& highEtas) const;
  virtual CaloVarType getVarType() const;
  virtual size_t getNumberOfBins() const;
  virtual size_t getNumberOfSums() const;
  virtual bool getVariableRange(double& lowLimit,double& highLimit) const;
  virtual bool getBinEdges(size_t theIndex,
               double& lowEdge, double& highEdge) const;
  virtual bool getBinCenter(size_t theIndex, double& binCenter) const;
  virtual const CaloBinDescriptor<double>& getBinDescriptor() const;
  
 
  // Data Accumulation //
 
  virtual bool add(const CaloCell* theCell,
           double theBinnedVariable,
           const std::vector<double>& theSummedVariables);
  virtual bool add(const CaloCell* theCell,
           double theBinnedVariable,
           double theSummedVariable);
  virtual bool add(const CaloSampling::CaloSample& theSampling,
           double theEta,
           double theBinnedVariable,
           const std::vector<double>& theSummedVariables);
  virtual bool add (const CaloSampling::CaloSample& theSampling,
            double theEta,
            double theBinnedVariable,
            double theSummedVariable);
  // Data Access //
 
  const_iterator begin() const;
  const_iterator end()   const;
  static CaloRegion   getRegion(const_iterator& theIterator)   ;
  static CaloSampling::CaloSample getSampling(const_iterator& theIterator) ;
 
  bool getSums(const_iterator& theIterator,
           size_t theBinIndex,
           std::vector<double>& theSums) const;
  bool getSums(const_iterator& theIterator,
           double theBinnedVariable,
           std::vector<double>& theSums) const;
  bool getSums(const CaloSum::CaloRegion&      theRegion,
           const CaloSampling::CaloSample& theSampling,
           size_t                          theIndex,
           std::vector<double>&            theSums) const;
  bool getSums(const CaloSum::CaloRegion&      theRegion,
           const CaloSampling::CaloSample& theSampling,
           double                          theBinnedVariable,
           std::vector<double>&            theSums) const;
  //  bool getSums(const CaloSampling::CaloSample& theSampling,
  //           double                          theEta,
  //           size_t                          theIndex
  //           std::vector<double>&            theSums) const;
  //  bool getSums(const CaloSampling::CaloSample& theSampling,
  //           double                          theEta,
  //           double                          theBinnedVariable,
  //           std::vector<double>&            theSums) const;
 
  virtual bool contains(const CaloSum::CaloRegion&      theRegion) const;
  virtual bool contains(const CaloSampling::CaloSample& theSampling) const;
  virtual bool contains(const CaloSum::CaloRegion&      theRegion,
            const CaloSampling::CaloSample& theSampling) const;
 
 protected:
 
  static key_t getKey(const CaloRegion&               theRegion,
           const CaloSampling::CaloSample& theSample) ;
  key_t getKey(double theEta, 
           const CaloSampling::CaloSample& theSample) const;
 
  bool  setUp(); 
 
 private:
 
  bool                      m_defaultRanges;
 
  size_t                    m_numberOfSums;
 
  CaloVarType               m_varType;
 
  CaloBinDescriptor<double> m_binDescriptor;
 
  range_map_t               m_regionRanges;
 
  store_t                   m_sumStore;
};
 
#endif