LoadCanSAS1dTest.h

#ifndef LOADCANSAS1DTEST_H
#define LOADCANSAS1DTEST_H

//------------------------------------------------
// Includes
//------------------------------------------------

#include <cxxtest/TestSuite.h>

#include "MantidDataHandling/LoadCanSAS1D.h"
#include "MantidDataObjects/Workspace2D.h"
#include <Poco/Path.h>

class LoadCanSAS1dTest : public CxxTest::TestSuite {
public:
  static LoadCanSAS1dTest *createSuite() { return new LoadCanSAS1dTest(); }
  static void destroySuite(LoadCanSAS1dTest *suite) { delete suite; }

  LoadCanSAS1dTest() { inputFile = "LOQ_CANSAS1D.xml"; }
  void testInit() {
    TS_ASSERT_THROWS_NOTHING(cansas1d.initialize());
    TS_ASSERT(cansas1d.isInitialized());
  }

  void testSingleEntry() {
    if (!cansas1d.isInitialized())
      cansas1d.initialize();

    // No parameters have been set yet, so it should throw
    TS_ASSERT_THROWS(cansas1d.execute(), std::runtime_error);

    // Set the file name
    cansas1d.setPropertyValue("Filename", inputFile);

    std::string outputSpace = "outws";
    // Set an output workspace
    cansas1d.setPropertyValue("OutputWorkspace", outputSpace);

    std::string result;
    TS_ASSERT_THROWS_NOTHING(result =
                                 cansas1d.getPropertyValue("OutputWorkspace"))
    TS_ASSERT(result == outputSpace);

    // Should now throw nothing
    TS_ASSERT_THROWS_NOTHING(cansas1d.execute());
    TS_ASSERT(cansas1d.isExecuted());

    // Now need to test the resultant workspace, first retrieve it
    Mantid::API::Workspace_sptr ws;
    TS_ASSERT_THROWS_NOTHING(
        ws =
            Mantid::API::AnalysisDataService::Instance().retrieve(outputSpace));
    Mantid::DataObjects::Workspace2D_sptr ws2d =
        boost::dynamic_pointer_cast<Mantid::DataObjects::Workspace2D>(ws);
    // Check if filename is saved
    TS_ASSERT_EQUALS(cansas1d.getPropertyValue("Filename"),
                     ws2d->run().getProperty("Filename")->value());

    Mantid::Kernel::Property *logP = ws2d->run().getLogData("run_number");
    TS_ASSERT_EQUALS(logP->value(), "LOQ48097")

    // Single histogram
    TS_ASSERT_EQUALS(ws2d->getNumberHistograms(), 1);

    // Test the size of the data vectors (there should be 102 data points so x
    // have 103)
    TS_ASSERT_EQUALS((ws2d->dataX(0).size()), 102);
    TS_ASSERT_EQUALS((ws2d->dataY(0).size()), 102);
    TS_ASSERT_EQUALS((ws2d->dataE(0).size()), 102);

    double tolerance(1e-06);
    TS_ASSERT_DELTA(ws2d->dataX(0)[0], 0.0604703, tolerance);
    TS_ASSERT_DELTA(ws2d->dataX(0)[1], 0.0620232, tolerance);
    TS_ASSERT_DELTA(ws2d->dataX(0)[2], 0.0635737, tolerance);
    ////Test a couple of random ones
    TS_ASSERT_DELTA(ws2d->dataX(0)[20], 0.0991537, tolerance);
    TS_ASSERT_DELTA(ws2d->dataX(0)[64], 0.293873, tolerance);

    TS_ASSERT_DELTA(ws2d->dataX(0)[100], 0.714858, tolerance);
    TS_ASSERT_DELTA(ws2d->dataX(0)[101], 0.732729, tolerance);

    TS_ASSERT_DELTA(ws2d->dataY(0)[0], 12, tolerance);
    TS_ASSERT_DELTA(ws2d->dataY(0)[25], 4674, tolerance);
    TS_ASSERT_DELTA(ws2d->dataY(0)[99], 1, tolerance);

    TS_ASSERT_DELTA(ws2d->dataE(0)[0], 3.4641, tolerance);
    TS_ASSERT_DELTA(ws2d->dataE(0)[25], 68.3667, tolerance);
    TS_ASSERT_DELTA(ws2d->dataE(0)[99], 1, tolerance);
  }

  void testMultipleEntries() {
    using namespace std;
    using namespace Mantid;
    using namespace API;
    using namespace DataObjects;
    using namespace DataHandling;

    LoadCanSAS1D alg;
    alg.initialize();

    std::string outputSpace = "LoadCanSAS1DTest_out";
    // Set an output workspace
    alg.setPropertyValue("OutputWorkspace", outputSpace);
    alg.setPropertyValue("Filename", "testCansas1DMultiEntry.xml");

    TS_ASSERT_THROWS_NOTHING(alg.execute())
    TS_ASSERT(alg.isExecuted());

    // Now need to test the resultant workspace, first retrieve it
    Workspace_sptr ws =
        Mantid::API::AnalysisDataService::Instance().retrieve(outputSpace);
    WorkspaceGroup_sptr group = boost::dynamic_pointer_cast<WorkspaceGroup>(ws);
    TS_ASSERT(group)
    vector<string> wNames = group->getNames();

    TS_ASSERT_EQUALS(
        wNames.size(),
        2) // change this and the lines below when group workspace names change

    ws = Mantid::API::AnalysisDataService::Instance().retrieve(wNames[0]);
    Mantid::DataObjects::Workspace2D_sptr ws2d =
        boost::dynamic_pointer_cast<Mantid::DataObjects::Workspace2D>(ws);
    TS_ASSERT(ws2d)

    Run run = ws2d->run();
    Mantid::Kernel::Property *logP = run.getLogData("run_number");
    TS_ASSERT_EQUALS(logP->value(), "53616")
    TS_ASSERT_EQUALS(run.getLogData("UserFile")->value(), "MASK.094AA");
    TS_ASSERT_EQUALS(ws2d->getInstrument()->getName(), "LOQ")

    TS_ASSERT_EQUALS(ws2d->getNumberHistograms(), 1);
    TS_ASSERT_EQUALS(ws2d->dataX(0).size(), 143);

    // some of the data is only stored to 3 decimal places
    double tolerance(1e-04);
    // this tests just the first, a middle and last value the other workspace
    // has all its values check below
    const int testIndices[] = {0, 70, 142};
    for (int i = 0; i < 3; ++i) {
      TS_ASSERT_DELTA(ws2d->dataX(0)[testIndices[i]], xs99631[i], tolerance);
      TS_ASSERT_DELTA(ws2d->dataY(0)[testIndices[i]], ys99631[i], tolerance);
      TS_ASSERT_DELTA(ws2d->dataE(0)[testIndices[i]], es99631[i], tolerance);
    }

    ws = Mantid::API::AnalysisDataService::Instance().retrieve(wNames[1]);
    ws2d = boost::dynamic_pointer_cast<Mantid::DataObjects::Workspace2D>(ws);
    TS_ASSERT(ws2d)

    run = ws2d->run();
    logP = run.getLogData("run_number");
    TS_ASSERT_EQUALS(logP->value(), "808")
    TS_ASSERT_EQUALS(run.getLogData("UserFile")->value(), "MASKSANS2D.091A");
    TS_ASSERT_EQUALS(ws2d->getInstrument()->getName(), "SANS2D")

    TS_ASSERT_EQUALS(ws2d->getNumberHistograms(), 1);
    TS_ASSERT_EQUALS(ws2d->dataX(0).size(), 23);

    // testing all workspace data, as there isn't much
    for (int i = 0; i < 23; ++i) {
      TS_ASSERT_DELTA(ws2d->dataX(0)[i], xs808[i], tolerance);
      TS_ASSERT_DELTA(ws2d->dataY(0)[i], ys808[i], tolerance);
      TS_ASSERT_DELTA(ws2d->dataE(0)[i], es808[i], tolerance);
    }
  }

private:
  std::string inputFile;
  Mantid::DataHandling::LoadCanSAS1D cansas1d;

  static const double xs99631[3], ys99631[3], es99631[3];
  static const double xs808[23], ys808[23], es808[23];
};
const double LoadCanSAS1dTest::xs99631[] = {0.0109, 0.151, 0.2949};
const double LoadCanSAS1dTest::ys99631[] = {5.44952, 0.15223, 0.14831};
const double LoadCanSAS1dTest::es99631[] = {0.0588457, 0.0043596, 0.335294};

const double LoadCanSAS1dTest::xs808[] = {
    0.646222, 0.659146, 0.672329, 0.685775, 0.699491, 0.713481,
    0.72775,  0.742305, 0.757152, 0.772295, 0.78774,  0.803495,
    0.819565, 0.835956, 0.852676, 0.869729, 0.887124, 0.904866,
    0.922963, 0.941423, 0.960251, 0.979456, 0.994577};
const double LoadCanSAS1dTest::ys808[] = {
    5.59202, 5.27307, 4.78682, 4.66635, 4.82897, 5.05591, 4.58635, 4.15975,
    4.01298, 4.1226,  4.04966, 3.90263, 3.4256,  3.29929, 3.17003, 2.67487,
    2.41979, 2.31446, 2.18734, 2.11788, 2.03716, 2.03615, 2.01552};
const double LoadCanSAS1dTest::es808[] = {
    0.219459,  0.203702,  0.186871,  0.178849,  0.172545,  0.17094,
    0.153269,  0.141219,  0.13289,   0.130725,  0.123281,  0.11705,
    0.104102,  0.0991949, 0.0933884, 0.082556,  0.0757769, 0.0715806,
    0.0674828, 0.064006,  0.0600373, 0.0581645, 0.0766164};

#endif