Histogram3D.h

Go to the documentation of this file.

#ifndef CondFormats_PhysicsToolsObjects_Histogram3D_h
#define CondFormats_PhysicsToolsObjects_Histogram3D_h

#include "CondFormats/Serialization/interface/Serializable.h"

#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
#include <atomic>
#endif

#include <utility>
#include <vector>
#include <cmath>

#include "CondFormats/PhysicsToolsObjects/interface/Histogram2D.h"

namespace PhysicsTools {
namespace Calibration {

//template<typename Value_t, typename AxisX_t = Value_t,
//         typename AxisY_t = AxisX_t>

template<typename Value_t, typename AxisX_t = Value_t,
         typename AxisY_t = AxisX_t, typename AxisZ_t = AxisX_t>


class Histogram3D {
    public:
    typedef Range<AxisX_t> RangeX;
    typedef Range<AxisY_t> RangeY;
        typedef Range<AxisZ_t> RangeZ;

    Histogram3D();

    Histogram3D(const Histogram3D &orig);

    template<typename OValue_t, typename OAxisX_t, typename OAxisY_t, typename OAxisZ_t>
    Histogram3D(const Histogram3D<OValue_t, OAxisX_t, OAxisY_t,  OAxisZ_t> &orig);

    Histogram3D(const std::vector<AxisX_t> &binULimitsX,
                const std::vector<AxisY_t> &binULimitsY,
                    const std::vector<AxisZ_t> &binULimitsZ);

    template<typename OAxisX_t, typename OAxisY_t, typename OAxisZ_t>
    Histogram3D(const std::vector<OAxisX_t> &binULimitsX,
                const std::vector<OAxisY_t> &binULimitsY,
                    const std::vector<OAxisZ_t> &binULimitsZ);

/*
    //TO BE CONVERTED FROM HISTO2D TO HISTO3D
    template<typename OAxisX_t, typename OAxisY_t>
    Histogram3D(const std::vector<OAxisX_t> &binULimitsX,
                unsigned int nBinsY,
                const PhysicsTools::Calibration::Range<OAxisY_t> &rangeY);

    template<typename OAxisX_t, typename OAxisY_t>
    Histogram3D(unsigned int nBinsX,
                const PhysicsTools::Calibration::Range<OAxisX_t> &rangeX,
                const std::vector<OAxisY_t> &binULimitsY);

    template<typename OAxisX_t, typename OAxisY_t>
    Histogram3D(unsigned int nBinsX,
                const PhysicsTools::Calibration::Range<OAxisX_t> &rangeX,
                unsigned int nBinsY,
                const PhysicsTools::Calibration::Range<OAxisY_t> &rangeY);
*/
    Histogram3D(unsigned int nBinsX, AxisX_t minX, AxisX_t maxX,
                unsigned int nBinsY, AxisY_t minY, AxisY_t maxY,
                    unsigned int nBinsZ, AxisZ_t minZ, AxisZ_t maxZ);

    ~Histogram3D();

    Histogram3D &operator = (const Histogram3D &orig);

    template<typename OValue_t, typename OAxisX_t, typename OAxisY_t, typename OAxisZ_t>
    Histogram3D &operator = (const Histogram3D<OValue_t,
                             OAxisX_t, OAxisY_t,  OAxisZ_t> &orig);

    void reset();

    const std::vector<AxisX_t> upperLimitsX() const { return binULimitsX; }
    const std::vector<AxisY_t> upperLimitsY() const { return binULimitsY; }
        const std::vector<AxisZ_t> upperLimitsZ() const { return binULimitsZ; }

    inline int bin3D(int binX, int binY, int binZ) const
//        { return (((binY * strideY) + binX) * strideX) + binZ; }
        { return binZ*strideX*strideY + binY*strideX + binX; }



    Value_t binContent(int bin) const { return binValues[bin]; }
    Value_t binContent(int binX, int binY, int binZ) const
    { return binValues[bin3D(binX, binY, binZ)]; }
    Value_t value(AxisX_t x, AxisY_t y, AxisY_t z) const
    { return binContent(findBin(x, y, z)); }
    Value_t normalizedValue(AxisX_t x, AxisY_t y, AxisZ_t z) const
    { return binContent(findBin(x, y, z)) / normalization(); }

        //TO BE CONVERTED FROM HISTO2D TO HISTO3D
//  Value_t normalizedXValue(AxisX_t x, AxisY_t y, AxisZ_t z) const;
//  Value_t normalizedYValue(AxisX_t x, AxisY_t y, AxisZ_t z) const;
//      Value_t normalizedZValue(AxisX_t x, AxisY_t y, AxisZ_t z) const;

    Value_t binError(int bin) const { return std::sqrt(binContent(bin)); }
    Value_t binError(int binX, int binY, int binZ) const
    { return binError(bin3D(binX, binY, binZ)); }
    Value_t error(AxisX_t x, AxisY_t y, AxisZ_t z) const
    { return binError(findBin(x, y, z)); }
    Value_t normalizedError(AxisX_t x, AxisY_t y, AxisY_t z) const
    { return std::sqrt(binContent(findBin(x, y, z))) / normalization(); }

        //TO BE CONVERTED FROM HISTO2D TO HISTO3D
//  Value_t normalizedXError(AxisX_t x, AxisY_t y, AxisZ_t z) const;
//  Value_t normalizedYError(AxisX_t x, AxisY_t y, AxisZ_t z) const;

    void setBinContent(int bin, Value_t value);
    void setBinContent(int binX, int binY, int binZ, Value_t value)
    { setBinContent(bin3D(binX, binY, binZ), value); }
    void fill(AxisX_t x, AxisY_t y, AxisZ_t z, Value_t weight = 1.0);

    bool empty() const { return binValues.empty(); }
    bool hasEquidistantBinsX() const { return binULimitsX.empty(); }
    bool hasEquidistantBinsY() const { return binULimitsY.empty(); }
        bool hasEquidistantBinsZ() const { return binULimitsZ.empty(); }
    int numberOfBinsX() const { return strideX - 2; }
    int numberOfBinsY() const { return strideY - 2; }
        int numberOfBinsZ() const { return binValues.size() / (strideX * strideY) - 2; }
    int numberOfBins() const
    { return numberOfBinsX() * numberOfBinsY() * numberOfBinsZ(); }

    inline const std::vector<Value_t> &values() const
    { return binValues; }

    void setValues(const std::vector<Value_t> &values);

    template<typename OValue_t>
    void setValues(const std::vector<OValue_t> &values);

    inline RangeX rangeX() const { return limitsX; }
    inline RangeY rangeY() const { return limitsY; }
        inline RangeZ rangeZ() const { return limitsZ; }
    RangeX binRangeX(int binX) const;
    RangeY binRangeY(int binY) const;
        RangeZ binRangeZ(int binZ) const;

        //TO BE CONVERTED FROM HISTO2D TO HISTO3D
/*  std::pair<RangeX, RangeY> binRange(int bin) const;
    std::pair<RangeX, RangeY> binRange(int binX, int binY) const
    { return binRange(bin2D(binX, binY)); }
*/
    int findBinX(AxisX_t x) const;
    int findBinY(AxisY_t y) const;
        int findBinZ(AxisZ_t z) const;
    int findBin(AxisX_t x, AxisY_t y, AxisZ_t z) const
    { return bin3D(findBinX(x), findBinY(y), findBinZ(z)); }
    Value_t normalization() const;

        //TO BE CONVERTED FROM HISTO2D TO HISTO3D
//  Value_t normalizationX(int binY) const;
//  Value_t normalizationY(int binX) const;

    protected:
    unsigned int            strideX;
        unsigned int                    strideY;
    std::vector<AxisX_t>        binULimitsX;
    std::vector<AxisY_t>        binULimitsY;
        std::vector<AxisZ_t>            binULimitsZ;
    std::vector<Value_t>        binValues;
    RangeX              limitsX;
    RangeY              limitsY;
        RangeY                          limitsZ;

    // transient cache variables
    mutable Value_t total COND_TRANSIENT; //CMS-THREADING protected by totalValid
#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
    mutable std::atomic<bool> totalValid COND_TRANSIENT;
#else
    mutable bool totalValid COND_TRANSIENT;
#endif
    mutable std::vector<Value_t>    sliceTotal COND_TRANSIENT;
    mutable std::vector<Value_t>    rowTotal COND_TRANSIENT;
    mutable std::vector<Value_t>    columnTotal COND_TRANSIENT;

    COND_SERIALIZABLE;
};

typedef Histogram3D<float>  HistogramF3D;
typedef Histogram3D<double> HistogramD3D;


} // namespace Calibration
} // namespace PhysicsTools

#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
#include "CondFormats/PhysicsToolsObjects/interface/Histogram3D.icc"
#endif

#endif // CondFormats_PhysicsToolsObjects_Histogram3D_h