Histogram2DTest.h

#ifndef HISTOGRAM2DTEST_H
#define HISTOGRAM2DTEST_H

#include "Histogram2D.h"
#include <memory>
#include "gtest/gtest.h"

class Histogram2DTest : public ::testing::Test
{
 protected:
    Histogram2DTest();
    virtual ~Histogram2DTest();

    Histogram2D *hist;
};


// y
// 4.0   -----------------------------------
//       |     |          |     |          |
//       |  2  |    5     |  8  |    11    |
// 2.0   -----------------------------------
//       |  1  |    4     |  7  |    10    |
// 1.0   -----------------------------------
//       |  0  |    3     |  6  |    9     |
// 0.0   -----------------------------------
//     -1.0  -0.5        0.5   1.0        2.0  X

Histogram2DTest::Histogram2DTest()
{
    std::vector<double> xbin_edges = {-1.0, -0.5, 0.5, 1.0, 2.0};
    std::vector<double> ybin_edges = {0.0, 1.0, 2.0, 4.0};
    hist = new Histogram2D(4, xbin_edges, 3, ybin_edges);
}

Histogram2DTest::~Histogram2DTest()
{
    delete hist;
}

TEST_F(Histogram2DTest, VariableHist)
{
    hist->reset();

    // basic axes check
    EXPECT_EQ(size_t(12), hist->getTotalNumberOfBins());
    EXPECT_EQ(hist->getRank(), size_t(2));
    EXPECT_EQ(hist->getXaxis()->getName(), std::string("x-axis"));
    EXPECT_EQ(hist->getXaxis()->getSize(), size_t(4));
    EXPECT_EQ(hist->getXmin(), -1.0);
    EXPECT_EQ(hist->getXmax(), 2.0);
    EXPECT_EQ(hist->getYaxis()->getName(), std::string("y-axis"));
    EXPECT_EQ(hist->getYaxis()->getSize(), size_t(3));
    EXPECT_EQ(hist->getYmin(), 0.0);
    EXPECT_EQ(hist->getYmax(), 4.0);

    // globalbin -> axes indices
    EXPECT_EQ(hist->getXaxisIndex(0), 0);
    EXPECT_EQ(hist->getXaxisIndex(1), 0);
    EXPECT_EQ(hist->getXaxisIndex(2), 0);
    EXPECT_EQ(hist->getXaxisIndex(3), 1);
    EXPECT_EQ(hist->getXaxisIndex(4), 1);
    EXPECT_EQ(hist->getXaxisIndex(5), 1);
    EXPECT_EQ(hist->getXaxisIndex(9), 3);
    EXPECT_EQ(hist->getXaxisIndex(10), 3);
    EXPECT_EQ(hist->getXaxisIndex(11), 3);

    EXPECT_EQ(hist->getYaxisIndex(0), 0);
    EXPECT_EQ(hist->getYaxisIndex(1), 1);
    EXPECT_EQ(hist->getYaxisIndex(2), 2);
    EXPECT_EQ(hist->getYaxisIndex(3), 0);
    EXPECT_EQ(hist->getYaxisIndex(4), 1);
    EXPECT_EQ(hist->getYaxisIndex(5), 2);
    EXPECT_EQ(hist->getYaxisIndex(9), 0);
    EXPECT_EQ(hist->getYaxisIndex(10), 1);
    EXPECT_EQ(hist->getYaxisIndex(11), 2);

    // axes indices -> global bin
    EXPECT_EQ(hist->getGlobalBin(0,0), size_t(0));
    EXPECT_EQ(hist->getGlobalBin(0,2), size_t(2));
    EXPECT_EQ(hist->getGlobalBin(1,1), size_t(4));
    EXPECT_EQ(hist->getGlobalBin(3,2), size_t(11));

    // bin centers
    EXPECT_EQ(hist->getXaxisValue(0), -0.75);
    EXPECT_EQ(hist->getXaxisValue(2), -0.75);
    EXPECT_EQ(hist->getXaxisValue(4), 0.0);
    EXPECT_EQ(hist->getXaxisValue(10), 1.5);
    EXPECT_EQ(hist->getXaxisValue(11), 1.5);

    EXPECT_EQ(hist->getYaxisValue(0), 0.5);
    EXPECT_EQ(hist->getYaxisValue(2), 3.0);
    EXPECT_EQ(hist->getYaxisValue(4), 1.5);
    EXPECT_EQ(hist->getYaxisValue(10), 1.5);
    EXPECT_EQ(hist->getYaxisValue(11), 3.0);

    // coordinates to global bin
    EXPECT_EQ(hist->findGlobalBin(-0.75, 0.5), size_t(0));
    EXPECT_EQ(hist->findGlobalBin(0.0, 1.5), size_t(4));
    EXPECT_EQ(hist->findGlobalBin(1.5, 3.0), size_t(11));

}

// y
// 4.0   -----------------------------------
//       |     |          |     |          |
//       |  2  |    5     |  8  |    11    |
// 2.0   -----------------------------------
//       |  1  |    4     |  7  |    10    |
// 1.0   -----------------------------------
//       |  0  |    3     |  6  |    9     |
// 0.0   -----------------------------------
//     -1.0  -0.5        0.5   1.0        2.0  X

TEST_F(Histogram2DTest, VariableHistFill)
{
    hist->reset();

    // values to fill all histogram
    std::vector<double> xvalues = {-0.75, -0.75, -0.75, 0.0, 0.0, 0.0,
                                   0.75, 0.75, 0.75, 1.5, 1.5, 1.5};
    std::vector<double> yvalues = {0.5, 1.5, 3.0, 0.5, 1.5, 3.0,
                                   0.5, 1.5, 3.0, 0.5, 1.5, 3.0};

    // put in every histogram bin one double value proportional to globalbin (globalbin*10.0)
    for(size_t i=0; i<xvalues.size(); ++i) {
        hist->fill(xvalues[i], yvalues[i], i*10.0);
    }

    // check bin content using globalbin
    for(size_t globalbin=0; globalbin<hist->getTotalNumberOfBins(); ++globalbin) {
        EXPECT_EQ(globalbin*10.0, hist->getBinContent(globalbin));
        EXPECT_EQ(1.0, hist->getBinNumberOfEntries(globalbin));

    }

    // check bin content using axes bins
    for(size_t binx=0; binx<hist->getXaxis()->getSize(); ++binx){
        for(size_t biny=0; biny<hist->getYaxis()->getSize(); ++biny){
            int globalbin = hist->getGlobalBin(binx, biny);
            EXPECT_EQ(globalbin*10.0, hist->getBinContent(binx, biny));
            EXPECT_EQ(1.0, hist->getBinNumberOfEntries(binx, biny));
        }
    }

}

// y
// 4.0   -----------------------------------
//       |     |          |     |          |
//       |  2  |    5     |  8  |    11    |
// 2.0   -----------------------------------
//       |  1  |    4     |  7  |    10    |
// 1.0   -----------------------------------
//       |  0  |    3     |  6  |    9     |
// 0.0   -----------------------------------
//     -1.0  -0.5        0.5   1.0        2.0  X

TEST_F(Histogram2DTest, projectionX)
{
    hist->reset();

    // values to fill all histogram
    std::vector<double> xvalues = {-0.75, -0.75, -0.75, 0.0, 0.0, 0.0,
                                   0.75, 0.75, 0.75, 1.5, 1.5, 1.5};
    std::vector<double> yvalues = {0.5, 1.5, 3.0, 0.5, 1.5, 3.0,
                                   0.5, 1.5, 3.0, 0.5, 1.5, 3.0};
    std::vector<double> content = {1.0, 2.0, 3.0, 1.0, 2.0, 3.0,
                                   1.0, 2.0, 3.0, 1.0, 2.0, 3.0};

    // put in every histogram bin the value from 'content' vector
    for(size_t i=0; i<xvalues.size(); ++i) {
        hist->fill(xvalues[i], yvalues[i], content[i]);
    }

    // a) create projection along X axis
    std::unique_ptr<Histogram1D > h1(hist->projectionX());
    EXPECT_EQ(hist->getXmin(), h1->getXmin());
    EXPECT_EQ(hist->getXmax(), h1->getXmax());
    EXPECT_EQ(hist->getNbinsX(), h1->getNbinsX());
    EXPECT_EQ(hist->getXaxisValue(0), h1->getXaxisValue(0));
    EXPECT_EQ(hist->getXaxisValue(3), h1->getXaxisValue(1));
    EXPECT_EQ(hist->getXaxisValue(6), h1->getXaxisValue(2));
    EXPECT_EQ(hist->getXaxisValue(9), h1->getXaxisValue(3));

    // check content of projections
    for(size_t binx=0; binx<h1->getNbinsX(); ++binx) {
        EXPECT_EQ(3, h1->getBinNumberOfEntries(binx));
        EXPECT_EQ(6.0, h1->getBinContent(binx));
        EXPECT_DOUBLE_EQ(std::sqrt(2.0/3.0), h1->getBinError(binx));
    }

    // b) create projection along X axis at given y (slice)
    h1.reset(hist->projectionX(1.01));
    EXPECT_EQ(hist->getXmin(), h1->getXmin());
    EXPECT_EQ(hist->getXmax(), h1->getXmax());
    EXPECT_EQ(hist->getNbinsX(), h1->getNbinsX());
    EXPECT_EQ(hist->getXaxisValue(0), h1->getXaxisValue(0));
    EXPECT_EQ(hist->getXaxisValue(3), h1->getXaxisValue(1));
    EXPECT_EQ(hist->getXaxisValue(6), h1->getXaxisValue(2));
    EXPECT_EQ(hist->getXaxisValue(9), h1->getXaxisValue(3));

    // check content of projections
    for(size_t binx=0; binx<h1->getNbinsX(); ++binx) {
        EXPECT_EQ(1, h1->getBinNumberOfEntries(binx));
        EXPECT_EQ(2.0, h1->getBinContent(binx));
        EXPECT_DOUBLE_EQ(0.0, h1->getBinError(binx));
    }

    // c) create projection along X for y between [ylow, yup]
    h1.reset(hist->projectionX(0.99, 1.01));
    EXPECT_EQ(hist->getXmin(), h1->getXmin());
    EXPECT_EQ(hist->getXmax(), h1->getXmax());
    EXPECT_EQ(hist->getNbinsX(), h1->getNbinsX());
    EXPECT_EQ(hist->getXaxisValue(0), h1->getXaxisValue(0));
    EXPECT_EQ(hist->getXaxisValue(3), h1->getXaxisValue(1));
    EXPECT_EQ(hist->getXaxisValue(6), h1->getXaxisValue(2));
    EXPECT_EQ(hist->getXaxisValue(9), h1->getXaxisValue(3));

    // check content of projections
    for(size_t binx=0; binx<h1->getNbinsX(); ++binx) {
        EXPECT_EQ(2, h1->getBinNumberOfEntries(binx));
        EXPECT_EQ(3.0, h1->getBinContent(binx));
        EXPECT_DOUBLE_EQ(std::sqrt(0.25), h1->getBinError(binx));
    }


}

// y
// 4.0   -----------------------------------
//       |     |          |     |          |
//       |  2  |    5     |  8  |    11    |
// 2.0   -----------------------------------
//       |  1  |    4     |  7  |    10    |
// 1.0   -----------------------------------
//       |  0  |    3     |  6  |    9     |
// 0.0   -----------------------------------
//     -1.0  -0.5        0.5   1.0        2.0  X


TEST_F(Histogram2DTest, projectionY)
{
    hist->reset();

    // values to fill all histogram
    std::vector<double> xvalues = {-0.75, -0.75, -0.75, 0.0, 0.0, 0.0,
                                   0.75, 0.75, 0.75, 1.5, 1.5, 1.5};
    std::vector<double> yvalues = {0.5, 1.5, 3.0, 0.5, 1.5, 3.0,
                                   0.5, 1.5, 3.0, 0.5, 1.5, 3.0};
    std::vector<double> content = {1.0, 2.0, 3.0, 1.0, 2.0, 3.0,
                                   1.0, 2.0, 3.0, 1.0, 2.0, 3.0};

    // put in every histogram bin the value from 'content' vector
    for(size_t i=0; i<xvalues.size(); ++i) {
        hist->fill(xvalues[i], yvalues[i], content[i]);
    }

    // a) create projection along Y axis
    std::unique_ptr<Histogram1D > h1(hist->projectionY());
    EXPECT_EQ(hist->getYmin(), h1->getXmin());
    EXPECT_EQ(hist->getYmax(), h1->getXmax());
    EXPECT_EQ(size_t(3), h1->getNbinsX());
    EXPECT_EQ(hist->getNbinsY(), h1->getNbinsX());
    EXPECT_EQ(hist->getYaxisValue(3), h1->getXaxisValue(0));
    EXPECT_EQ(hist->getYaxisValue(4), h1->getXaxisValue(1));
    EXPECT_EQ(hist->getYaxisValue(5), h1->getXaxisValue(2));

    // check content of projections

    for(size_t binx=0; binx<h1->getNbinsX(); ++binx) {
        EXPECT_EQ(4, h1->getBinNumberOfEntries(binx));
        EXPECT_DOUBLE_EQ(0.0, h1->getBinError(binx));
    }
    EXPECT_EQ(4.0, h1->getBinContent(0));
    EXPECT_EQ(8.0, h1->getBinContent(1));
    EXPECT_EQ(12.0, h1->getBinContent(2));

    // b) create projection along Y axis at given x(slice)
    h1.reset(hist->projectionY(0.0));
    EXPECT_EQ(hist->getYmin(), h1->getXmin());
    EXPECT_EQ(hist->getYmax(), h1->getXmax());
    EXPECT_EQ(size_t(3), h1->getNbinsX());
    EXPECT_EQ(hist->getNbinsY(), h1->getNbinsX());
    EXPECT_EQ(hist->getYaxisValue(3), h1->getXaxisValue(0));
    EXPECT_EQ(hist->getYaxisValue(4), h1->getXaxisValue(1));
    EXPECT_EQ(hist->getYaxisValue(5), h1->getXaxisValue(2));

    // check content of projections

    for(size_t binx=0; binx<h1->getNbinsX(); ++binx) {
        EXPECT_EQ(1, h1->getBinNumberOfEntries(binx));
        EXPECT_DOUBLE_EQ(0.0, h1->getBinError(binx));
    }
    EXPECT_EQ(1.0, h1->getBinContent(0));
    EXPECT_EQ(2.0, h1->getBinContent(1));
    EXPECT_EQ(3.0, h1->getBinContent(2));

    // c) create projection along Y axis for x's between [xlow,xup]
    h1.reset(hist->projectionY(0.0, 0.51));
    EXPECT_EQ(hist->getYmin(), h1->getXmin());
    EXPECT_EQ(hist->getYmax(), h1->getXmax());
    EXPECT_EQ(size_t(3), h1->getNbinsX());
    EXPECT_EQ(hist->getNbinsY(), h1->getNbinsX());
    EXPECT_EQ(hist->getYaxisValue(3), h1->getXaxisValue(0));
    EXPECT_EQ(hist->getYaxisValue(4), h1->getXaxisValue(1));
    EXPECT_EQ(hist->getYaxisValue(5), h1->getXaxisValue(2));

    // check content of projections

    for(size_t binx=0; binx<h1->getNbinsX(); ++binx) {
        EXPECT_EQ(2, h1->getBinNumberOfEntries(binx));
        EXPECT_DOUBLE_EQ(0.0, h1->getBinError(binx));
    }
    EXPECT_EQ(2.0, h1->getBinContent(0));
    EXPECT_EQ(4.0, h1->getBinContent(1));
    EXPECT_EQ(6.0, h1->getBinContent(2));
}

// y
// 4.0   -----------------------------------
//       |     |          |     |          |
//       |  2  |    5     |  8  |    11    |
// 2.0   -----------------------------------
//       |  1  |    4     |  7  |    10    |
// 1.0   -----------------------------------
//       |  0  |    3     |  6  |    9     |
// 0.0   -----------------------------------
//     -1.0  -0.5        0.5   1.0        2.0  X


TEST_F(Histogram2DTest, crop)
{
    hist->reset();

    // values to fill all histogram
    std::vector<double> xvalues = {-0.75, -0.75, -0.75, 0.0, 0.0, 0.0,
                                   0.75, 0.75, 0.75, 1.5, 1.5, 1.5};
    std::vector<double> yvalues = {0.5, 1.5, 3.0, 0.5, 1.5, 3.0,
                                   0.5, 1.5, 3.0, 0.5, 1.5, 3.0};
    std::vector<double> content = {1.0, 2.0, 3.0, 1.0, 2.0, 3.0,
                                   1.0, 2.0, 3.0, 1.0, 2.0, 3.0};

    // put in every histogram bin the value from 'content' vector
    for(size_t i=0; i<xvalues.size(); ++i) {
        hist->fill(xvalues[i], yvalues[i], content[i]);
    }

    std::unique_ptr<Histogram2D > crop(hist->crop(-0.49, 0.0, 1.99,1.9));
    EXPECT_EQ(-0.5, crop->getXmin());
    EXPECT_EQ(2.0, crop->getXmax());
    EXPECT_EQ(size_t(3), crop->getNbinsX());
    EXPECT_EQ(0.0, crop->getYmin());
    EXPECT_EQ(2.0, crop->getYmax());
    EXPECT_EQ(size_t(2), crop->getNbinsY());

    EXPECT_EQ(1.0, crop->getBinContent(0,0));
    EXPECT_EQ(2.0, crop->getBinContent(0,1));
    EXPECT_EQ(1.0, crop->getBinContent(1,0));
    EXPECT_EQ(2.0, crop->getBinContent(1,1));
    EXPECT_EQ(1.0, crop->getBinContent(2,0));
    EXPECT_EQ(2.0, crop->getBinContent(2,1));
}

TEST_F(Histogram2DTest, CreateHistogram)
{
    OutputData<double> data;
    data.addAxis("x-axis", 10, 0.0, 10.0);
    data.addAxis("y-axis", 5, -5.0, 0.0);
    for(size_t i=0; i<data.getAllocatedSize(); ++i) {
        data[i] = double(i);
    }

    std::unique_ptr<IHistogram> hist(IHistogram::createHistogram(data));
    EXPECT_EQ(size_t(2), hist->getRank());
    EXPECT_EQ(data.getAllocatedSize(), hist->getTotalNumberOfBins());
    EXPECT_EQ(data.getAxis(0)->getMin(), hist->getXmin());
    EXPECT_EQ(data.getAxis(0)->getMax(), hist->getXmax());
    EXPECT_EQ(data.getAxis(1)->getMin(), hist->getYmin());
    EXPECT_EQ(data.getAxis(1)->getMax(), hist->getYmax());
    for(size_t i=0; i<hist->getTotalNumberOfBins(); ++i) {
        EXPECT_EQ(data[i], hist->getBinContent(i));
        EXPECT_EQ(data[i], hist->getBinAverage(i));
        EXPECT_EQ(1, hist->getBinNumberOfEntries(i));
        EXPECT_EQ(0.0, hist->getBinError(i));
    }
}

TEST_F(Histogram2DTest, CreateOutputData)
{
    Histogram2D hist(10, -5.0, 5.0, 5, -5.0, 0.0);

    for(size_t nx=0; nx<hist.getNbinsX(); ++nx) {
        for(size_t ny=0; ny<hist.getNbinsY(); ++ny) {
            double value(ny + nx*hist.getNbinsY());
            size_t globalbin = hist.getGlobalBin(nx, ny);
            hist.fill(hist.getXaxisValue(globalbin), hist.getYaxisValue(globalbin), value);
        }
    }

    std::unique_ptr<OutputData<double> > data(hist.createOutputData(IHistogram::DataType::INTEGRAL));
    EXPECT_EQ(size_t(2), data->getRank());
    EXPECT_EQ(data->getAllocatedSize(), hist.getTotalNumberOfBins());
    EXPECT_EQ(data->getAxis(0)->getMin(), hist.getXmin());
    EXPECT_EQ(data->getAxis(0)->getMax(), hist.getXmax());
    EXPECT_EQ(data->getAxis(1)->getMin(), hist.getYmin());
    EXPECT_EQ(data->getAxis(1)->getMax(), hist.getYmax());
    for(size_t i=0; i<data->getAllocatedSize(); ++i) {
        EXPECT_EQ(double(i), (*data)[i]);
    }

    data.reset(hist.createOutputData(IHistogram::DataType::AVERAGE));
    for(size_t i=0; i<data->getAllocatedSize(); ++i) {
        EXPECT_EQ(double(i), (*data)[i]);
    }

    data.reset(hist.createOutputData(IHistogram::DataType::STANDARD_ERROR));
    for(size_t i=0; i<data->getAllocatedSize(); ++i) {
        EXPECT_EQ(0.0, (*data)[i]);
    }

    data.reset(hist.createOutputData(IHistogram::DataType::NENTRIES));
    for(size_t i=0; i<data->getAllocatedSize(); ++i) {
        EXPECT_EQ(1.0, (*data)[i]);
    }

}


TEST_F(Histogram2DTest, GetMaximumGetMinimum)
{
    Histogram2D hist(10, -5.0, 5.0, 5, -5.0, 0.0);

    for(size_t ix=0; ix<hist.getNbinsX(); ++ix) {
        for(size_t iy=0; iy<hist.getNbinsY(); ++iy) {
            hist.fill(-5.0 + ix+0.5, -5.0 + iy+0.5, 10.0 + ix + hist.getNbinsX()*iy);
        }
    }

    EXPECT_EQ(10.0, hist.getMinimum());
    EXPECT_EQ(size_t(0), hist.getMinimumBinIndex());
    EXPECT_EQ(59.0, hist.getMaximum());
    EXPECT_EQ(size_t(49), hist.getMaximumBinIndex());

}



#endif