RunRange.h

#pragma once
 
#include <string>
#include <vector>
#include <set>
#include <TNamed.h>
#include <TCollection.h>
#include <framework/database/IntervalOfValidity.h>
#include <framework/logging/Logger.h>
#include <calibration/Utilities.h>
 
namespace Belle2 {
  class RunRange : public TNamed {
 
  public:
    RunRange() : TNamed() {};
 
    explicit RunRange(std::vector<Calibration::ExpRun> expRuns) : TNamed()
    {
      for (auto expRun : expRuns) {
        this->add(expRun.first, expRun.second);
      }
    };
 
    virtual ~RunRange()
    {
      m_expRunSet.clear();
    }
 
    virtual void clear()
    {
      m_expRunSet.clear();
    }
 
    virtual void merge(const RunRange* other)
    {
      m_expRunSet.insert(other->m_expRunSet.begin(), other->m_expRunSet.end());
    }
 
    void add(int exp, int run)
    {
      m_expRunSet.insert(std::make_pair(exp, run));
    }
 
    const std::set<Calibration::ExpRun>& getExpRunSet()
    {
      return m_expRunSet;
    }
 
    IntervalOfValidity getIntervalOfValidity()
    {
      if (m_expRunSet.empty())
        return IntervalOfValidity();
 
      auto low = m_expRunSet.begin();
      auto high = m_expRunSet.rbegin();
 
      return IntervalOfValidity(low->first, low->second, high->first, high->second);
    }
 
    Long64_t Merge(TCollection* hlist)
    {
      B2DEBUG(100, "Running Merge() on " << this->GetName());
      Long64_t nMerged = 0;
      if (hlist) {
        const RunRange* xh = 0;
        TIter nxh(hlist);
        while ((xh = dynamic_cast<RunRange*>(nxh()))) {
          // Add xh to me
          merge(xh);
          ++nMerged;
        }
      }
      B2DEBUG(100, "Merged " << nMerged << " objects");
      return nMerged;
    }
 
    void setGranularity(std::string& granularity)
    {
      if (granularity == "all" || granularity == "run") {
        m_granularity = granularity;
      } else {
        B2WARNING("Tried to set RunRange granularity to something other than 'run' or 'all' -> " << granularity);
      }
    }
 
    std::string getGranularity() const {return m_granularity;}
    void Reset() {clear();}
    void SetDirectory(TDirectory*) {}
 
    bool operator<(const RunRange& other) const
    {
      if (m_granularity == other.m_granularity) {
        return m_expRunSet < other.m_expRunSet;
      }
      return m_granularity < other.m_granularity;
    }
 
  private:
    std::set<Calibration::ExpRun> m_expRunSet = {};
 
    std::string m_granularity = "run";
 
    ClassDef(RunRange, 2) 
  };
}