diff --git a/Framework/Algorithms/CMakeLists.txt b/Framework/Algorithms/CMakeLists.txt
index ec251747d76bdfe336d120059eeed86f3663ceee..0b5acd6d29d89a4a6312c48bbd3b1a40963daa4f 100644
--- a/Framework/Algorithms/CMakeLists.txt
+++ b/Framework/Algorithms/CMakeLists.txt
@@ -930,6 +930,7 @@ set ( TEST_FILES
SofQWTest.h
SolidAngleTest.h
SortEventsTest.h
+ SortXAxisTest.h
SparseInstrumentTest.h
SpatialGroupingTest.h
SpecularReflectionCalculateTheta2Test.h
diff --git a/Framework/Algorithms/src/SortXAxis.cpp b/Framework/Algorithms/src/SortXAxis.cpp
index 37d1c87d8e39e6a7163af0ade20790b4280286ec..e73edc34f8abef4525d1e905b486023992def6e6 100644
--- a/Framework/Algorithms/src/SortXAxis.cpp
+++ b/Framework/Algorithms/src/SortXAxis.cpp
@@ -5,9 +5,13 @@
#include "MantidKernel/ListValidator.h"
#include "MantidKernel/System.h"
#include "MantidKernel/make_unique.h"
-
-using namespace Mantid::Kernel;
+#include "MantidHistogramData/Histogram.h"
+using namespace Mantid;
using namespace Mantid::API;
+using namespace Mantid::Kernel;
+using namespace Mantid::Algorithms;
+using namespace Mantid::DataObjects;
+using namespace Mantid::HistogramData;
namespace Mantid {
namespace Algorithms {
diff --git a/Framework/Algorithms/test/SortXAxisTest.h b/Framework/Algorithms/test/SortXAxisTest.h
index 82aa4d497eddeba8448d34c2cb4c1adb9353f801..b2cca61903830038e3dda3c341ca84782e53a520 100644
--- a/Framework/Algorithms/test/SortXAxisTest.h
+++ b/Framework/Algorithms/test/SortXAxisTest.h
@@ -1,31 +1,115 @@
#ifndef MANTID_ALGORITHMS_SORTXAXISTEST_H_
#define MANTID_ALGORITHMS_SORTXAXISTEST_H_
+#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAlgorithms/SortXAxis.h"
-#include "MantidKernel/Workspace.h"
+#include "MantidDataObjects/Workspace2D.h"
+#include "MantidDataObjects/WorkspaceCreation.h"
+#include "MantidHistogramData/Histogram.h"
#include <cxxtest/TestSuite.h>
+using namespace Mantid;
+using namespace Mantid::API;
+using namespace Mantid::Kernel;
+using namespace Mantid::Algorithms;
+using namespace Mantid::DataObjects;
+using namespace Mantid::HistogramData;
+
namespace {
-MatrixWorkspace_sptr createWorkspace(const HistogramX &xData,
- const HistogramY &yData,
- const HistogramE &eData,
- const int nSpec = 1) {
+MatrixWorkspace_sptr createWorkspaceE(const std::vector<double> xData,
+ const std::vector<double> yData,
+ const std::vector<double> eData,
+ const int nSpec = 1) {
+
+ Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+ nSpec, Mantid::HistogramData::Histogram(
+ Mantid::HistogramData::Points(xData.size())));
+ for (int i = 0; i < nSpec; ++i) {
+ outputWorkspace->mutableY(i) = yData;
+ outputWorkspace->mutableE(i) = eData;
+ outputWorkspace->mutableX(i) = xData;
+ }
+ return outputWorkspace;
+}
+
+MatrixWorkspace_sptr createHistoWorkspaceE(const std::vector<double> xData,
+ const std::vector<double> yData,
+ const std::vector<double> eData,
+ const int nSpec = 1) {
- Workspace2D_sptr outWS = boost::make_shared<Workspace2D>();
- outWS->initialize(nSpec, xData.size(), yData.size());
+ Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+ nSpec, Mantid::HistogramData::Histogram(
+ Mantid::HistogramData::BinEdges(xData.size())));
for (int i = 0; i < nSpec; ++i) {
- outWS->mutableY(i) = yData;
- outWS->mutableE(i) = eData;
- outWS->mutableX(i) = xData;
+ outputWorkspace->mutableY(i) = yData;
+ outputWorkspace->mutableE(i) = eData;
+ outputWorkspace->mutableX(i) = xData;
}
+ return outputWorkspace;
+}
+
+MatrixWorkspace_sptr createWorkspaceDx(const std::vector<double> xData,
+ const std::vector<double> yData,
+ const std::vector<double> dxData,
+ const int nSpec = 1) {
+
+ Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+ nSpec, Mantid::HistogramData::Histogram(
+ Mantid::HistogramData::Points(xData.size())));
+ for (int i = 0; i < nSpec; ++i) {
+ outputWorkspace->mutableY(i) = yData;
+ outputWorkspace->mutableX(i) = xData;
+ outputWorkspace->setPointStandardDeviations(i, dxData);
+ }
+ return outputWorkspace;
+}
+
+MatrixWorkspace_sptr createHistoWorkspaceDx(const std::vector<double> xData,
+ const std::vector<double> yData,
+ const std::vector<double> dxData,
+ const int nSpec = 1) {
+
+ Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+ nSpec, Mantid::HistogramData::Histogram(
+ Mantid::HistogramData::BinEdges(xData.size())));
+ for (int i = 0; i < nSpec; ++i) {
+ outputWorkspace->mutableY(i) = yData;
+ outputWorkspace->mutableX(i) = xData;
+ outputWorkspace->setPointStandardDeviations(i, dxData);
+ }
+ return outputWorkspace;
+}
+
+MatrixWorkspace_sptr createHistoWorkspace(const std::vector<double> xData,
+ const std::vector<double> yData,
+ const int nSpec = 1) {
+
+ Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+ nSpec, Mantid::HistogramData::Histogram(
+ Mantid::HistogramData::BinEdges(xData.size())));
+ for (int i = 0; i < nSpec; ++i) {
+ outputWorkspace->mutableY(i) = yData;
+ outputWorkspace->mutableX(i) = xData;
+ }
+ return outputWorkspace;
+}
+
+bool operator==(const std::vector<double> &lhs, const HistogramX &rhs) {
+ return lhs == rhs.rawData();
+}
- outWS->getAxis(0)->unit() = UnitFactory::Instance().create("Wavelength");
+bool operator==(const std::vector<double> &lhs, const HistogramY &rhs) {
+ return lhs == rhs.rawData();
+}
- return outWS;
+bool operator==(const std::vector<double> &lhs, const HistogramDx &rhs) {
+ return lhs == rhs.rawData();
}
+} // namespace
class SortXAxisTest : 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 SortXAxisTest *createSuite() { return new SortXAxisTest(); }
@@ -36,30 +120,259 @@ class SortXAxisTest : public CxxTest::TestSuite {
std::vector<double> yData = {1, 2, 3};
std::vector<double> eData = {1, 2, 3};
- MatrixWorkspace_sptr unsortedws = createWorkspace(xData, yData, eData);
+ MatrixWorkspace_sptr unsortedws = createWorkspaceE(xData, yData, eData);
SortXAxis alg;
- alg.setProperty("InputWorkspacd", "unsortedws");
- alg.setProperty("OutputWorkspace", "sortedws");
- alg.execute();
- MatrixWorkspace_sptr sortedws =
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->x(0), xData);
+ TS_ASSERT_EQUALS(sortedws->y(0), yData);
+ TS_ASSERT_EQUALS(sortedws->e(0), eData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
}
- void testXDescending() {}
+ void testXDescending() {
+ std::vector<double> xData = {3, 2, 1};
+ std::vector<double> sortedXData = {1, 2, 3};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> reverseYData = {3, 2, 1};
+ std::vector<double> eData = {1, 2, 3};
+ std::vector<double> reverseEData = {3, 2, 1};
- void testOnMultipleSpectrum() {}
+ MatrixWorkspace_sptr unsortedws = createWorkspaceE(xData, yData, eData);
- void testSortsXHistogramAscending() {}
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
- void testSortsXHistogramDescending() {}
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
- void testSortXWorksChild() {}
+ TS_ASSERT_EQUALS(sortedws->x(0), sortedXData);
+ TS_ASSERT_EQUALS(sortedws->y(0), reverseYData);
+ TS_ASSERT_EQUALS(sortedws->e(0), reverseEData);
- void testDxMultipleSpectrum() {}
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
- void testDxHistogramAscending() {}
+ void testOnMultipleSpectrum() {
+ std::vector<double> xData = {3, 2, 1};
+ std::vector<double> sortedXData = {1, 2, 3};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> reverseYData = {3, 2, 1};
+ std::vector<double> eData = {1, 2, 3};
+ std::vector<double> reverseEData = {3, 2, 1};
- void testSortDescending() {}
-};
+ MatrixWorkspace_sptr unsortedws = createWorkspaceE(xData, yData, eData, 2);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->x(0), sortedXData);
+ TS_ASSERT_EQUALS(sortedws->y(0), reverseYData);
+ TS_ASSERT_EQUALS(sortedws->e(0), reverseEData);
+
+ TS_ASSERT_EQUALS(sortedws->x(1), sortedXData);
+ TS_ASSERT_EQUALS(sortedws->y(1), reverseYData);
+ TS_ASSERT_EQUALS(sortedws->e(1), reverseEData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testSortsXHistogramAscending() {
+ std::vector<double> xData = {1, 2, 3, 4};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> eData = {1, 2, 3};
+
+ MatrixWorkspace_sptr unsortedws =
+ createHistoWorkspaceE(xData, yData, eData);
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->x(0), xData);
+ TS_ASSERT_EQUALS(sortedws->y(0), yData);
+ TS_ASSERT_EQUALS(sortedws->e(0), eData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testSortsXHistogramDescending() {
+ std::vector<double> xData = {4, 3, 2, 1};
+ std::vector<double> sortedXData = {1, 2, 3, 4};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> reverseYData = {3, 2, 1};
+ std::vector<double> eData = {1, 2, 3};
+ std::vector<double> reverseEData = {3, 2, 1};
+
+ MatrixWorkspace_sptr unsortedws =
+ createHistoWorkspaceE(xData, yData, eData);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->x(0), sortedXData);
+ TS_ASSERT_EQUALS(sortedws->y(0), reverseYData);
+ TS_ASSERT_EQUALS(sortedws->e(0), reverseEData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testDxMultipleSpectrum() {
+ std::vector<double> xData = {3, 2, 1};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> dxData = {1, 2, 3};
+ std::vector<double> reverseDxData = {3, 2, 1};
+
+ MatrixWorkspace_sptr unsortedws =
+ createWorkspaceDx(xData, yData, dxData, 2);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->dx(0), reverseDxData);
+ TS_ASSERT_EQUALS(sortedws->dx(1), reverseDxData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testDxHistogramAscending() {
+ std::vector<double> xData = {1, 2, 3, 4};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> dxData = {1, 2, 3};
+ std::vector<double> reverseDxData = {3, 2, 1};
+
+ MatrixWorkspace_sptr unsortedws =
+ createHistoWorkspaceDx(xData, yData, dxData, 2);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ HistogramDx wsDxData = sortedws->dx(0);
+
+ TS_ASSERT_EQUALS(reverseDxData, wsDxData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testSortDescending() {
+ std::vector<double> xData = {1, 2, 3, 4};
+ std::vector<double> reverseXData = {4, 3, 2, 1};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> reverseYData = {3, 2, 1};
+
+ MatrixWorkspace_sptr unsortedws = createHistoWorkspace(xData, yData, 2);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("Ordering", "Descending"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(reverseXData, sortedws->x(0));
+ TS_ASSERT_EQUALS(reverseYData, sortedws->y(0));
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+}
+};
#endif /*MANTID_ALGORITHMS_SORTXAXISTEST_H_*/
diff --git a/Framework/HistogramData/inc/MantidHistogramData/HistogramDx.h b/Framework/HistogramData/inc/MantidHistogramData/HistogramDx.h
index c907569b6cbab43d3f4c8024f0a212f1de636ae2..ca8fbf409a6e13a908a1eba942c29287c7b4f46f 100644
--- a/Framework/HistogramData/inc/MantidHistogramData/HistogramDx.h
+++ b/Framework/HistogramData/inc/MantidHistogramData/HistogramDx.h
@@ -50,7 +50,9 @@ public:
HistogramDx(HistogramDx &&) = default;
HistogramDx &operator=(const HistogramDx &) & = default;
HistogramDx &operator=(HistogramDx &&) & = default;
-
+ bool operator==(const HistogramDx &rhs) const {
+ return this->rawData() == rhs.rawData();
+ }
// These classes are friends, such that they can modify the length.
friend class Histogram;
friend class detail::VectorOf<PointVariances, HistogramDx>;
diff --git a/Framework/HistogramData/inc/MantidHistogramData/HistogramE.h b/Framework/HistogramData/inc/MantidHistogramData/HistogramE.h
index 74728cc922d3e704254f3ede9a117102d9a2afa4..e8aa08a324a2155073693db64528f261fbe1d4c3 100644
--- a/Framework/HistogramData/inc/MantidHistogramData/HistogramE.h
+++ b/Framework/HistogramData/inc/MantidHistogramData/HistogramE.h
@@ -66,7 +66,9 @@ public:
HistogramE(HistogramE &&) = default;
HistogramE &operator=(const HistogramE &) & = default;
HistogramE &operator=(HistogramE &&) & = default;
-
+ bool operator==(const HistogramE &rhs) const {
+ return this->rawData() == rhs.rawData();
+ }
// These classes are friends, such that they can modify the length.
friend class Histogram;
friend class detail::VectorOf<CountStandardDeviations, HistogramE>;
diff --git a/Framework/HistogramData/inc/MantidHistogramData/HistogramX.h b/Framework/HistogramData/inc/MantidHistogramData/HistogramX.h
index 7006427eb5960c90361dd76ea62c7311af065ca2..f7038621d1eb53ac7c0c000d1d4494aa03728653 100644
--- a/Framework/HistogramData/inc/MantidHistogramData/HistogramX.h
+++ b/Framework/HistogramData/inc/MantidHistogramData/HistogramX.h
@@ -62,7 +62,9 @@ public:
HistogramX(HistogramX &&) = default;
HistogramX &operator=(const HistogramX &) & = default;
HistogramX &operator=(HistogramX &&) & = default;
-
+ bool operator==(const HistogramX &rhs) const {
+ return this->rawData() == rhs.rawData();
+ }
// These classes are friends, such that they can modify the length.
friend class Histogram;
friend class detail::VectorOf<BinEdges, HistogramX>;
diff --git a/Framework/HistogramData/inc/MantidHistogramData/HistogramY.h b/Framework/HistogramData/inc/MantidHistogramData/HistogramY.h
index 5ae2b1c45826565f31033f464cf0a63d708f5f2d..3bff7a11a16cd93e9bbfab6f9c6c9ac782fed99a 100644
--- a/Framework/HistogramData/inc/MantidHistogramData/HistogramY.h
+++ b/Framework/HistogramData/inc/MantidHistogramData/HistogramY.h
@@ -64,6 +64,9 @@ public:
HistogramY(HistogramY &&) = default;
HistogramY &operator=(const HistogramY &) & = default;
HistogramY &operator=(HistogramY &&) & = default;
+ bool operator==(const HistogramY &rhs) const {
+ return this->rawData() == rhs.rawData();
+ }
// Multiple inheritance causes ambiguous overload, bring operators into scope.
using detail::Addable<HistogramY>::operator+;
using detail::Addable<HistogramY>::operator+=;
diff --git a/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt b/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt
index 2aa190d32ad242014581c093468d62cef0510403..ac9d9fe1b60b1651850d8121dfefe195460e59ef 100644
--- a/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt
+++ b/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt
@@ -84,7 +84,6 @@ set ( TEST_PY_FILES
SetDetScaleTest.py
SortByQVectorsTest.py
SortDetectorsTest.py
- SortXAxisTest.py
StatisticsOfTableWorkspaceTest.py
StringToPngTest.py
SuggestTibCNCSTest.py
diff --git a/Framework/PythonInterface/test/python/plugins/algorithms/SortXAxisTest.py b/Framework/PythonInterface/test/python/plugins/algorithms/SortXAxisTest.py
deleted file mode 100644
index 9b43e770f953ed20e7eaef4600dd635f58969ac8..0000000000000000000000000000000000000000
--- a/Framework/PythonInterface/test/python/plugins/algorithms/SortXAxisTest.py
+++ /dev/null
@@ -1,183 +0,0 @@
-from __future__ import (absolute_import, division, print_function)
-
-import unittest
-from mantid.simpleapi import AlgorithmManager, CreateWorkspace, DeleteWorkspace, SortXAxis
-
-
-class SortXAxisTest(unittest.TestCase):
-
-
- def test_x_ascending(self):
- dataX = [1., 2., 3.] # In ascending order, so y and e will need to be reversed.
- dataY = [1., 2., 3.]
- dataE = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=True)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- # Check the resulting data values. Sorting operation should have resulted in no changes
- self.assertEqual(dataX, sortedX.tolist())
- self.assertEqual(dataY, sortedY.tolist())
- self.assertEqual(dataE, sortedE.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_x_descending(self):
- dataX = [3., 2., 1.] # In descending order, so y and e will need to be reversed.
- dataY = [1., 2., 3.]
- dataE = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=True)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- # Check the resulting data values.
- self.assertEqual(sorted(dataX), sortedX.tolist())
- dataY.reverse()
- dataE.reverse()
- self.assertEqual(dataY, sortedY.tolist())
- self.assertEqual(dataE, sortedE.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_on_multiple_spectrum(self):
- dataX = [3., 2., 1., 3., 2., 1.] # In descending order, so y and e will need to be reversed.
- dataY = [1., 2., 3., 1., 2., 3.]
- dataE = [1., 2., 3., 1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=True, NSpec=2)
- dataY.reverse()
- dataE.reverse()
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- # Check the resulting data values for 1st spectrum.
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- self.assertEqual(sorted(dataX[0:3]), sortedX.tolist())
- self.assertEqual(dataY[0:3], sortedY.tolist())
- self.assertEqual(dataE[0:3], sortedE.tolist())
- # Check the resulting data values for 2nd spectrum.
- sortedX = sortedws.readX(1)
- sortedY = sortedws.readY(1)
- sortedE = sortedws.readE(1)
- self.assertEqual(sorted(dataX[3:]), sortedX.tolist())
- self.assertEqual(dataY[3:], sortedY.tolist())
- self.assertEqual(dataE[3:], sortedE.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_sorts_x_histogram_ascending(self):
- dataX = [1., 2., 3., 4.]
- dataY = [1., 2., 3.]
- dataE = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=False)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- # Check the resulting data values. Sorting operation should have resulted in no changes
- self.assertEqual(dataX, sortedX.tolist())
- self.assertEqual(dataY, sortedY.tolist())
- self.assertEqual(dataE, sortedE.tolist())
-
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_sorts_x_histogram_descending(self):
- dataX = [4., 3., 2., 1.]
- dataY = [1., 2., 3.]
- dataE = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=False)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- # Check the resulting data values. Sorting operation should have resulted in no changes
- self.assertEqual(sorted(dataX), sortedX.tolist())
- dataY.reverse()
- dataE.reverse()
- self.assertEqual(dataY, sortedY.tolist())
- self.assertEqual(dataE, sortedE.tolist())
-
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_sort_x_works_child(self):
- # Create unsorted workspace
- parent = AlgorithmManager.createUnmanaged('Load')
- create_ws_alg = parent.createChildAlgorithm("CreateWorkspace")
- dataX = [4., 3., 2., 1.]
- dataY = [1., 2., 3.]
- dataE = [1., 2., 3.]
- create_ws_alg.setProperty("DataX", dataX)
- create_ws_alg.setProperty("DataY", dataY)
- create_ws_alg.setProperty("DataE", dataE)
- create_ws_alg.setProperty("UnitX",'TOF')
- create_ws_alg.setProperty("Distribution", False)
- create_ws_alg.execute()
- # Run the algorithm
- sort_alg = parent.createChildAlgorithm("SortXAxis")
- sort_alg.setProperty("InputWorkspace", create_ws_alg.getProperty("OutputWorkspace").value)
- sort_alg.execute()
- # Check the resulting data values. Sorting operation should have resulted in no changes
- sortedws = sort_alg.getProperty("OutputWorkspace").value
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- self.assertEqual(sorted(dataX), sortedX.tolist())
- dataY.reverse()
- dataE.reverse()
- self.assertEqual(dataY, sortedY.tolist())
- self.assertEqual(dataE, sortedE.tolist())
-
- def test_dx_multiple_spectrum(self):
- dataX = [3, 2, 1, 3, 2, 1] # In descending order, so y and e will need to be reversed.
- dataY = [1, 2, 3, 1, 2, 3]
- dx = [1, 2, 3, 1, 2, 3]
- unsortedws = CreateWorkspace(DataX=dataX, DataY=dataY, Dx=dx, UnitX='TOF', Distribution=True, NSpec=2)
- dx.reverse()
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- # Check the resulting data values for 1st spectrum.
- sortedDx = sortedws.readDx(0)
- self.assertEqual(dx[0:3], sortedDx.tolist())
- # Check the resulting data values for 2nd spectrum.
- sortedDx = sortedws.readDx(1)
- self.assertEqual(dx[3:], sortedDx.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_dx_histogram_ascending(self):
- dataX = [1., 2., 3., 4.]
- dataY = [1., 2., 3.]
- dx = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX, DataY=dataY, Dx=dx, UnitX='TOF', Distribution=False)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- sortedDx = sortedws.readDx(0)
- # Check the resulting data values. Sorting operation should have resulted in no changes
- self.assertEqual(dx, sortedDx.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_sort_descending(self):
- dataX = [1., 2., 3., 4.]
- dataY = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX, DataY=dataY, UnitX='TOF', Distribution=False)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws, Ordering="Descending")
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- # Check the resulting data values. Sorting operation should have resulted in no changes
- self.assertEqual([4., 3., 2., 1.], sortedX.tolist())
- self.assertEqual([3., 2., 1.], sortedY.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
-if __name__ == '__main__':
- unittest.main()