DualAxis.h

Go to the documentation of this file.

#ifndef NPSTAT_DUALAXIS_HH_
#define NPSTAT_DUALAXIS_HH_

#include "JetMETCorrections/InterpolationTables/interface/GridAxis.h"
#include "JetMETCorrections/InterpolationTables/interface/UniformAxis.h"

namespace npstat {
  class DualAxis {
  public:
    // Constructors
    inline DualAxis(const GridAxis& g) : a_(g), u_(2, 0.0, 1.0), uniform_(false) {}

    inline DualAxis(const UniformAxis& u) : a_(dummy_vec()), u_(u), uniform_(true) {}

    inline DualAxis(unsigned nCoords, double min, double max, const char* label = nullptr)
        : a_(dummy_vec()), u_(nCoords, min, max, label), uniform_(true) {}

    inline explicit DualAxis(const std::vector<double>& coords, const bool useLogSpace = false)
        : a_(coords, useLogSpace), u_(2, 0.0, 1.0), uniform_(false) {}

    inline DualAxis(const std::vector<double>& coords, const char* label, const bool useLogSpace = false)
        : a_(coords, label, useLogSpace), u_(2, 0.0, 1.0), uniform_(false) {}

    // Inspectors
    inline bool isUniform() const { return uniform_; }

    inline unsigned nCoords() const { return uniform_ ? u_.nCoords() : a_.nCoords(); }

    inline double min() const { return uniform_ ? u_.min() : a_.min(); }

    inline double max() const { return uniform_ ? u_.max() : a_.max(); }

    inline const std::string& label() const { return uniform_ ? u_.label() : a_.label(); }

    inline bool usesLogSpace() const { return uniform_ ? u_.usesLogSpace() : a_.usesLogSpace(); }

    inline std::pair<unsigned, double> getInterval(const double x) const {
      return uniform_ ? u_.getInterval(x) : a_.getInterval(x);
    }

    inline std::pair<unsigned, double> linearInterval(const double x) const {
      return uniform_ ? u_.linearInterval(x) : a_.linearInterval(x);
    }

    inline double coordinate(const unsigned i) const { return uniform_ ? u_.coordinate(i) : a_.coordinate(i); }

    inline double length() const { return uniform_ ? u_.length() : a_.length(); }

    inline unsigned nIntervals() const { return uniform_ ? u_.nIntervals() : a_.nIntervals(); }

    inline double intervalWidth(const unsigned i = 0) const {
      return uniform_ ? u_.intervalWidth(i) : a_.intervalWidth(i);
    }

    inline std::vector<double> coords() const { return uniform_ ? u_.coords() : a_.coords(); }

    inline bool operator==(const DualAxis& r) const { return uniform_ == r.uniform_ && a_ == r.a_ && u_ == r.u_; }

    inline bool operator!=(const DualAxis& r) const { return !(*this == r); }


    inline const GridAxis* getGridAxis() const { return uniform_ ? static_cast<const GridAxis*>(nullptr) : &a_; }

    inline const UniformAxis* getUniformAxis() const {
      return uniform_ ? &u_ : static_cast<const UniformAxis*>(nullptr);
    }

    inline void setLabel(const char* newlabel) { uniform_ ? u_.setLabel(newlabel) : a_.setLabel(newlabel); }


    inline gs::ClassId classId() const { return gs::ClassId(*this); }
    bool write(std::ostream& of) const;

    static inline const char* classname() { return "npstat::DualAxis"; }
    static inline unsigned version() { return 1; }
    static DualAxis* read(const gs::ClassId& id, std::istream& in);

  private:
    GridAxis a_;
    UniformAxis u_;
    bool uniform_;

    inline static std::vector<double> dummy_vec() {
      std::vector<double> vec(2, 0.0);
      vec[1] = 1.0;
      return vec;
    }

    inline DualAxis() : a_(dummy_vec()), u_(2, 0.0, 1.0), uniform_(true) {}
  };
}  // namespace npstat

#endif  // NPSTAT_DUALAXIS_HH_