diff --git a/Framework/Algorithms/CMakeLists.txt b/Framework/Algorithms/CMakeLists.txt
index 2391cf3569c3a54b7c3b2f40dacedd3fd8d129d2..8cdd4b52b1ef959fdef511f1c4016313479073e8 100644
--- a/Framework/Algorithms/CMakeLists.txt
+++ b/Framework/Algorithms/CMakeLists.txt
@@ -836,6 +836,7 @@ set ( TEST_FILES
RectangularBeamProfileTest.h
ReflectometryReductionOneAutoTest.h
ReflectometryReductionOneTest.h
+ ReflectometryReductionOne2Test.h
RegroupTest.h
RemoveBackgroundTest.h
RemoveBinsTest.h
diff --git a/Framework/Algorithms/src/ReflectometryReductionOne2.cpp b/Framework/Algorithms/src/ReflectometryReductionOne2.cpp
index 4ce3203402660a124dbddbfba8d176b9ab781484..97a36d3ee336942fdb3b8049b6f3a361b03cc8ed 100644
--- a/Framework/Algorithms/src/ReflectometryReductionOne2.cpp
+++ b/Framework/Algorithms/src/ReflectometryReductionOne2.cpp
@@ -427,7 +427,7 @@ ReflectometryReductionOne2::convertToWavelength(MatrixWorkspace_sptr inputWS) {
MatrixWorkspace_sptr ReflectometryReductionOne2::makeDetectorWS(
MatrixWorkspace_sptr inputWS) {
- std::string processingCommands = getProperty("ProcessingInstructions");
+ std::string processingCommands = getPropertyValue("ProcessingInstructions");
auto groupAlg = this->createChildAlgorithm("GroupDetectors");
groupAlg->initialize();
groupAlg->setProperty("GroupingPattern", processingCommands);
@@ -445,7 +445,6 @@ MatrixWorkspace_sptr ReflectometryReductionOne2::makeDetectorWS(
processingCommands = std::to_string(directBeamRegion[0]) + "-" +
std::to_string(directBeamRegion[1]);
- processingCommands = getProperty("ProcessingInstructions");
auto groupDirectBeamAlg = this->createChildAlgorithm("GroupDetectors");
groupDirectBeamAlg->initialize();
groupDirectBeamAlg->setProperty("GroupingPattern", processingCommands);
@@ -682,4 +681,4 @@ ReflectometryReductionOne2::convertToQ(MatrixWorkspace_sptr inputWS) {
}
} // namespace Algorithms
-} // namespace Mantid
\ No newline at end of file
+} // namespace Mantid
diff --git a/Framework/Algorithms/test/ReflectometryReductionOne2Test.h b/Framework/Algorithms/test/ReflectometryReductionOne2Test.h
new file mode 100644
index 0000000000000000000000000000000000000000..812009165c9acde55039410d680088a3915b1d4c
--- /dev/null
+++ b/Framework/Algorithms/test/ReflectometryReductionOne2Test.h
@@ -0,0 +1,488 @@
+#ifndef ALGORITHMS_TEST_REFLECTOMETRYREDUCTIONONE2TEST_H_
+#define ALGORITHMS_TEST_REFLECTOMETRYREDUCTIONONE2TEST_H_
+
+#include <cxxtest/TestSuite.h>
+#include "MantidAlgorithms/ReflectometryReductionOne2.h"
+#include "MantidAPI/AlgorithmManager.h"
+#include "MantidAPI/Axis.h"
+#include "MantidAPI/FrameworkManager.h"
+#include "MantidAPI/MatrixWorkspace.h"
+#include "MantidHistogramData/HistogramY.h"
+#include "MantidTestHelpers/WorkspaceCreationHelper.h"
+#include <algorithm>
+
+using namespace Mantid::API;
+using namespace Mantid::Algorithms;
+using namespace WorkspaceCreationHelper;
+
+class ReflectometryReductionOne2Test : public CxxTest::TestSuite {
+private:
+ MatrixWorkspace_sptr m_multiDetectorWS;
+ MatrixWorkspace_sptr m_wavelengthWS;
+
+public:
+ // This pair of boilerplate methods prevent the suite being created statically
+ // This means the constructor isn't called when running other tests
+ static ReflectometryReductionOne2Test *createSuite() {
+ return new ReflectometryReductionOne2Test();
+ }
+ static void destroySuite(ReflectometryReductionOne2Test *suite) {
+ delete suite;
+ }
+
+ ReflectometryReductionOne2Test() {
+ FrameworkManager::Instance();
+ // A multi detector ws
+ m_multiDetectorWS =
+ create2DWorkspaceWithReflectometryInstrumentMultiDetector();
+ // A workspace in wavelength
+ m_wavelengthWS = Create2DWorkspace154(1, 10, true);
+ m_wavelengthWS->setInstrument(m_multiDetectorWS->getInstrument());
+ m_wavelengthWS->getAxis(0)->setUnit("Wavelength");
+
+ }
+
+ void test_IvsLam() {
+ // Test IvsLam workspace
+ // No monitor normalization
+ // No direct beam normalization
+ // No transmission correction
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_multiDetectorWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspaceWavelength");
+
+ TS_ASSERT(outLam);
+ TS_ASSERT_EQUALS(outLam->getNumberHistograms(), 1);
+ TS_ASSERT_EQUALS(outLam->blocksize(), 8);
+ TS_ASSERT(outLam->readX(0)[0] >= 1.5);
+ TS_ASSERT(outLam->readX(0)[7] <= 15.0);
+ TS_ASSERT_DELTA(outLam->y(0)[0], 3.1530, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 3.1530, 0.0001);
+ }
+
+ void test_IvsLam_processing_instructions_1to2() {
+ // Test IvsLam workspace
+ // No monitor normalization
+ // No direct beam normalization
+ // No transmission correction
+ // Processing instructions : 1+2
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_multiDetectorWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setPropertyValue("ProcessingInstructions", "1+2");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspaceWavelength");
+
+ TS_ASSERT_EQUALS(outLam->getNumberHistograms(), 1);
+ TS_ASSERT_EQUALS(outLam->blocksize(), 8);
+ TS_ASSERT(outLam->readX(0)[0] >= 1.5);
+ TS_ASSERT(outLam->readX(0)[7] <= 15.0);
+ // Y counts, should be 3.1530 * 2
+ TS_ASSERT_DELTA(outLam->y(0)[0], 6.3060, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 6.3060, 0.0001);
+ }
+
+ void test_IvsLam_processing_instructions_1to3(){
+ // Test IvsLam workspace
+ // No monitor normalization
+ // No direct beam normalization
+ // No transmission correction
+ // Processing instructions : 1-3
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_multiDetectorWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setPropertyValue("ProcessingInstructions", "1-3");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspaceWavelength");
+
+ TS_ASSERT_EQUALS(outLam->getNumberHistograms(), 1);
+ TS_ASSERT_EQUALS(outLam->blocksize(), 8);
+ TS_ASSERT(outLam->readX(0)[0] >= 1.5);
+ TS_ASSERT(outLam->readX(0)[7] <= 15.0);
+ // Y counts, should be 3.1530 * 3
+ TS_ASSERT_DELTA(outLam->y(0)[0], 9.4590, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 9.4590, 0.0001);
+ }
+
+ void xtest_bad_processing_instructions() {
+ // Processing instructions : 5+6
+
+ auto alg = AlgorithmManager::Instance().create("ReflectometryReductionOne");
+ alg->setChild(true);
+ alg->initialize();
+ alg->setProperty("InputWorkspace", m_multiDetectorWS);
+ alg->setProperty("WavelengthMin", 1.5);
+ alg->setProperty("WavelengthMax", 15.0);
+ alg->setPropertyValue("OutputWorkspace", "IvsQ");
+ alg->setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg->setPropertyValue("ProcessingInstructions", "1+2");
+ // Must throw as spectrum 2 is not defined
+ TS_ASSERT_THROWS_ANYTHING(alg->execute());
+ }
+
+ void xtest_IvsLam_direct_beam() {
+ // Test IvsLam workspace
+ // No monitor normalization
+ // Direct beam normalization: 2-3
+ // No transmission correction
+ // Processing instructions : 1
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_multiDetectorWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("RegionOfDirectBeam", "2-3");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspaceWavelength");
+
+ TS_ASSERT_EQUALS(outLam->getNumberHistograms(), 1);
+ TS_ASSERT_EQUALS(outLam->blocksize(), 8);
+ TS_ASSERT(outLam->readX(0)[0] >= 1.5);
+ TS_ASSERT(outLam->readX(0)[7] <= 15.0);
+ // Y counts, should be 0.5 = 1 (from detector ws) / 2 (from direct beam)
+ TS_ASSERT_DELTA(outLam->y(0)[0], 0.5, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 0.5, 0.0001);
+ }
+
+ void xtest_bad_direct_beam() {
+ // Direct beam : 4-5
+
+ auto alg = AlgorithmManager::Instance().create("ReflectometryReductionOne");
+ alg->setChild(true);
+ alg->initialize();
+ alg->setProperty("InputWorkspace", m_multiDetectorWS);
+ alg->setProperty("WavelengthMin", 1.5);
+ alg->setProperty("WavelengthMax", 15.0);
+ alg->setProperty("MomentumTransferStep", 0.1);
+ alg->setProperty("AnalysisMode", "PointDetectorAnalysis");
+ alg->setProperty("NormalizeByIntegratedMonitors", "0");
+ alg->setPropertyValue("ProcessingInstructions", "1");
+ alg->setPropertyValue("OutputWorkspace", "IvsQ");
+ alg->setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg->setPropertyValue("RegionOfDirectBeam", "4-5");
+ // Must throw region of interest is incompatible with point detector
+ TS_ASSERT_THROWS_ANYTHING(alg->execute());
+ }
+
+ void test_IvsLam_no_monitors() {
+ // Test IvsLam workspace
+ // No monitor normalization
+ // Direct beam normalization: 2-3
+ // No transmission correction
+ // Processing instructions : 1
+
+ // I0MonitorIndex: 0
+ // MonitorBackgroundWavelengthMin : Not given
+ // MonitorBackgroundWavelengthMax : Not given
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_multiDetectorWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setProperty("I0MonitorIndex", "0");
+ alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspaceWavelength");
+
+ TS_ASSERT_EQUALS(outLam->getNumberHistograms(), 1);
+ TS_ASSERT_EQUALS(outLam->blocksize(), 8);
+ TS_ASSERT(outLam->readX(0)[0] >= 1.5);
+ TS_ASSERT(outLam->readX(0)[7] <= 15.0);
+ // No monitors considered because MonitorBackgroundWavelengthMin
+ // and MonitorBackgroundWavelengthMax were not set
+ // Y counts must be 3.1530
+ TS_ASSERT_DELTA(outLam->y(0)[0], 3.1530, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 3.1530, 0.0001);
+ }
+
+ void xtest_IvsLam_monitor_normalization() {
+ // Test IvsLam workspace
+ // Monitor normalization
+ // No direct beam normalization
+ // No transmission correction
+ // Processing instructions : 1
+
+ // I0MonitorIndex: 0
+ // MonitorBackgroundWavelengthMin : 0.5
+ // MonitorBackgroundWavelengthMax : 3.0
+ // Normalize by integrated monitors : No
+
+ // Modify counts in monitor (only for this test)
+ // Modify counts only for range that will be fitted
+ auto inputWS = m_multiDetectorWS;
+ auto &Y = inputWS->mutableY(0);
+ Y = 1.0;
+ //std::fill(Y.begin(), Y.begin()+2, 1.0);
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", inputWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setProperty("I0MonitorIndex", "0");
+ alg.setProperty("MonitorBackgroundWavelengthMin", 0.5);
+ alg.setProperty("MonitorBackgroundWavelengthMax", 3.0);
+ alg.setProperty("NormalizeByIntegratedMonitors", "0");
+ alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspaceWavelength");
+
+ TS_ASSERT_EQUALS(outLam->getNumberHistograms(), 1);
+ TS_ASSERT_EQUALS(outLam->blocksize(), 8);
+ TS_ASSERT(outLam->readX(0)[0] >= 1.5);
+ TS_ASSERT(outLam->readX(0)[7] <= 15.0);
+ // Expected values are 2.4996 = 3.15301 (detectors) / 1.26139 (monitors)
+ TS_ASSERT_DELTA(outLam->y(0)[0], 2.4996, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 2.4996, 0.0001);
+ }
+
+ void xtest_IvsLam_integrated_monitors() {
+ // Test IvsLam workspace
+ // Monitor normalization
+ // No direct beam normalization
+ // No transmission correction
+ // Processing instructions : 1
+
+ // I0MonitorIndex: 0
+ // MonitorBackgroundWavelengthMin : 0.5
+ // MonitorBackgroundWavelengthMax : 3.0
+ // Normalize by integrated monitors : Yes
+
+ // Modify counts in monitor (only for this test)
+ // Modify counts only for range that will be fitted
+ auto inputWS = m_multiDetectorWS;
+ auto &Y = inputWS->mutableY(0);
+ Y = 1.0;
+ //std::fill(Y.begin(), Y.begin()+2, 1.0);
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", inputWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setProperty("I0MonitorIndex", "0");
+ alg.setProperty("MonitorBackgroundWavelengthMin", 0.5);
+ alg.setProperty("MonitorBackgroundWavelengthMax", 3.0);
+ alg.setProperty("NormalizeByIntegratedMonitors", "1");
+ alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspaceWavelength");
+
+ TS_ASSERT_EQUALS(outLam->getNumberHistograms(), 1);
+ TS_ASSERT_EQUALS(outLam->blocksize(), 8);
+ TS_ASSERT(outLam->readX(0)[0] >= 1.5);
+ TS_ASSERT(outLam->readX(0)[7] <= 15.0);
+ // Expected values are 0.3124 = 3.15301 (detectors) / (1.26139*8) (monitors)
+ TS_ASSERT_DELTA(outLam->y(0)[0], 0.3124, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 0.3124, 0.0001);
+ }
+
+ void xtest_transmission_correction_run() {
+ // Transmission run is the same as input run
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_wavelengthWS);
+ alg.setProperty("FirstTransmissionRun", m_wavelengthWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setProperty("ProcessingInstructions", "100");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspaceWavelength");
+
+ TS_ASSERT_EQUALS(outLam->getNumberHistograms(), 1);
+ TS_ASSERT_EQUALS(outLam->blocksize(), 10);
+ // Expected values are 1 = m_wavelength / m_wavelength
+ TS_ASSERT_DELTA(outLam->y(0)[0], 1.0000, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 1.0000, 0.0001);
+ }
+
+ void xtest_exponential_correction() {
+ // CorrectionAlgorithm: ExponentialCorrection
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_wavelengthWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setProperty("ProcessingInstructions", "100");
+ alg.setProperty("CorrectDetectorPositions", false);
+ alg.setProperty("CorrectionAlgorithm", "ExponentialCorrection");
+ alg.setProperty("C0", 0.2);
+ alg.setProperty("C1", 0.1);
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspaceWavelength");
+
+ TS_ASSERT_EQUALS(outLam->getNumberHistograms(), 1);
+ TS_ASSERT_EQUALS(outLam->blocksize(), 10);
+ // Expected values are 29.0459 and 58.4912
+ TS_ASSERT_DELTA(outLam->y(0)[0], 29.0459, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 58.4912, 0.0001);
+ }
+
+ void test_polynomial_correction() {
+ // CorrectionAlgorithm: PolynomialCorrection
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_wavelengthWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setProperty("ProcessingInstructions", "100");
+ alg.setProperty("CorrectionAlgorithm", "PolynomialCorrection");
+ alg.setProperty("Polynomial", "0.1,0.3,0.5");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspaceWavelength");
+
+ TS_ASSERT_EQUALS(outLam->getNumberHistograms(), 1);
+ TS_ASSERT_EQUALS(outLam->blocksize(), 10);
+ // Expected values are 2.9851 and 0.1289
+ TS_ASSERT_DELTA(outLam->y(0)[0], 2.9851, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 0.1289, 0.0001);
+ }
+
+ void xtest_IvsQ_no_rebin() {
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_wavelengthWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setProperty("ProcessingInstructions", "100");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outQ = alg.getProperty("OutputWorkspace");
+
+ // TODO: test some values
+ }
+
+ void xtest_IvsQ_linear_binning() {
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_wavelengthWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setProperty("ProcessingInstructions", "100");
+ alg.setProperty("MomentumTransferMin", 1.0);
+ alg.setProperty("MomentumTransferMax", 10.0);
+ alg.setProperty("MomentumTransferStep", 0.04);
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outQ = alg.getProperty("OutputWorkspace");
+
+ // TODO: choose appropriate values for MomentumTransferMin, MomentumTransferMax, MomentumTransferStep
+ // TODO: test some values
+ }
+
+ void xtest_IvsQ_logarithmic_binning() {
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_wavelengthWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setProperty("ProcessingInstructions", "100");
+ alg.setProperty("MomentumTransferMin", 1.0);
+ alg.setProperty("MomentumTransferMax", 10.0);
+ alg.setProperty("MomentumTransferStep", 0.04);
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outQ = alg.getProperty("OutputWorkspace");
+
+ // TODO: choose appropriate values for MomentumTransferMin, MomentumTransferMax, MomentumTransferStep
+ // TODO: test some values
+ }
+
+ void xtest_IvsQ_q_range() {
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_wavelengthWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setProperty("ProcessingInstructions", "100");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspaceWavelength");
+ MatrixWorkspace_sptr outQ = alg.getProperty("OutputWorkspace");
+
+ // TODO: check that q = 4 * pi / lambda * sin(theta)
+ }
+
+ void xtest_IvsQ_scale() {
+
+ ReflectometryReductionOne2 alg;
+ alg.setChild(true);
+ alg.initialize();
+ alg.setProperty("InputWorkspace", m_wavelengthWS);
+ alg.setProperty("WavelengthMin", 1.5);
+ alg.setProperty("WavelengthMax", 15.0);
+ alg.setProperty("ProcessingInstructions", "100");
+ alg.setPropertyValue("OutputWorkspace", "IvsQ");
+ alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
+ alg.execute();
+ MatrixWorkspace_sptr outQ = alg.getProperty("OutputWorkspace");
+
+ TS_ASSERT_EQUALS(outQ->getNumberHistograms(), 1);
+ TS_ASSERT_EQUALS(outQ->blocksize(), 10);
+
+ // TODO: test some values
+ }
+
+};
+
+#endif /* ALGORITHMS_TEST_REFLECTOMETRYREDUCTIONONE2TEST_H_ */
diff --git a/Framework/TestHelpers/inc/MantidTestHelpers/WorkspaceCreationHelper.h b/Framework/TestHelpers/inc/MantidTestHelpers/WorkspaceCreationHelper.h
index f0144963c8e90db0ab192c33c9009d81b0f0b492..81d2f08928b3b07b840f313bc9aebc340d3391dc 100644
--- a/Framework/TestHelpers/inc/MantidTestHelpers/WorkspaceCreationHelper.h
+++ b/Framework/TestHelpers/inc/MantidTestHelpers/WorkspaceCreationHelper.h
@@ -328,6 +328,11 @@ void create2DAngles(std::vector<double> &L2, std::vector<double> &polar,
Mantid::API::MatrixWorkspace_sptr
create2DWorkspaceWithReflectometryInstrument(double startX = 0);
+/// Create a 2D workspace with one monitor and three detectors based around
+/// a virtual reflectometry instrument.
+Mantid::API::MatrixWorkspace_sptr
+create2DWorkspaceWithReflectometryInstrumentMultiDetector(double startX = 0);
+
void createInstrumentForWorkspaceWithDistances(
Mantid::API::MatrixWorkspace_sptr workspace,
const Mantid::Kernel::V3D &samplePosition,
diff --git a/Framework/TestHelpers/src/WorkspaceCreationHelper.cpp b/Framework/TestHelpers/src/WorkspaceCreationHelper.cpp
index 0ea9ef83badb5e07d2e60b93ef199e088799f6ed..057d18381d7defcd6a7dd75a131d380190bd9ae0 100644
--- a/Framework/TestHelpers/src/WorkspaceCreationHelper.cpp
+++ b/Framework/TestHelpers/src/WorkspaceCreationHelper.cpp
@@ -490,6 +490,71 @@ create2DWorkspaceWithReflectometryInstrument(double startX) {
return workspace;
}
+/**
+* Create a very small 2D workspace for a virtual reflectometry instrument with multiple detectors
+* @return workspace with instrument attached.
+* @param startX : X Tof start value for the workspace.
+*/
+MatrixWorkspace_sptr
+create2DWorkspaceWithReflectometryInstrumentMultiDetector(double startX) {
+ Instrument_sptr instrument = boost::make_shared<Instrument>();
+ instrument->setReferenceFrame(
+ boost::make_shared<ReferenceFrame>(Y /*up*/, X /*along*/, Left, "0,0,0"));
+
+ ObjComponent *source = new ObjComponent("source");
+ source->setPos(V3D(0, 0, 0));
+ instrument->add(source);
+ instrument->markAsSource(source);
+
+ ObjComponent *sample = new ObjComponent("some-surface-holder");
+ sample->setPos(V3D(15, 0, 0));
+ instrument->add(sample);
+ instrument->markAsSamplePos(sample);
+
+ Detector *monitor = new Detector("Monitor", 1, nullptr);
+ monitor->setPos(14, 0, 0);
+ instrument->add(monitor);
+ instrument->markAsMonitor(monitor);
+
+ Detector *det1 = new Detector(
+ "point-detector", 2,
+ ComponentCreationHelper::createCuboid(0.01, 0.02, 0.03), nullptr);
+ det1->setPos(20,(20 - sample->getPos().X()) , 0);
+ instrument->add(det1);
+ instrument->markAsDetector(det1);
+
+ Detector *det2 = new Detector(
+ "point-detector", 3,
+ ComponentCreationHelper::createCuboid(0.01, 0.02, 0.03), nullptr);
+ det2->setPos(20, (20 - sample->getPos().X()), 0);
+ instrument->add(det2);
+ instrument->markAsDetector(det2);
+
+ Detector *det3 = new Detector(
+ "point-detector", 4,
+ ComponentCreationHelper::createCuboid(0.01, 0.02, 0.03), nullptr);
+ det3->setPos(20, (20 - sample->getPos().X()), 0);
+ instrument->add(det3);
+ instrument->markAsDetector(det3);
+
+ const int nSpectra = 4;
+ const int nBins = 20;
+ const double deltaX = 5000; // TOF
+ auto workspace = Create2DWorkspaceBinned(nSpectra, nBins, startX, deltaX);
+
+ workspace->setTitle("Test histogram");
+ workspace->getAxis(0)->setUnit("TOF");
+ workspace->setYUnit("Counts");
+
+ workspace->setInstrument(instrument);
+ workspace->getSpectrum(0).setDetectorID(monitor->getID());
+ workspace->getSpectrum(1).setDetectorID(det1->getID());
+ workspace->getSpectrum(2).setDetectorID(det2->getID());
+ workspace->getSpectrum(3).setDetectorID(det3->getID());
+ return workspace;
+}
+
+
void createInstrumentForWorkspaceWithDistances(
MatrixWorkspace_sptr workspace, const V3D &samplePosition,
const V3D &sourcePosition, const std::vector<V3D> &detectorPositions) {