LoadDNSSCDTest.h

#ifndef MANTID_MDALGORITHMS_LOADDNSSCDEWTEST_H_
#define MANTID_MDALGORITHMS_LOADDNSSCDEWTEST_H_

#include "MantidKernel/Strings.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/IMDIterator.h"
#include "MantidAPI/IMDEventWorkspace.h"
#include "MantidDataObjects/MDBox.h"
#include "MantidDataObjects/MDGridBox.h"
#include "MantidDataObjects/MDEventFactory.h"
#include "MantidDataObjects/MDEventWorkspace.h"
#include "MantidAPI/BoxController.h"
#include "MantidGeometry/MDGeometry/HKL.h"
#include "MantidAPI/ExperimentInfo.h"
#include "MantidAPI/Run.h"
#include "MantidKernel/TimeSeriesProperty.h"
#include "MantidAPI/ITableWorkspace.h"
#include "MantidAPI/WorkspaceFactory.h"
#include "MantidMDAlgorithms/LoadDNSSCD.h"
#include <cxxtest/TestSuite.h>

using namespace Mantid;
using namespace Mantid::Kernel;
using namespace Mantid::API;
using namespace Mantid::DataObjects;
using namespace Mantid::MDAlgorithms;

bool cmp_Events(const std::vector<coord_t> &ev1, const std::vector<coord_t> &ev2) {
  // event1 < event2 if it has smaller det_id and dE
  assert(ev1.size() == 8);
  assert(ev2.size() == 8);
  double eps = 1.0e-07;
  if (std::abs(ev1[3] - ev2[3]) > eps) {
    return ev1[3] < ev2[3];
  } else {
    return ev1[7] < ev2[7];
  }
}

void sort_Events(std::vector<coord_t> &events) {
  // 1. split the events vector into 8-sized chunks
  std::vector<std::vector<coord_t>> sub_events;
  auto itr = events.cbegin();
  while (itr < events.cend()) {
    sub_events.emplace_back(std::vector<coord_t>(itr, itr + 8));
    itr += 8;
  }
  // 2. sort the vector of chunks
  std::sort(sub_events.begin(), sub_events.end(), cmp_Events);

  // 3. put the sorted array back
  events.clear();
  for (auto ev : sub_events) {
    events.insert(end(events), begin(ev), end(ev));
  }
}

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

  LoadDNSSCDTest() : m_fileName("dn134011vana.d_dat") {}

  void test_Init() {
    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
  }

  void test_Name() {
    LoadDNSSCD alg;
    TS_ASSERT_EQUALS(alg.name(), "LoadDNSSCD");
  }

  void test_Metadata() {
    // test whether the metadata were loaded correctly

    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");

    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    IMDEventWorkspace_sptr iws;
    TS_ASSERT_THROWS_NOTHING(
        iws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            outWSName));
    TS_ASSERT(iws);
    TS_ASSERT_EQUALS(iws->getNumExperimentInfo(), 1);

    ExperimentInfo_sptr expinfo = iws->getExperimentInfo(0);
    auto &run = expinfo->run();
    double d(1e-05);
    TS_ASSERT_DELTA(run.getPropertyValueAsType<double>("wavelength"), 4.2, d);
    TimeSeriesProperty<double> *p =
        dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Lambda"));
    TS_ASSERT_DELTA(p->firstValue(), 0.42, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Energy"));
    TS_ASSERT_DELTA(p->firstValue(), 4.640, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Speed"));
    TS_ASSERT_DELTA(p->firstValue(), 949.0, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("DeteRota"));
    TS_ASSERT_DELTA(p->firstValue(), -8.54, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Huber"));
    TS_ASSERT_DELTA(p->firstValue(), 79.0, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(
        run.getProperty("Flipper_precession"));
    TS_ASSERT_DELTA(p->firstValue(), 0.970, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(
        run.getProperty("Flipper_z_compensation"));
    TS_ASSERT_DELTA(p->firstValue(), 0.400, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("C_a"));
    TS_ASSERT_DELTA(p->firstValue(), 0.0, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("C_b"));
    TS_ASSERT_DELTA(p->firstValue(), 0.110, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("C_c"));
    TS_ASSERT_DELTA(p->firstValue(), -0.500, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("C_z"));
    TS_ASSERT_DELTA(p->firstValue(), 0.0, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("T1"));
    TS_ASSERT_DELTA(p->firstValue(), 295.0, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("T2"));
    TS_ASSERT_DELTA(p->firstValue(), 296.477, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(
        run.getProperty("sample_setpoint"));
    TS_ASSERT_DELTA(p->firstValue(), 295.0, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Timer"));
    TS_ASSERT_DELTA(p->firstValue(), 600.0, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Monitor"));
    TS_ASSERT_DELTA(p->firstValue(), 8332872, d);
    p = dynamic_cast<TimeSeriesProperty<double> *>(
        run.getProperty("TOF channels"));
    TS_ASSERT_DELTA(p->firstValue(), 1.0, d);
    TimeSeriesProperty<std::string> *s =
        dynamic_cast<TimeSeriesProperty<std::string> *>(
            run.getProperty("start_time"));
    TS_ASSERT_EQUALS(s->firstValue(), "2013-04-16T16:11:02");
    s = dynamic_cast<TimeSeriesProperty<std::string> *>(
        run.getProperty("stop_time"));
    TS_ASSERT_EQUALS(s->firstValue(), "2013-04-16T16:21:03");
    AnalysisDataService::Instance().remove(outWSName);
  }

  void test_DataWSStructure() {
    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");

    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("DeltaEmin", "-2.991993"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    IMDEventWorkspace_sptr iws;
    TS_ASSERT_THROWS_NOTHING(
        iws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            outWSName));
    TS_ASSERT(iws);

    TS_ASSERT_EQUALS(iws->getNumDims(), 4);
    TS_ASSERT_EQUALS(iws->getNPoints(), 24);
    TS_ASSERT_EQUALS(iws->id(), "MDEventWorkspace<MDEvent,4>");

    // test box controller
    BoxController_sptr bc = iws->getBoxController();
    TS_ASSERT(bc);
    TS_ASSERT_EQUALS(bc->getNumMDBoxes().size(), 6);

    // test dimensions
    std::vector<std::string> v = {"H", "K", "L", "DeltaE"};
    for (auto i = 0; i < 4; i++) {
      auto dim = iws->getDimension(i);
      TS_ASSERT(dim);
      TS_ASSERT_EQUALS(dim->getName(), v[i]);
      TS_ASSERT_EQUALS(dim->getNBins(), 5);
      double d(1.0e-05);
      TS_ASSERT_DELTA(dim->getMinimum(), -2.991993, d);
      if (i < 3) {
        TS_ASSERT_DELTA(dim->getMaximum(), 2.991993, d);
      } else {
        TS_ASSERT_DELTA(dim->getMaximum(), 4.637426, d);
      }
    }
    AnalysisDataService::Instance().remove(outWSName);
  }

  void test_DataWS() {
    // test whether the metadata were loaded correctly

    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");

    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("a", 6.84));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("b", 6.84));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("c", 4.77));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("alpha", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("beta", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("gamma", 120.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OmegaOffset", -43.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL1", "1,1,0"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL2", "0,0,1"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    IMDEventWorkspace_sptr iws;
    TS_ASSERT_THROWS_NOTHING(
        iws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            outWSName));
    TS_ASSERT(iws);

    std::vector<API::IMDNode *> boxes(0, NULL);
    iws->getBoxes(boxes, 10000, false);
    TSM_ASSERT_EQUALS("Number of boxes", boxes.size(), 1);
    API::IMDNode *box = boxes[0];
    // there are 24 points in the data file
    TS_ASSERT_EQUALS(box->getNPoints(), 24);
    std::vector<coord_t> events;
    size_t ncols;
    box->getEventsData(events, ncols);
    // 8 columns: I, err^2, run_num, det_id, h, k, l, dE
    TS_ASSERT_EQUALS(ncols, 8);
    // 8*24 = 192
    TS_ASSERT_EQUALS(events.size(), 192);
    // reference vector
    const std::vector<coord_t> ref = {
        4366, 4366, 0, 0, -0.09776273f, -0.09776273f, 0.10005156f, 0.0f, 31461,
        31461, 0, 1, -0.15959044f, -0.15959044f, 0.14884006f, 0.0f, 33314,
        33314, 0, 2, -0.224231616093f, -0.224231616093f, 0.189927174618f, 0.0f,
        32369, 32369, 0, 3, -0.291194311172f, -0.291194311172f, 0.223000198347f,
        0.0f, 31851, 31851, 0, 4, -0.359968893923f, -0.359968893923f,
        0.247807429194f, 0.0f, 30221, 30221, 0, 5, -0.430031948245f,
        -0.430031948245f, 0.264160069153f, 0.0f, 26267, 26267, 0, 6,
        -0.500850251989f, -0.500850251989f, 0.271933664761f, 0.0f, 26788, 26788,
        0, 7, -0.571884835101f, -0.571884835101f, 0.27106905426f, 0.0f, 29729,
        29729, 0, 8, -0.642595081514f, -0.642595081514f, 0.26157281786f, 0.0f,
        30188, 30188, 0, 9, -0.712442843555f, -0.712442843555f, 0.243517227652f,
        0.0f, 28116, 28116, 0, 10, -0.78089653758f, -0.78089653758f,
        0.217039697581f, 0.0f, 30277, 30277, 0, 11, -0.847435189645f,
        -0.847435189645f, 0.182341737639f, 0.0f, 20231, 20231, 0, 12,
        -0.911552400429f, -0.911552400429f, 0.13968742025f, 0.0f, 24538, 24538,
        0, 13, -0.972760199244f, -0.972760199244f, 0.089401370527f, 0.0f, 16416,
        16416, 0, 14, -1.03059275778f, -1.03059275778f, 0.0318662956709f, 0.0f,
        20225, 20225, 0, 15, -1.08460993535f, -1.08460993535f,
        -0.0324799276578f, 0.0f, 19957, 19957, 0, 16, -1.13440062862f,
        -1.13440062862f, -0.103147585846f, 0.0f, 19570, 19570, 0, 17,
        -1.17958590034f, -1.17958590034f, -0.179598855345f, 0.0f, 20743, 20743,
        0, 18, -1.21982186332f, -1.21982186332f, -0.261251895832f, 0.0f, 22758,
        22758, 0, 19, -1.25480229757f, -1.25480229757f, -0.347485278364f, 0.0f,
        23001, 23001, 0, 20, -1.28426098088f, -1.28426098088f, -0.437642714831f,
        0.0f, 21836, 21836, 0, 21, -1.30797371487f, -1.30797371487f,
        -0.531038052704f, 0.0f, 23877, 23877, 0, 22, -1.32576003133f,
        -1.32576003133f, -0.626960497068f, 0.0f, 13340, 13340, 0, 23,
        -1.33748456564f, -1.33748456564f, -0.724680020201f, 0.0f};
    double d(1.0e-06);
    for (auto i = 0; i < 192; i++) {
      TS_ASSERT_DELTA(events[i], ref[i], d);
    }

    AnalysisDataService::Instance().remove(outWSName);
  }

  void test_NormWSStructure() {
    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");

    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("DeltaEmin", "-2.991993"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    IMDEventWorkspace_sptr nws;
    TS_ASSERT_THROWS_NOTHING(
        nws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            normWSName));
    TS_ASSERT(nws);

    TS_ASSERT_EQUALS(nws->getNumDims(), 4);
    TS_ASSERT_EQUALS(nws->getNPoints(), 24);
    TS_ASSERT_EQUALS(nws->id(), "MDEventWorkspace<MDEvent,4>");

    // test box controller
    BoxController_sptr bc = nws->getBoxController();
    TS_ASSERT(bc);
    TS_ASSERT_EQUALS(bc->getNumMDBoxes().size(), 6);

    // test dimensions
    std::vector<std::string> v = {"H", "K", "L", "DeltaE"};
    for (auto i = 0; i < 4; i++) {
      auto dim = nws->getDimension(i);
      TS_ASSERT(dim);
      TS_ASSERT_EQUALS(dim->getName(), v[i]);
      TS_ASSERT_EQUALS(dim->getNBins(), 5);
      double d(1.0e-05);
      TS_ASSERT_DELTA(dim->getMinimum(), -2.991993, d);
      if (i < 3) {
        TS_ASSERT_DELTA(dim->getMaximum(), 2.991993, d);
      } else {
        TS_ASSERT_DELTA(dim->getMaximum(), 4.637426, d);
      }
    }
    AnalysisDataService::Instance().remove(normWSName);
  }

  void test_NormMonitor() {
    // test whether the metadata were loaded correctly

    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");

    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("a", 6.84));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("b", 6.84));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("c", 4.77));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("alpha", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("beta", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("gamma", 120.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OmegaOffset", -43.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL1", "1,1,0"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL2", "0,0,1"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    IMDEventWorkspace_sptr nws;
    TS_ASSERT_THROWS_NOTHING(
        nws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            normWSName));
    TS_ASSERT(nws);

    std::vector<API::IMDNode *> boxes(0, NULL);
    nws->getBoxes(boxes, 10000, false);
    TSM_ASSERT_EQUALS("Number of boxes", boxes.size(), 1);
    API::IMDNode *box = boxes[0];
    // there are 24 points in the data file
    TS_ASSERT_EQUALS(box->getNPoints(), 24);
    std::vector<coord_t> events;
    size_t ncols;
    box->getEventsData(events, ncols);
    // 8 columns: I, err^2, run_num, det_id, h, k, l, dE
    TS_ASSERT_EQUALS(ncols, 8);
    // 8*24 = 192
    TS_ASSERT_EQUALS(events.size(), 192);
    // reference vector
    const std::vector<coord_t> ref = {
        8332872, 8332872, 0, 0, -0.09776273f, -0.09776273f, 0.10005156f, 0.0f,
        8332872, 8332872, 0, 1, -0.15959044f, -0.15959044f, 0.14884006f, 0.0f,
        8332872, 8332872, 0, 2, -0.224231616093f, -0.224231616093f,
        0.189927174618f, 0.0f, 8332872, 8332872, 0, 3, -0.291194311172f,
        -0.291194311172f, 0.223000198347f, 0.0f, 8332872, 8332872, 0, 4,
        -0.359968893923f, -0.359968893923f, 0.247807429194f, 0.0f, 8332872,
        8332872, 0, 5, -0.430031948245f, -0.430031948245f, 0.264160069153f,
        0.0f, 8332872, 8332872, 0, 6, -0.500850251989f, -0.500850251989f,
        0.271933664761f, 0.0f, 8332872, 8332872, 0, 7, -0.571884835101f,
        -0.571884835101f, 0.27106905426f, 0.0f, 8332872, 8332872, 0, 8,
        -0.642595081514f, -0.642595081514f, 0.26157281786f, 0.0f, 8332872,
        8332872, 0, 9, -0.712442843555f, -0.712442843555f, 0.243517227652f,
        0.0f, 8332872, 8332872, 0, 10, -0.78089653758f, -0.78089653758f,
        0.217039697581f, 0.0f, 8332872, 8332872, 0, 11, -0.847435189645f,
        -0.847435189645f, 0.182341737639f, 0.0f, 8332872, 8332872, 0, 12,
        -0.911552400429f, -0.911552400429f, 0.13968742025f, 0.0f, 8332872,
        8332872, 0, 13, -0.972760199244f, -0.972760199244f, 0.089401370527f,
        0.0f, 8332872, 8332872, 0, 14, -1.03059275778f, -1.03059275778f,
        0.0318662956709f, 0.0f, 8332872, 8332872, 0, 15, -1.08460993535f,
        -1.08460993535f, -0.0324799276578f, 0.0f, 8332872, 8332872, 0, 16,
        -1.13440062862f, -1.13440062862f, -0.103147585846f, 0.0f, 8332872,
        8332872, 0, 17, -1.17958590034f, -1.17958590034f, -0.179598855345f,
        0.0f, 8332872, 8332872, 0, 18, -1.21982186332f, -1.21982186332f,
        -0.261251895832f, 0.0f, 8332872, 8332872, 0, 19, -1.25480229757f,
        -1.25480229757f, -0.347485278364f, 0.0f, 8332872, 8332872, 0, 20,
        -1.28426098088f, -1.28426098088f, -0.437642714831f, 0.0f, 8332872,
        8332872, 0, 21, -1.30797371487f, -1.30797371487f, -0.531038052704f,
        0.0f, 8332872, 8332872, 0, 22, -1.32576003133f, -1.32576003133f,
        -0.626960497068f, 0.0f, 8332872, 8332872, 0, 23, -1.33748456564f,
        -1.33748456564f, -0.724680020201f, 0.0f};
    double d(1.0e-06);
    for (auto i = 0; i < 192; i++) {
      TS_ASSERT_DELTA(events[i], ref[i], d);
    }

    AnalysisDataService::Instance().remove(normWSName);
  }

  void test_NormTime() {
    // test whether the metadata were loaded correctly

    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");

    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "time"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("a", 6.84));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("b", 6.84));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("c", 4.77));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("alpha", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("beta", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("gamma", 120.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OmegaOffset", -43.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL1", "1,1,0"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL2", "0,0,1"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    IMDEventWorkspace_sptr nws;
    TS_ASSERT_THROWS_NOTHING(
        nws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            normWSName));
    TS_ASSERT(nws);

    std::vector<API::IMDNode *> boxes(0, NULL);
    nws->getBoxes(boxes, 10000, false);
    TSM_ASSERT_EQUALS("Number of boxes", boxes.size(), 1);
    API::IMDNode *box = boxes[0];
    // there are 24 points in the data file
    TS_ASSERT_EQUALS(box->getNPoints(), 24);
    std::vector<coord_t> events;
    size_t ncols;
    box->getEventsData(events, ncols);
    // 8 columns: I, err^2, run_num, det_id, h, k, l, dE
    TS_ASSERT_EQUALS(ncols, 8);
    // 8*24 = 192
    TS_ASSERT_EQUALS(events.size(), 192);
    // reference vector
    const std::vector<coord_t> ref = {
        600, 0, 0, 0, -0.09776273f, -0.09776273f, 0.10005156f, 0.0f, 600, 0, 0,
        1, -0.15959044f, -0.15959044f, 0.14884006f, 0.0f, 600, 0, 0, 2,
        -0.224231616093f, -0.224231616093f, 0.189927174618f, 0.0f, 600, 0, 0, 3,
        -0.291194311172f, -0.291194311172f, 0.223000198347f, 0.0f, 600, 0, 0, 4,
        -0.359968893923f, -0.359968893923f, 0.247807429194f, 0.0f, 600, 0, 0, 5,
        -0.430031948245f, -0.430031948245f, 0.264160069153f, 0.0f, 600, 0, 0, 6,
        -0.500850251989f, -0.500850251989f, 0.271933664761f, 0.0f, 600, 0, 0, 7,
        -0.571884835101f, -0.571884835101f, 0.27106905426f, 0.0f, 600, 0, 0, 8,
        -0.642595081514f, -0.642595081514f, 0.26157281786f, 0.0f, 600, 0, 0, 9,
        -0.712442843555f, -0.712442843555f, 0.243517227652f, 0.0f, 600, 0, 0,
        10, -0.78089653758f, -0.78089653758f, 0.217039697581f, 0.0f, 600, 0, 0,
        11, -0.847435189645f, -0.847435189645f, 0.182341737639f, 0.0f, 600, 0,
        0, 12, -0.911552400429f, -0.911552400429f, 0.13968742025f, 0.0f, 600, 0,
        0, 13, -0.972760199244f, -0.972760199244f, 0.089401370527f, 0.0f, 600,
        0, 0, 14, -1.03059275778f, -1.03059275778f, 0.0318662956709f, 0.0f, 600,
        0, 0, 15, -1.08460993535f, -1.08460993535f, -0.0324799276578f, 0.0f,
        600, 0, 0, 16, -1.13440062862f, -1.13440062862f, -0.103147585846f, 0.0f,
        600, 0, 0, 17, -1.17958590034f, -1.17958590034f, -0.179598855345f, 0.0f,
        600, 0, 0, 18, -1.21982186332f, -1.21982186332f, -0.261251895832f, 0.0f,
        600, 0, 0, 19, -1.25480229757f, -1.25480229757f, -0.347485278364f, 0.0f,
        600, 0, 0, 20, -1.28426098088f, -1.28426098088f, -0.437642714831f, 0.0f,
        600, 0, 0, 21, -1.30797371487f, -1.30797371487f, -0.531038052704f, 0.0f,
        600, 0, 0, 22, -1.32576003133f, -1.32576003133f, -0.626960497068f, 0.0f,
        600, 0, 0, 23, -1.33748456564f, -1.33748456564f, -0.724680020201f,
        0.0f};
    double d(1.0e-06);
    for (auto i = 0; i < 192; i++) {
      TS_ASSERT_DELTA(events[i], ref[i], d);
    }

    AnalysisDataService::Instance().remove(normWSName);
  }

  void test_SaveHuber() {
    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");
    std::string tWSName("LoadDNSSCDTest_Huber");

    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("SaveHuberTo", tWSName));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    ITableWorkspace_sptr tws;
    TS_ASSERT_THROWS_NOTHING(
        tws = AnalysisDataService::Instance().retrieveWS<ITableWorkspace>(
            tWSName));
    TS_ASSERT(tws);

    // check that workspace has 1 row and 1 column
    TS_ASSERT_EQUALS(tws->rowCount(), 1);
    TS_ASSERT_EQUALS(tws->columnCount(), 1);
    std::vector<std::string> columnNames = {"Huber(degrees)"};
    TS_ASSERT_EQUALS(tws->getColumnNames(), columnNames);

    // test the value
    TS_ASSERT_DELTA(tws->cell<double>(0, 0), 79.0, 1.0e-06);
    AnalysisDataService::Instance().remove(tWSName);
  }

  void test_LoadHuber() {
    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");
    std::string tWSName2("LoadDNSSCDTest_Huber_save");
    std::string tWSName1("LoadDNSSCDTest_Huber_load");

    // create a test table workspace
    ITableWorkspace_sptr huberWS =
        WorkspaceFactory::Instance().createTable("TableWorkspace");
    huberWS->addColumn("double", "Huber(degrees)");
    const std::vector<double> vals = {77.0, 92.0, 122.0};
    auto n = vals.size();
    for (size_t i = 0; i < n; i++) {
      huberWS->appendRow();
      huberWS->cell<double>(i, 0) = vals[i];
    }
    AnalysisDataService::Instance().add(tWSName1, huberWS);

    // run the algorithm
    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("LoadHuberFrom", tWSName1));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("SaveHuberTo", tWSName2));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    IMDEventWorkspace_sptr iws;
    TS_ASSERT_THROWS_NOTHING(
        iws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            outWSName));
    TS_ASSERT(iws);

    TS_ASSERT_EQUALS(iws->getNumDims(), 4);
    // data should be replicated for each huber value
    TS_ASSERT_EQUALS(iws->getNPoints(), 24 * n);

    // Retrieve the table workspace from data service.
    ITableWorkspace_sptr tws;
    TS_ASSERT_THROWS_NOTHING(
        tws = AnalysisDataService::Instance().retrieveWS<ITableWorkspace>(
            tWSName2));
    TS_ASSERT(tws);

    // check that workspace has 1 row and 1 column
    TS_ASSERT_EQUALS(tws->rowCount(), n);
    TS_ASSERT_EQUALS(tws->columnCount(), 1);
    std::vector<std::string> columnNames = {"Huber(degrees)"};
    TS_ASSERT_EQUALS(tws->getColumnNames(), columnNames);

    // test the values
    for (size_t i = 0; i < n; i++)
      TS_ASSERT_DELTA(tws->cell<double>(i, 0), vals[i], 1.0e-06);
    AnalysisDataService::Instance().remove(tWSName1);
    AnalysisDataService::Instance().remove(tWSName2);
    AnalysisDataService::Instance().remove(outWSName);
  }

  void test_2ThetaLimits() {
    // test whether the scattering angle limits work correctly

    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");

    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("a", 6.84));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("b", 6.84));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("c", 4.77));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("alpha", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("beta", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("gamma", 120.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OmegaOffset", -43.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL1", "1,1,0"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL2", "0,0,1"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("TwoThetaLimits", "20.0,55.0"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    IMDEventWorkspace_sptr iws;
    TS_ASSERT_THROWS_NOTHING(
        iws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            outWSName));
    TS_ASSERT(iws);

    std::vector<API::IMDNode *> boxes(0, NULL);
    iws->getBoxes(boxes, 10000, false);
    TSM_ASSERT_EQUALS("Number of boxes", boxes.size(), 1);
    API::IMDNode *box = boxes[0];
    // there are 7 points (the rest is outside of 2theta limits)
    TS_ASSERT_EQUALS(box->getNPoints(), 7);
    std::vector<coord_t> events;
    size_t ncols;
    box->getEventsData(events, ncols);
    // 8 columns: I, err^2, run_num, det_id, h, k, l, dE
    TS_ASSERT_EQUALS(ncols, 8);
    // 8*7 = 56
    TS_ASSERT_EQUALS(events.size(), 56);
    // reference vector
    const std::vector<coord_t> ref = {
        32369, 32369, 0, 3, -0.291194311172f, -0.291194311172f, 0.223000198347f,
        0.0f, 31851, 31851, 0, 4, -0.359968893923f, -0.359968893923f,
        0.247807429194f, 0.0f, 30221, 30221, 0, 5, -0.430031948245f,
        -0.430031948245f, 0.264160069153f, 0.0f, 26267, 26267, 0, 6,
        -0.500850251989f, -0.500850251989f, 0.271933664761f, 0.0f, 26788, 26788,
        0, 7, -0.571884835101f, -0.571884835101f, 0.27106905426f, 0.0f, 29729,
        29729, 0, 8, -0.642595081514f, -0.642595081514f, 0.26157281786f, 0.0f,
        30188, 30188, 0, 9, -0.712442843555f, -0.712442843555f, 0.243517227652f,
        0.0f};
    double d(1.0e-06);
    for (auto i = 0; i < 56; i++) {
      TS_ASSERT_DELTA(events[i], ref[i], d);
    }

    AnalysisDataService::Instance().remove(outWSName);

    // test the normalization workspace as well
    IMDEventWorkspace_sptr nws;
    TS_ASSERT_THROWS_NOTHING(
        nws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            normWSName));
    TS_ASSERT(nws);
    // there are 7 points (the rest is outside of 2theta limits)
    TS_ASSERT_EQUALS(nws->getNPoints(), 7);

    AnalysisDataService::Instance().remove(normWSName);
  }

  void test_TOFWSStructure() {
    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");

    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", "dnstof.d_dat"));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("DeltaEmin", "-2.991993"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    IMDEventWorkspace_sptr iws;
    TS_ASSERT_THROWS_NOTHING(
        iws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            outWSName));
    TS_ASSERT(iws);

    TS_ASSERT_EQUALS(iws->getNumDims(), 4);
    TS_ASSERT_EQUALS(iws->getNPoints(), 1968);
    TS_ASSERT_EQUALS(iws->id(), "MDEventWorkspace<MDEvent,4>");
    // test some metadata
    TS_ASSERT_EQUALS(iws->getNumExperimentInfo(), 1);
    ExperimentInfo_sptr expinfo = iws->getExperimentInfo(0);
    auto &run = expinfo->run();
    TimeSeriesProperty<double> *p = dynamic_cast<TimeSeriesProperty<double> *>(
        run.getProperty("TOF channels"));
    TS_ASSERT_DELTA(p->firstValue(), 100, 1.0e-05);
    p = dynamic_cast<TimeSeriesProperty<double> *>(
        run.getProperty("Time per channel"));
    TS_ASSERT_DELTA(p->firstValue(), 40.1, 1.0e-05);
    // test box controller
    BoxController_sptr bc = iws->getBoxController();
    TS_ASSERT(bc);
    TS_ASSERT_EQUALS(bc->getNumMDBoxes().size(), 6);

    // test dimensions
    std::vector<std::string> v = {"H", "K", "L", "DeltaE"};
    for (auto i = 0; i < 4; i++) {
      auto dim = iws->getDimension(i);
      TS_ASSERT(dim);
      TS_ASSERT_EQUALS(dim->getName(), v[i]);
      TS_ASSERT_EQUALS(dim->getNBins(), 5);
      double d(1.0e-05);
      TS_ASSERT_DELTA(dim->getMinimum(), -2.991993, d);
      if (i < 3) {
        TS_ASSERT_DELTA(dim->getMaximum(), 2.991993, d);
      } else {
        TS_ASSERT_DELTA(dim->getMaximum(), 4.637426, d);
      }
    }
    AnalysisDataService::Instance().remove(outWSName);
  }

  void test_TOFWSData() {
    // test whether the calculation for inelastic data are correct

    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");

    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", "dnstof.d_dat"));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("a", 3.55));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("b", 3.55));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("c", 24.778));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("alpha", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("beta", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("gamma", 120.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OmegaOffset", 0.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL1", "1,1,0"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL2", "0,0,1"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("TwoThetaLimits", "20.0,55.0"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("DeltaEmin", "-3.0"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    IMDEventWorkspace_sptr iws;
    TS_ASSERT_THROWS_NOTHING(
        iws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            outWSName));
    TS_ASSERT(iws);

    std::vector<API::IMDNode *> boxes(0, NULL);
    iws->getBoxes(boxes, 10000, false);
    TSM_ASSERT_EQUALS("Number of boxes", boxes.size(), 1);
    API::IMDNode *box = boxes[0];
    // there are 7 points (the rest is outside of 2theta limits)
    TS_ASSERT_EQUALS(box->getNPoints(), 574);
    std::vector<coord_t> events;
    size_t ncols;
    box->getEventsData(events, ncols);
    // 8 columns: I, err^2, run_num, det_id, h, k, l, dE
    TS_ASSERT_EQUALS(ncols, 8);
    // 8*574 = 4592
    TS_ASSERT_EQUALS(events.size(), 4592);
    // reference vector, EPP is wrong, since no elastic channel is given
    const std::vector<coord_t> ref = {
        0, 0, 0, 3, -0.0943541043211f, -0.0943541043211f, 2.51817307323f,
        -2.22473993186f, // 0
        0, 0, 0, 3, -0.105491719946f, -0.105491719946f, 2.18460421817f,
        -1.53897441518f, // 1
        0, 0, 0, 3, -0.115542738924f, -0.115542738924f, 1.88357866605f,
        -0.951095651067f, // 2
        0, 0, 0, 3, -0.124658779393f, -0.124658779393f, 1.61055549086f,
        -0.443322919741f, // 3
        0, 0, 0, 3, -0.132964505153f, -0.132964505153f, 1.36180104236f,
        -0.00173676689289f, // 4
        0, 0, 0, 3, -0.140563360636f, -0.140563360636f, 1.13421718522f,
        0.384685191257f, // 5
        0, 0, 0, 3, -0.147541901385f, -0.147541901385f, 0.925211602133f,
        0.724762824962f, // 6
        0, 0, 0, 3, -0.153973105606f, -0.153973105606f, 0.732598613797f,
        1.02562126597f, // 7
        0, 0, 0, 3, -0.159918935922f, -0.159918935922f, 0.55452245477f,
        1.29306717609f, // 8
        0, 0, 0, 3, -0.165432342216f, -0.165432342216f, 0.389397289126f,
        1.53187104043f, // 9
        0, 0, 0, 3, -0.170558842805f, -0.170558842805f, 0.235859854405f,
        1.7459813825f, // 10
        0, 0, 0, 3, -0.175337784032f, -0.175337784032f, 0.0927317372921f,
        1.93868903792f, // 11
        0, 0, 0, 3, -0.179803352064f, -0.179803352064f, -0.0410109295185f,
        2.11275436309f, // 12
        0, 0, 0, 3, -0.183985391967f, -0.183985391967f, -0.166261998436f,
        2.27050663742f, // 13
        0, 0, 0, 3, -0.187910075568f, -0.187910075568f, -0.283805309267f,
        2.41392239469f, // 14
        0, 0, 0, 3, -0.1916004497f, -0.1916004497f, -0.394331109003f,
        2.54468763779f, // 15
        0, 0, 0, 3, -0.1950768891f, -0.1950768891f, -0.498449616001f,
        2.664247618f, // 16
        0, 0, 0, 3, -0.198357472759f, -0.198357472759f, -0.596702291619f,
        2.77384694056f, // 17
        0, 0, 0, 3, -0.20145829841f, -0.20145829841f, -0.689571258983f,
        2.87456208674f, // 18
        0, 0, 0, 3, -0.204393746692f, -0.204393746692f, -0.777487214755f,
        2.96732794808f, // 19
        0, 0, 0, 3, -0.207176704155f, -0.207176704155f, -0.86083610789f,
        3.05295960034f, // 20
        0, 0, 0, 3, -0.209818752378f, -0.209818752378f, -0.939964803903f,
        3.13217026882f, // 21
        0, 0, 0, 3, -0.212330329085f, -0.212330329085f, -1.01518590999f,
        3.20558622767f, // 22
        0, 0, 0, 3, -0.214720865951f, -0.214720865951f, -1.08678190253f,
        3.27375921711f, // 23
        0, 0, 0, 3, -0.216998906964f, -0.216998906964f, -1.15500867189f,
        3.33717683991f, // 24
        0, 0, 0, 3, -0.219172210459f, -0.219172210459f, -1.2200985783f,
        3.39627130464f, // 25
        0, 0, 0, 3, -0.221247837392f, -0.221247837392f, -1.28226309565f,
        3.45142680925f, // 26
        0, 0, 0, 3, -0.223232227977f, -0.223232227977f, -1.34169510674f,
        3.5029858015f, // 27
        0, 0, 0, 3, -0.225131268429f, -0.225131268429f, -1.39857090231f,
        3.55125430721f, // 28
        0, 0, 0, 3, -0.226950349283f, -0.226950349283f, -1.45305192753f,
        3.59650648186f, // 29
        0, 0, 0, 3, -0.228694416494f, -0.228694416494f, -1.50528631254f,
        3.63898851198f, // 30
        0, 0, 0, 3, -0.230368016343f, -0.230368016343f, -1.55541021734f,
        3.67892197067f, // 31
        0, 0, 0, 3, -0.231975335009f, -0.231975335009f, -1.60354901701f,
        3.71650671254f, // 32
        0, 0, 0, 3, -0.233520233533f, -0.233520233533f, -1.64981834872f,
        3.75192337916f, // 33
        0, 0, 0, 3, -0.23500627878f, -0.23500627878f, -1.69432503923f,
        3.78533557363f, // 34
        0, 0, 0, 3, -0.236436770934f, -0.236436770934f, -1.73716792823f,
        3.81689175332f, // 35
        0, 0, 0, 3, -0.237814767963f, -0.237814767963f, -1.77843860111f,
        3.84672688183f, // 36
        0, 0, 0, 3, -0.239143107441f, -0.239143107441f, -1.81822204254f,
        3.87496387446f, // 37
        0, 0, 0, 3, -0.240424426052f, -0.240424426052f, -1.85659722056f,
        3.90171486617f, // 38
        0, 0, 0, 3, -0.24166117706f, -0.24166117706f, -1.89363760977f,
        3.92708232664f, // 39
        0, 0, 0, 3, -0.242855645982f, -0.242855645982f, -1.92941166089f,
        3.95116004298f, // 40
        1, 1, 0, 3, -0.244009964688f, -0.244009964688f, -1.9639832229f,
        3.97403398783f, // 41
        1, 1, 0, 3, -0.245126124099f, -0.245126124099f, -1.99741192336f,
        3.99578308789f, // 42
        0, 0, 0, 3, -0.246205985642f, -0.246205985642f, -2.0297535116f,
        4.01647990566f, 2, 2, 0, 3, -0.247251291615f, -0.247251291615f,
        -2.06106016902f, 4.03619124547f, 0, 0, 0, 3, -0.248263674566f,
        -0.248263674566f, -2.09138078999f, 4.05497869322f, 2, 2, 0, 3,
        -0.249244665798f, -0.249244665798f, -2.12076123667f, 4.07289909803f, 6,
        6, 0, 3, -0.250195703099f, -0.250195703099f, -2.14924457046f,
        4.09000500276f, // EPP
        3, 3, 0, 3, -0.251118137774f, -0.251118137774f, -2.17687126264f,
        4.10634502964f, 0, 0, 0, 3, -0.252013241051f, -0.252013241051f,
        -2.20367938617f, 4.12196422612f, 0, 0, 0, 3, -0.252882209926f,
        -0.252882209926f, -2.22970479075f, 4.1369043757f, 0, 0, 0, 3,
        -0.253726172503f, -0.253726172503f, -2.25498126284f, 4.15120427767f, 0,
        0, 0, 3, -0.254546192879f, -0.254546192879f, -2.27954067188f,
        4.16489999925f, 0, 0, 0, 3, -0.255343275622f, -0.255343275622f,
        -2.30341310445f, 4.17802510323f, 0, 0, 0, 3, -0.256118369875f,
        -0.256118369875f, -2.32662698715f, 4.19061085383f, 0, 0, 0, 3,
        -0.256872373129f, -0.256872373129f, -2.34920919958f, 4.20268640299f, 0,
        0, 0, 3, -0.257606134684f, -0.257606134684f, -2.37118517811f,
        4.2142789594f, 0, 0, 0, 3, -0.258320458847f, -0.258320458847f,
        -2.39257901152f, 4.22541394183f, 0, 0, 0, 3, -0.259016107869f,
        -0.259016107869f, -2.41341352902f, 4.23611511866f, 0, 0, 0, 3,
        -0.259693804658f, -0.259693804658f, -2.43371038155f, 4.24640473475f, 0,
        0, 0, 3, -0.260354235286f, -0.260354235286f, -2.45349011683f,
        4.25630362721f, 0, 0, 0, 3, -0.260998051308f, -0.260998051308f,
        -2.4727722487f, 4.2658313309f, 0, 0, 0, 3, -0.2616258719f,
        -0.2616258719f, -2.49157532139f, 4.27500617494f, 0, 0, 0, 3,
        -0.262238285852f, -0.262238285852f, -2.50991696898f, 4.2838453709f, 0,
        0, 0, 3, -0.262835853406f, -0.262835853406f, -2.52781397058f,
        4.2923650936f, 0, 0, 0, 3, -0.263419107964f, -0.263419107964f,
        -2.54528230147f, 4.30058055512f, 0, 0, 0, 3, -0.26398855768f,
        -0.26398855768f, -2.56233718075f, 4.3085060728f, 0, 0, 0, 3,
        -0.264544686935f, -0.264544686935f, -2.57899311548f, 4.31615513161f, 0,
        0, 0, 3, -0.265087957711f, -0.265087957711f, -2.5952639419f,
        4.32354044159f, 0, 0, 0, 3, -0.265618810868f, -0.265618810868f,
        -2.61116286371f, 4.33067399066f, 0, 0, 0, 3, -0.266137667344f,
        -0.266137667344f, -2.62670248786f, 4.33756709332f, 0, 0, 0, 3,
        -0.266644929262f, -0.266644929262f, -2.64189485783f, 4.34423043551f, 0,
        0, 0, 3, -0.267140980972f, -0.267140980972f, -2.65675148482f,
        4.35067411606f, 0, 0, 0, 3, -0.267626190022f, -0.267626190022f,
        -2.67128337679f, 4.35690768501f, 0, 0, 0, 3, -0.268100908065f,
        -0.268100908065f, -2.6855010657f, 4.36294017896f, 0, 0, 0, 3,
        -0.268565471711f, -0.268565471711f, -2.69941463291f, 4.3687801539f, 0,
        0, 0, 3, -0.269020203322f, -0.269020203322f, -2.7130337331f,
        4.37443571549f, 0, 0, 0, 3, -0.269465411759f, -0.269465411759f,
        -2.72636761653f, 4.37991454727f, 0, 0, 0, 3, -0.269901393077f,
        -0.269901393077f, -2.73942515004f, 4.38522393675f, 0, 0, 0, 3,
        -0.27032843119f, -0.27032843119f, -2.75221483671f, 4.39037079963f, 0, 0,
        0, 3, -0.270746798477f, -0.270746798477f, -2.76474483431f,
        4.39536170235f, 0, 0, 0, 3, -0.271156756372f, -0.271156756372f,
        -2.77702297266f, 4.40020288306f};
    double d(1.0e-06);
    sort_Events(events);
    for (auto i = 0; i < 82 * 8; i++) {
      TS_ASSERT_DELTA(events[i], ref[i], d);
    }

    AnalysisDataService::Instance().remove(outWSName);

    // test the normalization workspace as well
    IMDEventWorkspace_sptr nws;
    TS_ASSERT_THROWS_NOTHING(
        nws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            normWSName));
    TS_ASSERT(nws);
    // there are 7 histograms (the rest is outside of 2theta limits)
    TS_ASSERT_EQUALS(nws->getNPoints(), 574);

    AnalysisDataService::Instance().remove(normWSName);
  }

  void test_TOFWSDataRotateEPP() {
    // test whether the calculation for inelastic data are correct

    std::string outWSName("LoadDNSSCDTest_OutputWS");
    std::string normWSName("LoadDNSSCDTest_OutputWS_norm");

    LoadDNSSCD alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize());
    TS_ASSERT(alg.isInitialized());
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", "dnstof.d_dat"));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("NormalizationWorkspace", normWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("a", 3.55));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("b", 3.55));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("c", 24.778));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("alpha", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("beta", 90.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("gamma", 120.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OmegaOffset", -43.0));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL1", "1,1,0"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("HKL2", "0,0,1"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("TwoThetaLimits", "25.0,60.0"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("DeltaEmin", "-3.0"));
    TS_ASSERT_THROWS_NOTHING(alg.setProperty("ElasticChannel", "64"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(););
    TS_ASSERT(alg.isExecuted());

    // Retrieve the workspace from data service.
    IMDEventWorkspace_sptr iws;
    TS_ASSERT_THROWS_NOTHING(
        iws = AnalysisDataService::Instance().retrieveWS<IMDEventWorkspace>(
            outWSName));
    TS_ASSERT(iws);

    std::vector<API::IMDNode *> boxes(0, NULL);
    iws->getBoxes(boxes, 10000, false);
    TSM_ASSERT_EQUALS("Number of boxes", boxes.size(), 1);
    API::IMDNode *box = boxes[0];
    // there are 7 points (the rest is outside of 2theta limits)