diff --git a/Code/Mantid/Framework/Algorithms/src/CropWorkspace.cpp b/Code/Mantid/Framework/Algorithms/src/CropWorkspace.cpp index 0164d827b14f..e081ecaa2a11 100644 --- a/Code/Mantid/Framework/Algorithms/src/CropWorkspace.cpp +++ b/Code/Mantid/Framework/Algorithms/src/CropWorkspace.cpp @@ -69,7 +69,7 @@ void CropWorkspace::init() { */ void CropWorkspace::exec() { - auto extract = createChildAlgorithm("ExtractSpectra"); + auto extract = createChildAlgorithm("ExtractSpectra", 0, 1); extract->initialize(); extract->setRethrows(true); diff --git a/Code/Mantid/Framework/Algorithms/src/ExtractSpectra.cpp b/Code/Mantid/Framework/Algorithms/src/ExtractSpectra.cpp index fff966bd36e8..af309ca25e4b 100644 --- a/Code/Mantid/Framework/Algorithms/src/ExtractSpectra.cpp +++ b/Code/Mantid/Framework/Algorithms/src/ExtractSpectra.cpp @@ -29,7 +29,7 @@ DECLARE_ALGORITHM(ExtractSpectra) /** Constructor */ ExtractSpectra::ExtractSpectra() - : Algorithm(), m_minX(0), m_maxX(0), //m_minSpec(-1), m_maxSpec(-1), + : Algorithm(), m_minX(0), m_maxX(0), m_commonBoundaries(false), m_histogram(false), m_croppingInX(false) {} //---------------------------------------------------------------------------------------------- diff --git a/Code/Mantid/Framework/Algorithms/src/RemoveMaskedSpectra.cpp b/Code/Mantid/Framework/Algorithms/src/RemoveMaskedSpectra.cpp index 69d38a164d2b..68df4d055a22 100644 --- a/Code/Mantid/Framework/Algorithms/src/RemoveMaskedSpectra.cpp +++ b/Code/Mantid/Framework/Algorithms/src/RemoveMaskedSpectra.cpp @@ -80,7 +80,7 @@ void RemoveMaskedSpectra::exec() { std::vector indices; makeIndexList(indices, maskedWorkspace.get()); - auto extract = createChildAlgorithm("ExtractSpectra"); + auto extract = createChildAlgorithm("ExtractSpectra", 0, 1); extract->initialize(); extract->setRethrows(true); @@ -114,7 +114,7 @@ void RemoveMaskedSpectra::makeIndexList( } catch (Exception::NotFoundError &) { continue; } - if (det->isMasked()) { + if (!det->isMasked()) { indices.push_back(static_cast(i)); } } diff --git a/Code/Mantid/Framework/Algorithms/test/ExtractSpectraTest.h b/Code/Mantid/Framework/Algorithms/test/ExtractSpectraTest.h index 7538808842b1..409067ec5cc8 100644 --- a/Code/Mantid/Framework/Algorithms/test/ExtractSpectraTest.h +++ b/Code/Mantid/Framework/Algorithms/test/ExtractSpectraTest.h @@ -4,9 +4,17 @@ #include #include "MantidAlgorithms/ExtractSpectra.h" +#include "MantidDataObjects/EventWorkspace.h" +#include "MantidKernel/EmptyValues.h" +#include "MantidKernel/UnitFactory.h" +#include "MantidTestHelpers/ComponentCreationHelper.h" +#include "MantidTestHelpers/WorkspaceCreationHelper.h" using Mantid::Algorithms::ExtractSpectra; using namespace Mantid::API; +using namespace Mantid::Kernel; +using namespace Mantid::DataObjects; +using namespace Mantid; class ExtractSpectraTest : public CxxTest::TestSuite { @@ -14,8 +22,14 @@ class ExtractSpectraTest : public CxxTest::TestSuite // This pair of boilerplate methods prevent the suite being created statically // This means the constructor isn't called when running other tests static ExtractSpectraTest *createSuite() { return new ExtractSpectraTest(); } - static void destroySuite( ExtractSpectraTest *suite ) { delete suite; } + static void destroySuite( ExtractSpectraTest *suite ) { + AnalysisDataService::Instance().clear(); + delete suite; + } + ExtractSpectraTest() + : nSpec(5), nBins(6), //inWSName("toCrop"), + outWSName("ExtractSpectraTest_OutputWS") {} void test_Init() { @@ -24,36 +38,382 @@ class ExtractSpectraTest : public CxxTest::TestSuite TS_ASSERT( alg.isInitialized() ) } - void test_exec() + void test_defaults() + { + Parameters params; + auto ws = runAlgorithm(params); + if (!ws) return; + TS_ASSERT_EQUALS(ws->getNumberHistograms(), nSpec); + TS_ASSERT_EQUALS(ws->blocksize(), nBins); + + TS_ASSERT_EQUALS(ws->readX(0)[0], 0.0); + TS_ASSERT_EQUALS(ws->readX(0)[1], 1.0); + TS_ASSERT_EQUALS(ws->readX(0)[2], 2.0); + TS_ASSERT_EQUALS(ws->readX(0)[3], 3.0); + TS_ASSERT_EQUALS(ws->readX(0)[4], 4.0); + TS_ASSERT_EQUALS(ws->readX(0)[5], 5.0); + TS_ASSERT_EQUALS(ws->readX(0)[6], 6.0); + } + + // ---- test histo ---- + + void test_x_range() + { + Parameters params; + params.setXRange(); + + auto ws = runAlgorithm(params); + if (!ws) return; + + TS_ASSERT_EQUALS(ws->getNumberHistograms(), nSpec); + params.testXRange("test_x_range",*ws); + } + + void test_index_range() { - // Name of the output workspace. - std::string outWSName("ExtractSpectraTest_OutputWS"); + Parameters params; + params.setIndexRange(); + + auto ws = runAlgorithm(params); + if (!ws) return; + + TS_ASSERT_EQUALS(ws->blocksize(), nBins); + params.testIndexRange("test_index_range",*ws); + } + + void test_spectrum_list() + { + Parameters params; + params.setSpectrumList(); + + auto ws = runAlgorithm(params); + if (!ws) return; + + TS_ASSERT_EQUALS(ws->blocksize(), nBins); + params.testSpectrumList("test_spectrum_list",*ws); + } + + void test_index_and_spectrum_list() + { + Parameters params; + params.setSpectrumList().setIndexRange(); + + auto ws = runAlgorithm(params); + if (!ws) return; + TS_ASSERT_EQUALS(ws->blocksize(), nBins); + params.testSpectrumList("test_spectrum_list",*ws); + } + + void test_x_range_and_spectrum_list() + { + Parameters params; + params.setSpectrumList().setXRange(); + + auto ws = runAlgorithm(params); + if (!ws) return; + + params.testXRange("test_x_range_and_spectrum_list",*ws); + params.testSpectrumList("test_x_range_and_spectrum_list",*ws); + } + + void test_invalid_x_range() + { + Parameters params; + params.setInvalidXRange(); + + auto ws = runAlgorithm(params, false); + } + + void test_invalid_index_range() + { + { + Parameters params; + params.setInvalidIndexRange(); + auto ws = runAlgorithm(params, false); + } + { + Parameters params; + params.setInvalidIndexRange1(); + auto ws = runAlgorithm(params, false); + } + } + + + // ---- test event ---- + + void test_x_range_event() + { + Parameters params("event"); + params.setXRange(); + + auto ws = runAlgorithm(params); + if (!ws) return; + + TS_ASSERT_EQUALS(ws->getNumberHistograms(), nSpec); + params.testXRange("test_x_range_event",*ws); + } + + void test_index_range_event() + { + Parameters params("event"); + params.setIndexRange(); + + auto ws = runAlgorithm(params); + if (!ws) return; + + TS_ASSERT_EQUALS(ws->blocksize(), nBins); + params.testIndexRange("test_index_range_event",*ws); + } + + void test_spectrum_list_event() + { + Parameters params("event"); + params.setSpectrumList(); + + auto ws = runAlgorithm(params); + if (!ws) return; + + TS_ASSERT_EQUALS(ws->blocksize(), nBins); + params.testSpectrumList("test_spectrum_list_event",*ws); + } + + void test_index_and_spectrum_list_event() + { + Parameters params("event"); + params.setSpectrumList().setIndexRange(); + + auto ws = runAlgorithm(params); + if (!ws) return; + + TS_ASSERT_EQUALS(ws->blocksize(), nBins); + params.testSpectrumList("test_spectrum_list_event",*ws); + } + + void test_x_range_and_spectrum_list_event() + { + Parameters params("event"); + params.setSpectrumList().setXRange(); + + auto ws = runAlgorithm(params); + if (!ws) return; + + params.testXRange("test_x_range_and_spectrum_list_event",*ws); + params.testSpectrumList("test_x_range_and_spectrum_list_event",*ws); + } + + void test_invalid_x_range_event() + { + Parameters params("event"); + params.setInvalidXRange(); + auto ws = runAlgorithm(params, true); + // this is a bit unexpected but at least no crash + TS_ASSERT_EQUALS(ws->getNumberHistograms(), nSpec); + TS_ASSERT_EQUALS(ws->blocksize(), 1); + TS_ASSERT_EQUALS(ws->readX(0)[0], 2); + TS_ASSERT_EQUALS(ws->readX(0)[1], 1); + } + + void test_invalid_index_range_event() + { + { + Parameters params("event"); + params.setInvalidIndexRange(); + auto ws = runAlgorithm(params, false); + } + { + Parameters params("event"); + params.setInvalidIndexRange1(); + auto ws = runAlgorithm(params, false); + } + } + +private: + + // ----------------------- helper methods ------------------------ + + const size_t nSpec; + const size_t nBins; + const std::string outWSName; + + MatrixWorkspace_sptr createInputWorkspace(const std::string& workspaceType) const + { + if (workspaceType == "histo") + return createInputWorkspaceHisto(); + else if (workspaceType == "event") + return createInputWorkspaceEvent(); + throw std::runtime_error("Undefined workspace type"); + } + + MatrixWorkspace_sptr createInputWorkspaceHisto() const + { + // Set up a small workspace for testing + MatrixWorkspace_sptr space = WorkspaceFactory::Instance().create("Workspace2D", nSpec, nBins+1, nBins); + for (size_t j = 0; j < nSpec; ++j) { + for (size_t k = 0; k <= nBins; ++k) { + space->dataX(j)[k] = double(k); + } + space->dataY(j).assign(nBins, double(j)); + space->dataE(j).assign(nBins, sqrt(double(j))); + } + return space; + } + + MatrixWorkspace_sptr createInputWorkspaceEvent() const + { + EventWorkspace_sptr ws = WorkspaceCreationHelper::CreateEventWorkspace(int(nSpec), int(nBins), 50, 0.0, 1., 2); + ws->getAxis(0)->unit() = UnitFactory::Instance().create("TOF"); + ws->setInstrument( ComponentCreationHelper::createTestInstrumentCylindrical(1) ); + for(size_t i = 0; i < ws->getNumberHistograms(); ++i) + { + ws->getSpectrum(i)->setDetectorID(detid_t(i + 1)); + } + return ws; + } + + struct Parameters + { + Parameters(const std::string& workspaceType = "histo") + : XMin(EMPTY_DBL()), XMax(EMPTY_DBL()), StartWorkspaceIndex(0), + EndWorkspaceIndex(EMPTY_INT()), SpectrumList(), wsType(workspaceType) + { + } + double XMin; + double XMax; + int StartWorkspaceIndex; + int EndWorkspaceIndex; + std::vector SpectrumList; + std::string wsType; + + // ---- x range ---- + Parameters& setXRange() + { + XMin = 2.0; + XMax = 3.1; + return *this; + } + void testXRange(const std::string& reference, const MatrixWorkspace& ws) const + { + TSM_ASSERT_EQUALS(reference, ws.blocksize(), 1); + TSM_ASSERT_EQUALS(reference, ws.readX(0)[0], 2.0); + } + + // ---- index range ---- + Parameters& setIndexRange() + { + StartWorkspaceIndex = 1; + EndWorkspaceIndex = 3; + return *this; + } + void testIndexRange(const std::string& reference, const MatrixWorkspace& ws) const + { + TSM_ASSERT_EQUALS(reference, ws.getNumberHistograms(), 3); + if (wsType == "histo") + { + TSM_ASSERT_EQUALS(reference, ws.readY(0)[0], 1.0); + TSM_ASSERT_EQUALS(reference, ws.readY(1)[0], 2.0); + TSM_ASSERT_EQUALS(reference, ws.readY(2)[0], 3.0); + } + else if (wsType == "event") + { + TSM_ASSERT_EQUALS(reference, ws.getDetector(0)->getID(), 2); + TSM_ASSERT_EQUALS(reference, ws.getDetector(1)->getID(), 3); + TSM_ASSERT_EQUALS(reference, ws.getDetector(2)->getID(), 4); + } + } + + // ---- spectrum list ---- + Parameters& setSpectrumList() + { + SpectrumList.resize(3); + SpectrumList[0] = 0; + SpectrumList[1] = 2; + SpectrumList[2] = 4; + return *this; + } + void testSpectrumList(const std::string& reference, const MatrixWorkspace& ws) const + { + TSM_ASSERT_EQUALS(reference, ws.getNumberHistograms(), 3); + if (wsType == "histo") + { + TSM_ASSERT_EQUALS(reference, ws.readY(0)[0], 0.0); + TSM_ASSERT_EQUALS(reference, ws.readY(1)[0], 2.0); + TSM_ASSERT_EQUALS(reference, ws.readY(2)[0], 4.0); + } + else if (wsType == "event") + { + TSM_ASSERT_EQUALS(reference, ws.getDetector(0)->getID(), 1); + TSM_ASSERT_EQUALS(reference, ws.getDetector(1)->getID(), 3); + TSM_ASSERT_EQUALS(reference, ws.getDetector(2)->getID(), 5); + } + } + + // ---- invalid inputs ---- + void setInvalidXRange() + { + XMin = 2.0; + XMax = 1.0; + } + void setInvalidIndexRange() + { + StartWorkspaceIndex = 3; + EndWorkspaceIndex = 1; + } + void setInvalidIndexRange1() + { + StartWorkspaceIndex = 1000; + EndWorkspaceIndex = 1002; + } + }; + + MatrixWorkspace_sptr runAlgorithm(const Parameters& params, bool expectSuccess = true) const + { + auto ws = createInputWorkspace(params.wsType); ExtractSpectra alg; TS_ASSERT_THROWS_NOTHING( alg.initialize() ) TS_ASSERT( alg.isInitialized() ) - TS_ASSERT_THROWS_NOTHING( alg.setPropertyValue("REPLACE_PROPERTY_NAME_HERE!!!!", "value") ); + TS_ASSERT_THROWS_NOTHING( alg.setProperty("InputWorkspace", ws) ); TS_ASSERT_THROWS_NOTHING( alg.setPropertyValue("OutputWorkspace", outWSName) ); + + if (params.XMin != EMPTY_DBL()) + { + TS_ASSERT_THROWS_NOTHING( alg.setProperty("XMin", params.XMin) ); + } + if (params.XMax != EMPTY_DBL()) + { + TS_ASSERT_THROWS_NOTHING( alg.setProperty("XMax", params.XMax) ); + } + if (params.StartWorkspaceIndex != 0) + { + TS_ASSERT_THROWS_NOTHING( alg.setProperty("StartWorkspaceIndex", params.StartWorkspaceIndex) ); + } + if (params.EndWorkspaceIndex != EMPTY_INT()) + { + TS_ASSERT_THROWS_NOTHING( alg.setProperty("EndWorkspaceIndex", params.EndWorkspaceIndex) ); + } + if (!params.SpectrumList.empty()) + { + TS_ASSERT_THROWS_NOTHING( alg.setProperty("SpectrumList", params.SpectrumList) ); + } + TS_ASSERT_THROWS_NOTHING( alg.execute(); ); - TS_ASSERT( alg.isExecuted() ); - // Retrieve the workspace from data service. TODO: Change to your desired type - Workspace_sptr ws; - TS_ASSERT_THROWS_NOTHING( ws = AnalysisDataService::Instance().retrieveWS(outWSName) ); - TS_ASSERT(ws); - if (!ws) return; + if (expectSuccess) + { + TS_ASSERT( alg.isExecuted() ); - // TODO: Check the results + // Retrieve the workspace from data service. TODO: Change to your desired type + MatrixWorkspace_sptr ws; + TS_ASSERT_THROWS_NOTHING( ws = AnalysisDataService::Instance().retrieveWS(outWSName) ); + return ws; + } + else + { + TS_ASSERT( !alg.isExecuted() ); + } - // Remove workspace from the data service. - AnalysisDataService::Instance().remove(outWSName); + return MatrixWorkspace_sptr(); } - - void test_Something() - { - TSM_ASSERT( "You forgot to write a test!", 0); - } - };