TimeDistribution.h

Go to the documentation of this file.

#ifndef _utl_TimeDistribution_h_
#define _utl_TimeDistribution_h_

#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>
#include <utl/IteratorRange.h>

#include <boost/tuple/tuple_io.hpp>
#include <boost/iterator/transform_iterator.hpp>

#include <map>
#include <cmath>
#include <iostream>


namespace utl {

  class TimeDistributionAlgorithm;


  template<typename T>
  class TimeDistribution {

  private:
    typedef std::map<int, T> InternalMap;
    typedef typename InternalMap::value_type InternalMapValue;
    typedef typename InternalMap::iterator InternalIterator;
    typedef typename InternalMap::const_iterator InternalConstIterator;

  public:
    typedef T ValueType;
    typedef boost::tuple<const int, const T> Tuple;

    struct InternalMapFunctor {
      Tuple operator()(const InternalMapValue& pair) const
      { return Tuple(pair.first, pair.second); }
    };

    typedef boost::transform_iterator<InternalMapFunctor,
                                      InternalConstIterator,
                                      Tuple> SparseIterator;

    TimeDistribution(const double slotSize) : fSlotSize(slotSize) { }

    void Clear() { decltype(fData)().swap(fData); }

    int
    Purge()
    {
      int n = 0;
      for (InternalIterator it = fData.begin(); it != fData.end(); ) {
        if (it->second == T()) {
          it = fData.erase(it);
          ++n;
        } else
          ++it;
      }
      return n;
    }

    void
    AddTime(const int slot, const T weight = T(1))
    {
      if (!weight)
        return;
      const std::pair<InternalIterator, bool> ins = fData.insert(InternalMapValue(slot, weight));
      if (!ins.second) {
        const InternalIterator& it = ins.first;
        const T w = (it->second += weight);
        if (!w)
          fData.erase(it);
      }
    }


    void AddTime(const double time, const T weight = T(1))
    { AddTime(int(std::floor(time/fSlotSize)), weight); }

    void
    SetTime(const int slot, const T weight = T(1))
    {
      if (weight)
        fData[slot] = weight;
      else {
        const InternalIterator it = fData.find(slot);
        if (it != fData.end())
          fData.erase(it);
      }
    }

    void SetTime(const double time, const T weight = T(1))
    { SetTime(int(std::floor(time/fSlotSize)), weight); }


    T& operator[](const int index) { return fData[index]; }


    const T&
    operator[](const int index)
      const
    {
      static const T zero = T(0);
      const InternalConstIterator it = fData.find(index);
      return it == fData.end() ? zero : it->second;
    }


    T& operator[](const double time)
    { return operator[](int(std::floor(time/fSlotSize))); }

    const T& operator[](const double time) const
    { return operator[](int(std::floor(time/fSlotSize))); }

    T
    At(const int index)
      const
    {
      const InternalConstIterator it = fData.find(index);
      return it == fData.end() ? 0 : it->second;
    }

    T At(const double time) const
    { return At(int(std::floor(time/fSlotSize))); }

    TimeDistribution<T>
    operator+(const TimeDistribution<T>& td)
      const
    {
      if (GetBinning() == td.GetBinning()) {
        TimeDistribution<T> val(*this);
        for (const auto& kv : td.fData)
          if (kv.second)
            val[kv.first] += kv.second;
        return val;
      }
      const std::string msg = "Cannot add two TimeDistributions with unequal binning.";
      ERROR(msg);
      throw AugerException(msg); // not sure what kind of exception to throw here.
    }

    TimeDistribution<T>&
    operator+=(const TimeDistribution<T>& td)
    {
      if (GetBinning() == td.GetBinning()) {
        for (const auto& kv : td.fData)
          if (kv.second)
            (*this)[kv.first] += kv.second;
        return *this;
      }
      const std::string msg = "Cannot add two TimeDistributions with unequal binning.";
      ERROR(msg);
      throw AugerException(msg); // not sure what kind of exception to throw here.
    }

    bool operator==(const TimeDistribution& td) const
    { return fSlotSize == td.fSlotSize && fData == td.fData; }

    bool operator!=(const TimeDistribution& td) const
    { return !operator==(td); }

    double GetBinning() const { return fSlotSize; }

    int GetStart() const { return fData.empty() ? 0 : fData.begin()->first; }

    int GetStop() const { return fData.empty() ? -1 : fData.rbegin()->first; }

    int GetNumSlots() const
    { return fData.empty() ? 0 : fData.rbegin()->first - fData.begin()->first + 1; }

    SparseIterator SparseBegin() const { return SparseIterator(fData.begin()); }

    SparseIterator SparseEnd() const { return SparseIterator(fData.end()); }

    OFFLINE_MAKE_CONST_ITERATOR_RANGE(SparseIterator, Sparse)

  private:
    InternalMap fData;
    double fSlotSize = 0;

    friend class TimeDistributionAlgorithm;

  };


  typedef TimeDistribution<double> TimeDistributionD;
  typedef TimeDistribution<int> TimeDistributionI;


  template<typename T>
  void Print(std::ostream& os, const TimeDistribution<T>& td);

}


#endif