ConvertEmptyToTofTest.h

#ifndef MANTID_ALGORITHMS_CONVERTEMPTYTOTOFTEST_H_
#define MANTID_ALGORITHMS_CONVERTEMPTYTOTOFTEST_H_

#include <cxxtest/TestSuite.h>
#include <cmath>

#include "MantidAlgorithms/ConvertEmptyToTof.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/FrameworkManager.h"
#include "MantidTestHelpers/WorkspaceCreationHelper.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidGeometry/Instrument/ComponentHelper.h"

using Mantid::Algorithms::ConvertEmptyToTof;
using namespace Mantid;
using namespace API;

class ConvertEmptyToTofTest: 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 ConvertEmptyToTofTest *createSuite() {
    return new ConvertEmptyToTofTest();
  }
  static void destroySuite(ConvertEmptyToTofTest *suite) {
    delete suite;
  }

  ConvertEmptyToTofTest() {
    FrameworkManager::Instance();
  }

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

  void test_find_ep_from_1_spectra() {
    // Name of the output workspace.
    std::string outWSName("ConvertEmptyToTofTest_OutputWS1");
    std::string inWSName("ConvertEmptyToTofTest_InputWS1");

    DataObjects::Workspace2D_sptr testWS = createTestWorkspace();
    WorkspaceCreationHelper::storeWS(inWSName, testWS);

    ConvertEmptyToTof alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize())
    TS_ASSERT(alg.isInitialized())
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("InputWorkspace", inWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("ListOfSpectraIndices", "5"));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("ListOfChannelIndices", "40-60"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(); );
    TS_ASSERT(alg.isExecuted());

    auto outWS =
        AnalysisDataService::Instance().retrieveWS<API::MatrixWorkspace>(
            outWSName);

    TS_ASSERT(outWS);
    if (!outWS)
      return;

    // Check the results
    TS_ASSERT_DELTA(*(outWS->dataX(1).begin()), 31463.8, 0.1);
    TS_ASSERT_DELTA(*(outWS->dataX(1).end() - 1), 34493.8, 0.1);

    // Remove workspace from the data service.
    AnalysisDataService::Instance().remove(outWSName);
  }

  void test_find_ep_from_2_spectra() {
    // Name of the output workspace.
    std::string outWSName("ConvertEmptyToTofTest_OutputWS2");
    std::string inWSName("ConvertEmptyToTofTest_InputWS2");

    DataObjects::Workspace2D_sptr testWS = createTestWorkspace();
    WorkspaceCreationHelper::storeWS(inWSName, testWS);

    // move
    placeDetectorAtSamePosition(testWS, "pixel-5)", "pixel-6)");

    ConvertEmptyToTof alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize())
    TS_ASSERT(alg.isInitialized())
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("InputWorkspace", inWSName));
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("ListOfSpectraIndices", "5,6"));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("ListOfChannelIndices", "40-60"));
    TS_ASSERT_THROWS_NOTHING(alg.execute(); );
    TS_ASSERT(alg.isExecuted());

    auto outWS =
        AnalysisDataService::Instance().retrieveWS<API::MatrixWorkspace>(
            outWSName);

    TS_ASSERT(outWS);
    if (!outWS)
      return;

    // Check the results
    TS_ASSERT_DELTA(*(outWS->dataX(1).begin()), 31433.8, 0.1);
    TS_ASSERT_DELTA(*(outWS->dataX(1).end() - 1), 34463.8, 0.1);

    // Remove workspace from the data service.
    AnalysisDataService::Instance().remove(outWSName);
  }

  void test_set_tof_from_EPP_and_EP_Spectrum_idx() {
      // Name of the output workspace.
      std::string outWSName("ConvertEmptyToTofTest_OutputWS3");
      std::string inWSName("ConvertEmptyToTofTest_InputWS3");

      DataObjects::Workspace2D_sptr testWS = createTestWorkspace();
      WorkspaceCreationHelper::storeWS(inWSName, testWS);

      ConvertEmptyToTof alg;
      TS_ASSERT_THROWS_NOTHING(alg.initialize())
      TS_ASSERT(alg.isInitialized())
      TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("InputWorkspace", inWSName));
      TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));

      TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("ElasticPeakPositionSpectrum", "5"));
      TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("ElasticPeakPosition", "50"));
      TS_ASSERT_THROWS_NOTHING(alg.execute(); );
      TS_ASSERT(alg.isExecuted());

      auto outWS =
          AnalysisDataService::Instance().retrieveWS<API::MatrixWorkspace>(
              outWSName);

      TS_ASSERT(outWS);
      if (!outWS)
        return;

      // Check the results
      TS_ASSERT_DELTA(*(outWS->dataX(1).begin()), 30113.8, 0.1);
      TS_ASSERT_DELTA(*(outWS->dataX(1).end() - 1), 33143.8, 0.1);

      // Remove workspace from the data service.
      AnalysisDataService::Instance().remove(outWSName);
    }

private:

  /**
   * Create a test workspace with full instrument
   * Spectra follow a Gaussian distribution
   */
  DataObjects::Workspace2D_sptr createTestWorkspace() {

    // create test ws
    const size_t nHist = 10; //or testWS->getNumberHistograms();
    const size_t nBins = 101; //or testWS->blocksize();
    DataObjects::Workspace2D_sptr testWS =
        WorkspaceCreationHelper::create2DWorkspaceWithFullInstrument(nHist,
            nBins, false, false, true, std::string("testInstEmpty"));
    testWS->getAxis(0)->setUnit("Empty");
    API::Run & run = testWS->mutableRun();
    run.addProperty<double>("wavelength", 5.0, true); //overwrite
    run.addProperty<double>("channel_width", 30.0, true); //overwrite

    for (size_t i = 0; i < nHist; ++i) {
      for (size_t j = 0; j < nBins - 1; ++j) {
        // gaussian peak centred at 50,and h=10
        testWS->dataY(i)[j] = 10
            * exp(-pow((static_cast<double>(j) - 50), 2) / (2 * pow(1.5, 2)));
      }
    }
    return testWS;
  }
  /**
   * Place componentName1 and componentName2 at the same distance!
   */
  void placeDetectorAtSamePosition(API::MatrixWorkspace_sptr ws,
      const std::string& componentName1, const std::string& componentName2) {

    Geometry::Instrument_const_sptr instrument = ws->getInstrument();
    Geometry::IComponent_const_sptr component1 = instrument->getComponentByName(
        componentName1);
    Geometry::IComponent_const_sptr component2 = instrument->getComponentByName(
        componentName2);

    if (component1 == 0 || component2 == 0)
      throw std::runtime_error(
          "component1 = 0 || component2 == 0 : Not found!");

    Kernel::V3D component1Pos = component1->getPos();
    Kernel::V3D component2NewPos(component1Pos);

    Geometry::ParameterMap& pmap = ws->instrumentParameters();
    Geometry::ComponentHelper::moveComponent(*component2, pmap,
        component2NewPos, Geometry::ComponentHelper::Absolute);

  }

};

#endif /* MANTID_ALGORITHMS_CONVERTEMPTYTOTOFTEST_H_ */