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 = 0)
            : a_(binEdges, label), u_(1U, 0.0, 1.0), uniform_(false) {}

        inline DualHistoAxis(unsigned nBins, double min, double max,
                             const char* label = 0)
            : 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*>(0) : &a_;}

        inline const HistoAxis* getHistoAxis() const
            {return uniform_ ? &u_ : static_cast<const HistoAxis*>(0);}

        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) {}
    };
}

#endif // NPSTAT_DUALHISTOAXIS_HH_