DualHistoAxis.h

Go to the documentation of this file.

#ifndef NPSTAT_DUALHISTOAXIS_HH_
#define NPSTAT_DUALHISTOAXIS_HH_
 
#include "JetMETCorrections/InterpolationTables/interface/HistoAxis.h"
#include "JetMETCorrections/InterpolationTables/interface/NUHistoAxis.h"
 
namespace npstat {
  class DualHistoAxis {
  public:
    // Constructors
    inline DualHistoAxis(const NUHistoAxis& a) : a_(a), u_(1U, 0.0, 1.0), uniform_(false) {}
 
    inline DualHistoAxis(const HistoAxis& u) : a_(dummy_vec()), u_(u), uniform_(true) {}
 
    inline DualHistoAxis(const std::vector<double>& binEdges, const char* label = nullptr)
        : a_(binEdges, label), u_(1U, 0.0, 1.0), uniform_(false) {}
 
    inline DualHistoAxis(unsigned nBins, double min, double max, const char* label = nullptr)
        : a_(dummy_vec()), u_(nBins, min, max, label), uniform_(true) {}
 
    // Inspectors
    inline bool isUniform() const { return uniform_; }
 
    inline double min() const { return uniform_ ? u_.min() : a_.min(); }
 
    inline double max() const { return uniform_ ? u_.max() : a_.max(); }
 
    inline Interval<double> interval() const { return uniform_ ? u_.interval() : a_.interval(); }
 
    inline double length() const { return uniform_ ? u_.length() : a_.length(); }
 
    inline unsigned nBins() const { return uniform_ ? u_.nBins() : a_.nBins(); }
 
    inline double binWidth(const int binNum) const { return uniform_ ? u_.binWidth(binNum) : a_.binWidth(binNum); }
 
    inline const std::string& label() const { return uniform_ ? u_.label() : a_.label(); }
 
    inline double binCenter(const int binNum) const { return uniform_ ? u_.binCenter(binNum) : a_.binCenter(binNum); }
 
    inline double leftBinEdge(const int binNum) const {
      return uniform_ ? u_.leftBinEdge(binNum) : a_.leftBinEdge(binNum);
    }
 
    inline double rightBinEdge(const int binNum) const {
      return uniform_ ? u_.rightBinEdge(binNum) : a_.rightBinEdge(binNum);
    }
 
    inline Interval<double> binInterval(const int binNum) const {
      return uniform_ ? u_.binInterval(binNum) : a_.binInterval(binNum);
    }
 
 
    inline const NUHistoAxis* getNUHistoAxis() const {
      return uniform_ ? static_cast<const NUHistoAxis*>(nullptr) : &a_;
    }
 
    inline const HistoAxis* getHistoAxis() const { return uniform_ ? &u_ : static_cast<const HistoAxis*>(nullptr); }
 
    inline void setLabel(const char* newlabel) { uniform_ ? u_.setLabel(newlabel) : a_.setLabel(newlabel); }
 
    inline int binNumber(const double x) const { return uniform_ ? u_.binNumber(x) : a_.binNumber(x); }
 
    inline double fltBinNumber(const double x, const bool mapLeftEdgeTo0 = true) const {
      return uniform_ ? u_.fltBinNumber(x, mapLeftEdgeTo0) : a_.fltBinNumber(x, mapLeftEdgeTo0);
    }
 
    inline unsigned closestValidBin(const double x) const {
      return uniform_ ? u_.closestValidBin(x) : a_.closestValidBin(x);
    }
 
    inline bool operator==(const DualHistoAxis& r) const { return uniform_ == r.uniform_ && a_ == r.a_ && u_ == r.u_; }
 
    inline bool operator!=(const DualHistoAxis& r) const { return !(*this == r); }
 
    inline bool isClose(const DualHistoAxis& r, const double tol) const {
      return uniform_ == r.uniform_ && a_.isClose(r.a_, tol) && u_.isClose(r.u_, tol);
    }
 
    inline DualHistoAxis rebin(const unsigned newBins) const {
      return DualHistoAxis(newBins, min(), max(), label().c_str());
    }
 
    // Method related to "geners" I/O
    inline gs::ClassId classId() const { return gs::ClassId(*this); }
    bool write(std::ostream& of) const;
 
    static inline const char* classname() { return "npstat::DualHistoAxis"; }
    static inline unsigned version() { return 1; }
    static DualHistoAxis* read(const gs::ClassId& id, std::istream& in);
 
  private:
    NUHistoAxis a_;
    HistoAxis u_;
    bool uniform_;
 
    template <typename Numeric, class Axis>
    friend class HistoND;
 
    inline unsigned overflowIndex(const double x, unsigned* binNumber) const {
      return uniform_ ? u_.overflowIndex(x, binNumber) : a_.overflowIndex(x, binNumber);
    }
 
    inline static std::vector<double> dummy_vec() {
      std::vector<double> vec(2, 0.0);
      vec[1] = 1.0;
      return vec;
    }
 
    inline DualHistoAxis() : a_(dummy_vec()), u_(1U, 0.0, 1.0), uniform_(true) {}
  };
}  // namespace npstat
 
#endif  // NPSTAT_DUALHISTOAXIS_HH_