MDGridBoxTest.h

#ifndef MDGRIDBOXTEST_H
#define MDGRIDBOXTEST_H

#include "MDBoxTest.h"
#include "MantidAPI/BoxController.h"
#include "MantidDataObjects/CoordTransformDistance.h"
#include "MantidDataObjects/MDBox.h"
#include "MantidDataObjects/MDGridBox.h"
#include "MantidDataObjects/MDLeanEvent.h"
#include "MantidGeometry/MDGeometry/MDBoxImplicitFunction.h"
#include "MantidGeometry/MDGeometry/MDImplicitFunction.h"
#include "MantidKernel/CPUTimer.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/Memory.h"
#include "MantidKernel/MultiThreaded.h"
#include "MantidKernel/ProgressText.h"
#include "MantidKernel/ThreadPool.h"
#include "MantidKernel/ThreadScheduler.h"
#include "MantidKernel/Timer.h"
#include "MantidKernel/Utils.h"
#include "MantidKernel/WarningSuppressions.h"
#include "MantidTestHelpers/MDEventsTestHelper.h"
#include <Poco/File.h>
#include <boost/random/linear_congruential.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/uniform_real.hpp>
#include <boost/random/variate_generator.hpp>
#include <cmath>
#include <cxxtest/TestSuite.h>
#include <gmock/gmock.h>
#include <map>
#include <memory>
#include <nexus/NeXusFile.hpp>
#include <vector>

using namespace Mantid;
using namespace Mantid::Kernel;
using namespace Mantid::DataObjects;
using namespace Mantid::API;
using namespace Mantid::Geometry;
using namespace testing;

class MDGridBoxTest : public CxxTest::TestSuite {
private:
  /// Mock type to help determine if masking is being determined correctly
  class MockMDBox : public MDBox<MDLeanEvent<1>, 1> {
    API::BoxController *const pBC;

  public:
    MockMDBox()
        : MDBox<MDLeanEvent<1>, 1>(new API::BoxController(1)),
          pBC(MDBox<MDLeanEvent<1>, 1>::getBoxController()) {}
    GCC_DIAG_OFF_SUGGEST_OVERRIDE
    MOCK_CONST_METHOD0(getIsMasked, bool());
    MOCK_METHOD0(mask, void());
    MOCK_METHOD0(unmask, void());
    ~MockMDBox() override { delete pBC; }
    GCC_DIAG_ON_SUGGEST_OVERRIDE
  };

  // the sp to a box controller used as general reference to all tested
  // classes/operations including MockMDBox
  BoxController_sptr gbc;

public:
  // This pair of boilerplate methods prevent the suite being created statically
  // This means the constructor isn't called when running other tests
  static MDGridBoxTest *createSuite() { return new MDGridBoxTest(); }
  static void destroySuite(MDGridBoxTest *suite) { delete suite; }

  bool DODEBUG;
  MDGridBoxTest() {
    gbc = BoxController_sptr(new BoxController(1));
    DODEBUG = false;
  }

  //-------------------------------------------------------------------------------------
  void test_MDBoxConstructor() {

    MDBox<MDLeanEvent<1>, 1> *b = MDEventsTestHelper::makeMDBox1(10);
    TS_ASSERT_EQUALS(b->getNumDims(), 1);
    TS_ASSERT_EQUALS(b->getNPoints(), 0);
    TS_ASSERT_DELTA(b->getExtents(0).getMin(), 0.0, 1e-5);
    TS_ASSERT_DELTA(b->getExtents(0).getMax(), 10.0, 1e-5);
    TS_ASSERT_DELTA(b->getVolume(), 10.0, 1e-5);
    // Start at ID 0.
    TS_ASSERT_EQUALS(b->getID(), 0);

    BoxController *const bcc = b->getBoxController();
    delete b;
    if (DODEBUG) {
      std::cout << sizeof(MDLeanEvent<3>) << " bytes per MDLeanEvent(3)\n";
      std::cout << sizeof(MDLeanEvent<4>) << " bytes per MDLeanEvent(4)\n";
      std::cout << sizeof(std::mutex) << " bytes per Mutex\n";
      std::cout << sizeof(MDDimensionExtents<coord_t>)
                << " bytes per MDDimensionExtents\n";
      std::cout << sizeof(MDBox<MDLeanEvent<3>, 3>) << " bytes per MDBox(3)\n";
      std::cout << sizeof(MDBox<MDLeanEvent<4>, 4>) << " bytes per MDBox(4)\n";
      std::cout << sizeof(MDGridBox<MDLeanEvent<3>, 3>)
                << " bytes per MDGridBox(3)\n";
      std::cout << sizeof(MDGridBox<MDLeanEvent<4>, 4>)
                << " bytes per MDGridBox(4)\n";

      MemoryStats mem;
      size_t start = mem.availMem();
      std::cout << start << " KB before\n";
      CPUTimer tim;
      for (size_t i = 0; i < 1000000; i++) {
        MDBox<MDLeanEvent<3>, 3> *box = new MDBox<MDLeanEvent<3>, 3>(bcc);
        (void)box;
      }
      std::cout << tim << " to allocate a million boxes\n";
      mem.update();
      size_t stop = mem.availMem();
      std::cout << stop << " KB after \n";
      std::cout << start - stop << " KB change \n";
      std::cout << (start - stop) * 1024 / sizeof(MDBox<MDLeanEvent<3>, 3>)
                << " times the sizeof MDBox3\n";
      delete bcc;
    } else
      delete bcc;
  }

  void check_MDGridBox(MDGridBox<MDLeanEvent<1>, 1> *g) {
    // The grid box stole the ID of the box it replaces.
    TS_ASSERT_EQUALS(g->getID(), 0);

    // Look overall; it has 10 points
    TS_ASSERT_EQUALS(g->getNumDims(), 1);
    TS_ASSERT_EQUALS(g->getNPoints(), 10);
    // Its depth level should be 0 (same as parent)
    TS_ASSERT_EQUALS(g->getDepth(), 0);
    // It was split into 10 MDBoxes.
    TS_ASSERT_EQUALS(g->getNumMDBoxes(), 10);
    // Same result for non-recursive children
    TS_ASSERT_EQUALS(g->getNumChildren(), 10);
    // The volume was set correctly
    TS_ASSERT_DELTA(g->getVolume(), 10.0, 1e-5);

    // It has a BoxController
    TS_ASSERT(g->getBoxController());

    // Check the boxes
    std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> &boxes = g->getBoxes();
    TS_ASSERT_EQUALS(boxes.size(), 10);
    for (size_t i = 0; i < boxes.size(); i++) {
      // The get child method is equivalent
      TS_ASSERT_EQUALS(boxes[i], g->getChild(i));
      MDBox<MDLeanEvent<1>, 1> *box =
          dynamic_cast<MDBox<MDLeanEvent<1>, 1> *>(boxes[i]);

      // Sequential ID, starting at 1 since 0 was used by the parent.
      TS_ASSERT_EQUALS(box->getID(), i + 1);
      // At the right place?
      TS_ASSERT_DELTA(box->getExtents(0).getMin(), double(i) * 1.0, 1e-6);
      TS_ASSERT_DELTA(box->getExtents(0).getMax(), double(i + 1) * 1.0, 1e-6);
      // Look at the single event in there
      TS_ASSERT_EQUALS(box->getNPoints(), 1);
      MDLeanEvent<1> ev = box->getEvents()[0];
      TS_ASSERT_DELTA(ev.getCenter(0), double(i) * 1.0 + 0.5, 1e-5);
      // Its depth level should be 1 (deeper than parent)
      TS_ASSERT_EQUALS(box->getDepth(), 1);
      // The volume was set correctly
      TS_ASSERT_DELTA(box->getVolume(), 1.0, 1e-5);
      // The parent of the MDBox is the grid box
      TS_ASSERT_EQUALS(box->getParent(), g);
    }
  }

  //-------------------------------------------------------------------------------------
  void test_MDGridBox_constructor_from_MDBox() {
    MDBox<MDLeanEvent<1>, 1> *b = MDEventsTestHelper::makeMDBox1();
    TS_ASSERT(b->getBoxController());
    // Start at ID 0.
    TS_ASSERT_EQUALS(b->getID(), 0);
    // Give it 10 events
    const std::vector<MDLeanEvent<1>> events =
        MDEventsTestHelper::makeMDEvents1(10);
    b->addEvents(events);
    TS_ASSERT_EQUALS(b->getNPoints(), 10);
    TS_ASSERT_DELTA(b->getVolume(), 10.0, 1e-5);

    // Build the grid box out of it
    MDGridBox<MDLeanEvent<1>, 1> *g = new MDGridBox<MDLeanEvent<1>, 1>(b);

    // Perform a detailed check
    check_MDGridBox(g);

    // Now we add 10 more events
    // auto events = MDEventsTestHelper::makeMDEvents1(10);
    TSM_ASSERT_EQUALS("No bad events ", 0, g->addEvents(events));

    // And now there should be 2 events per box
    std::vector<MDBoxBase<MDLeanEvent<1>, 1> *> boxes = g->getBoxes();
    for (size_t i = 0; i < 10; i++) {
      MDBox<MDLeanEvent<1>, 1> *box =
          dynamic_cast<MDBox<MDLeanEvent<1>, 1> *>(boxes[i]);
      TS_ASSERT_EQUALS(box->getNPoints(), 2);
    }