diff --git a/Framework/Algorithms/CMakeLists.txt b/Framework/Algorithms/CMakeLists.txt
index 5ecfac48d9482a8f4e31436084f61b53f4eaf60c..715f5776a75d20f662f7253d5761e7d3881ed553 100644
--- a/Framework/Algorithms/CMakeLists.txt
+++ b/Framework/Algorithms/CMakeLists.txt
@@ -241,9 +241,7 @@ set ( SRC_FILES
src/RebinToWorkspace.cpp
src/Rebunch.cpp
src/RecordPythonScript.cpp
- src/ReflectometryReductionOne.cpp
src/ReflectometryReductionOne2.cpp
- src/ReflectometryReductionOneAuto.cpp
src/ReflectometryReductionOneAuto2.cpp
src/ReflectometryWorkflowBase.cpp
src/ReflectometryWorkflowBase2.cpp
@@ -578,9 +576,7 @@ set ( INC_FILES
inc/MantidAlgorithms/RebinToWorkspace.h
inc/MantidAlgorithms/Rebunch.h
inc/MantidAlgorithms/RecordPythonScript.h
- inc/MantidAlgorithms/ReflectometryReductionOne.h
inc/MantidAlgorithms/ReflectometryReductionOne2.h
- inc/MantidAlgorithms/ReflectometryReductionOneAuto.h
inc/MantidAlgorithms/ReflectometryReductionOneAuto2.h
inc/MantidAlgorithms/ReflectometryWorkflowBase.h
inc/MantidAlgorithms/ReflectometryWorkflowBase2.h
@@ -917,8 +913,6 @@ set ( TEST_FILES
RectangularBeamProfileTest.h
ReflectometryReductionOne2Test.h
ReflectometryReductionOneAuto2Test.h
- ReflectometryReductionOneAutoTest.h
- ReflectometryReductionOneTest.h
RegroupTest.h
RemoveBackgroundTest.h
RemoveBinsTest.h
diff --git a/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOne.h b/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOne.h
deleted file mode 100644
index 0a0c6854d40826e5b7cd823d1b79b7a9510333ee..0000000000000000000000000000000000000000
--- a/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOne.h
+++ /dev/null
@@ -1,110 +0,0 @@
-#ifndef MANTID_ALGORITHMS_REFLECTOMETRYREDUCTIONONE_H_
-#define MANTID_ALGORITHMS_REFLECTOMETRYREDUCTIONONE_H_
-
-#include "MantidKernel/System.h"
-#include "MantidAlgorithms/DllConfig.h"
-#include "MantidAPI/MatrixWorkspace_fwd.h"
-#include "MantidGeometry/Instrument.h"
-#include "MantidGeometry/IComponent.h"
-#include "MantidGeometry/IDetector.h"
-#include "MantidAlgorithms/ReflectometryWorkflowBase.h"
-
-namespace Mantid {
-namespace Algorithms {
-
-/** ReflectometryReductionOne : Reflectometry reduction of a single input TOF
- workspace to an IvsQ workspace.
-
- Copyright © 2013 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
- National Laboratory & European Spallation Source
-
- This file is part of Mantid.
-
- Mantid is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- (at your option) any later version.
-
- Mantid is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
-
- File change history is stored at: <https://github.com/mantidproject/mantid>
- Code Documentation is available at: <http://doxygen.mantidproject.org>
- */
-class DLLExport ReflectometryReductionOne : public ReflectometryWorkflowBase {
-public:
- const std::string name() const override;
- /// Summary of algorithms purpose
- const std::string summary() const override {
- return "Reduces a single TOF/Lambda reflectometry run into a mod Q vs I/I0 "
- "workspace. Performs transmission corrections.";
- }
-
- int version() const override;
- const std::string category() const override;
-
- /// Convert to an IvsQ workspace. Performs detector positional corrections
- /// based on the component name and the theta value.
- Mantid::API::MatrixWorkspace_sptr toIvsQ(API::MatrixWorkspace_sptr &toConvert,
- const bool bCorrectPosition,
- OptionalDouble &thetaInDeg,
- const bool isPointDetector);
-
-private:
- /** Overridden Algorithm methods **/
-
- void init() override;
-
- void exec() override;
-
- /// Get the surface sample component
- Mantid::Geometry::IComponent_const_sptr
- getSurfaceSampleComponent(Mantid::Geometry::Instrument_const_sptr inst);
-
- /// Get the detector component
- Mantid::Geometry::IComponent_const_sptr
- getDetectorComponent(Mantid::Geometry::Instrument_const_sptr inst,
- const bool isPointDetector);
-
- /// Correct detector positions.
- API::MatrixWorkspace_sptr
- correctPosition(API::MatrixWorkspace_sptr &toCorrect,
- const double &thetaInDeg, const bool isPointDetector);
-
- /// Perform a transmission correction on the input IvsLam workspace
- API::MatrixWorkspace_sptr transmissonCorrection(
- API::MatrixWorkspace_sptr IvsLam, const MinMax &wavelengthInterval,
- const OptionalMinMax &wavelengthMonitorBackgroundInterval,
- const OptionalMinMax &wavelengthMonitorIntegrationInterval,
- const OptionalInteger &i0MonitorIndex,
- API::MatrixWorkspace_sptr firstTransmissionRun,
- OptionalMatrixWorkspace_sptr secondTransmissionRun,
- const OptionalDouble &stitchingStart,
- const OptionalDouble &stitchingDelta, const OptionalDouble &stitchingEnd,
- const OptionalDouble &stitchingStartOverlap,
- const OptionalDouble &stitchingEndOverlap,
- const std::string &numeratorProcessingCommands);
-
- /// Perform transmission correction using either PolynomialCorrection
- /// or ExponentialCorrection.
- API::MatrixWorkspace_sptr
- algorithmicCorrection(API::MatrixWorkspace_sptr IvsLam);
-
- /// Verify spectrum maps
- void verifySpectrumMaps(API::MatrixWorkspace_const_sptr ws1,
- API::MatrixWorkspace_const_sptr ws2,
- const bool severe = false);
- /// returns angle for source rotation
- double getAngleForSourceRotation(API::MatrixWorkspace_sptr toConvert,
- double thetaOut);
-};
-
-} // namespace Algorithms
-} // namespace Mantid
-
-#endif /* MANTID_ALGORITHMS_REFLECTOMETRYREDUCTIONONE_H_ */
diff --git a/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOneAuto.h b/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOneAuto.h
deleted file mode 100644
index 5b84f40d83371650a724a21303f6dbd34a8bdb05..0000000000000000000000000000000000000000
--- a/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOneAuto.h
+++ /dev/null
@@ -1,70 +0,0 @@
-#ifndef MANTID_ALGORITHMS_REFLECTOMETRYREDUCTIONONEAUTO_H_
-#define MANTID_ALGORITHMS_REFLECTOMETRYREDUCTIONONEAUTO_H_
-
-#include "MantidAPI/Algorithm.h"
-#include "MantidAPI/DataProcessorAlgorithm.h"
-#include "MantidAPI/WorkspaceGroup_fwd.h"
-#include "MantidKernel/System.h"
-
-#include <boost/optional.hpp>
-
-namespace Mantid {
-namespace Algorithms {
-
-/** ReflectometryReductionOneAuto : Algorithm to run ReflectometryReductionOne,
-attempting to pick instrument parameters for
- * missing properties.
-
-Copyright © 2014 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
-National Laboratory & European Spallation Source
-
-This file is part of Mantid.
-
-Mantid is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-(at your option) any later version.
-
-Mantid is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program. If not, see <http://www.gnu.org/licenses/>.
-
-File change history is stored at: <https://github.com/mantidproject/mantid>
-Code Documentation is available at: <http://doxygen.mantidproject.org>
-*/
-class DLLExport ReflectometryReductionOneAuto
- : public API::DataProcessorAlgorithm {
-public:
- const std::string name() const override;
- int version() const override;
- const std::string category() const override;
- const std::string summary() const override;
-
- // For (multiperiod) workspace groups
- bool checkGroups() override;
- bool processGroups() override;
-
-private:
- void init() override;
- void exec() override;
- template <typename T> boost::optional<T> isSet(std::string propName) const;
- Mantid::API::Workspace_sptr
- sumOverTransmissionGroup(Mantid::API::WorkspaceGroup_sptr &transGroup);
-
- std::string pNRLabel() const { return "PNR"; }
- std::string pALabel() const { return "PA"; }
- std::string crhoLabel() const { return "CRho"; }
- std::string cppLabel() const { return "CPp"; }
- std::string cAlphaLabel() const { return "CAlpha"; }
- std::string cApLabel() const { return "CAp"; }
- std::string noPolarizationCorrectionMode() const { return "None"; }
-};
-
-} // namespace Algorithms
-} // namespace Mantid
-
-#endif /* MANTID_ALGORITHMS_REFLECTOMETRYREDUCTIONONEAUTO_H_ */
diff --git a/Framework/Algorithms/src/ReflectometryReductionOne.cpp b/Framework/Algorithms/src/ReflectometryReductionOne.cpp
deleted file mode 100644
index 3d8e2a2dc971cb8260577504d599e7df3bdaac57..0000000000000000000000000000000000000000
--- a/Framework/Algorithms/src/ReflectometryReductionOne.cpp
+++ /dev/null
@@ -1,855 +0,0 @@
-#include "MantidAlgorithms/BoostOptionalToAlgorithmProperty.h"
-#include "MantidAlgorithms/ReflectometryReductionOne.h"
-#include "MantidAPI/Axis.h"
-#include "MantidAPI/WorkspaceUnitValidator.h"
-#include "MantidGeometry/Instrument/ReferenceFrame.h"
-#include "MantidKernel/ListValidator.h"
-#include "MantidKernel/ArrayProperty.h"
-#include "MantidKernel/EnabledWhenProperty.h"
-#include "MantidKernel/Tolerance.h"
-#include "MantidKernel/Unit.h"
-
-using namespace Mantid::Kernel;
-using namespace Mantid::API;
-using namespace Mantid::Geometry;
-
-namespace Mantid {
-namespace Algorithms {
-
-/*Anonomous namespace */
-namespace {
-/**
-* Helper non-member function for translating all the workspace indexes in an
-*origin workspace into workspace indexes
-* of a host end-point workspace. This is done using spectrum numbers as the
-*intermediate.
-*
-* This function will throw a runtime error if the specId are not found to exist
-*on the host end-point workspace.
-*
-* @param originWS : Origin workspace, which provides the original workspace
-*index to spectrum number mapping.
-* @param hostWS : Workspace onto which the resulting workspace indexes will be
-*hosted
-* @return Remapped workspace indexes applicable for the host workspace. results
-*as comma separated string.
-*/
-std::string createWorkspaceIndexListFromDetectorWorkspace(
- MatrixWorkspace_const_sptr originWS, MatrixWorkspace_const_sptr hostWS) {
- auto spectrumMap = originWS->getSpectrumToWorkspaceIndexMap();
- auto it = spectrumMap.begin();
- std::stringstream result;
- specnum_t specId = (*it).first;
- result << static_cast<int>(hostWS->getIndexFromSpectrumNumber(specId));
- ++it;
- for (; it != spectrumMap.end(); ++it) {
- specId = (*it).first;
- result << ","
- << static_cast<int>(hostWS->getIndexFromSpectrumNumber(specId));
- }
- return result.str();
-}
-
-const std::string multiDetectorAnalysis = "MultiDetectorAnalysis";
-const std::string pointDetectorAnalysis = "PointDetectorAnalysis";
-const std::string tofUnitId = "TOF";
-const std::string wavelengthUnitId = "Wavelength";
-
-/**
-* Helper free function to get the ordered spectrum numbers from a workspace.
-* @param ws
-* @return
-*/
-std::vector<int> getSpectrumNumbers(MatrixWorkspace_sptr &ws) {
- auto specToWSIndexMap = ws->getSpectrumToWorkspaceIndexMap();
- std::vector<int> keys(specToWSIndexMap.size());
- size_t i = 0;
- for (auto it = specToWSIndexMap.begin(); it != specToWSIndexMap.end();
- ++it, ++i) {
- keys[i] = static_cast<int>(it->first);
- }
- std::sort(
- keys.begin(),
- keys.end()); // Sort the keys, as the order is not guaranteed in the map.
-
- return keys;
-}
-
-/**
-* Helper free function to calculate MomentumTransfer from lambda and theta
-* @param lambda : Value in wavelength
-* @param theta : Value in Degrees
-* @return MomentumTransfer
-* @
-*/
-double calculateQ(double lambda, double theta) {
- if (lambda == 0.0)
- throw std::runtime_error("Minimum/Maximum value of the IvsLambda Workspace "
- "is 0. Cannot calculate Q");
- double thetaInRad = theta * M_PI / 180;
- return (4 * M_PI * sin(thetaInRad)) / lambda;
-}
-}
-/* End of ananomous namespace */
-
-// Register the algorithm into the AlgorithmFactory
-DECLARE_ALGORITHM(ReflectometryReductionOne)
-
-//----------------------------------------------------------------------------------------------
-/// Algorithm's name for identification. @see Algorithm::name
-const std::string ReflectometryReductionOne::name() const {
- return "ReflectometryReductionOne";
-}
-
-/// Algorithm's version for identification. @see Algorithm::version
-int ReflectometryReductionOne::version() const { return 1; }
-
-/// Algorithm's category for identification. @see Algorithm::category
-const std::string ReflectometryReductionOne::category() const {
- return "Reflectometry";
-}
-
-//----------------------------------------------------------------------------------------------
-
-//----------------------------------------------------------------------------------------------
-/** Initialize the algorithm's properties.
-*/
-void ReflectometryReductionOne::init() {
-
- declareProperty(make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "InputWorkspace", "", Direction::Input),
- "Run to reduce.");
-
- std::vector<std::string> propOptions;
- propOptions.push_back(pointDetectorAnalysis);
- propOptions.push_back(multiDetectorAnalysis);
-
- declareProperty(
- "AnalysisMode", "PointDetectorAnalysis",
- boost::make_shared<StringListValidator>(propOptions),
- "The type of analysis to perform. Point detector or multi detector.");
-
- declareProperty(make_unique<ArrayProperty<int>>("RegionOfDirectBeam"),
- "Indices of the spectra a pair (lower, upper) that mark the "
- "ranges that correspond to the direct beam in multi-detector "
- "mode.");
-
- this->initIndexInputs();
- this->initWavelengthInputs();
-
- declareProperty(make_unique<PropertyWithValue<std::string>>(
- "DetectorComponentName", "", Direction::Input),
- "Name of the detector component i.e. point-detector. If "
- "these are not specified, the algorithm will attempt lookup "
- "using a standard naming convention.");
-
- declareProperty(make_unique<PropertyWithValue<std::string>>(
- "SampleComponentName", "", Direction::Input),
- "Name of the sample component i.e. some-surface-holder. If "
- "these are not specified, the algorithm will attempt lookup "
- "using a standard naming convention.");
-
- declareProperty(make_unique<WorkspaceProperty<>>("OutputWorkspace", "",
- Direction::Output),
- "Output Workspace IvsQ.");
-
- declareProperty(make_unique<WorkspaceProperty<>>("OutputWorkspaceWavelength",
- "", Direction::Output,
- PropertyMode::Optional),
- "Output Workspace IvsLam. Intermediate workspace.");
-
- declareProperty(make_unique<PropertyWithValue<double>>(
- "ThetaIn", Mantid::EMPTY_DBL(), Direction::Input),
- "Final theta value in degrees. Optional, this value will be "
- "calculated internally and provided as ThetaOut if not "
- "provided.");
-
- declareProperty(make_unique<PropertyWithValue<double>>(
- "ThetaOut", Mantid::EMPTY_DBL(), Direction::Output),
- "Calculated final theta in degrees.");
-
- declareProperty("NormalizeByIntegratedMonitors", true,
- "Normalize by dividing by the integrated monitors.");
-
- declareProperty(make_unique<PropertyWithValue<bool>>(
- "CorrectDetectorPositions", true, Direction::Input),
- "Correct detector positions using ThetaIn (if given)");
-
- declareProperty(
- make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "FirstTransmissionRun", "", Direction::Input, PropertyMode::Optional),
- "First transmission run, or the low wavelength transmission run if "
- "SecondTransmissionRun is also provided.");
-
- auto inputValidator = boost::make_shared<WorkspaceUnitValidator>(tofUnitId);
- declareProperty(make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "SecondTransmissionRun", "", Direction::Input,
- PropertyMode::Optional, inputValidator),
- "Second, high wavelength transmission run. Optional. Causes "
- "the FirstTransmissionRun to be treated as the low "
- "wavelength transmission run.");
-
- this->initStitchingInputs();
-
- declareProperty(make_unique<PropertyWithValue<bool>>("StrictSpectrumChecking",
- true, Direction::Input),
- "Enforces spectrum number checking prior to normalization");
-
- std::vector<std::string> correctionAlgorithms = {
- "None", "PolynomialCorrection", "ExponentialCorrection"};
- declareProperty("CorrectionAlgorithm", "None",
- boost::make_shared<StringListValidator>(correctionAlgorithms),
- "The type of correction to perform.");
-
- declareProperty(make_unique<ArrayProperty<double>>("Polynomial"),
- "Coefficients to be passed to the PolynomialCorrection"
- " algorithm.");
-
- declareProperty(
- make_unique<PropertyWithValue<double>>("C0", 0.0, Direction::Input),
- "C0 value to be passed to the ExponentialCorrection algorithm.");
-
- declareProperty(
- make_unique<PropertyWithValue<double>>("C1", 0.0, Direction::Input),
- "C1 value to be passed to the ExponentialCorrection algorithm.");
-
- setPropertyGroup("CorrectionAlgorithm", "Polynomial Corrections");
- setPropertyGroup("Polynomial", "Polynomial Corrections");
- setPropertyGroup("C0", "Polynomial Corrections");
- setPropertyGroup("C1", "Polynomial Corrections");
-
- setPropertySettings(
- "Polynomial",
- Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "CorrectionAlgorithm", IS_EQUAL_TO, "PolynomialCorrection"));
- setPropertySettings(
- "C0", Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "CorrectionAlgorithm", IS_EQUAL_TO, "ExponentialCorrection"));
- setPropertySettings(
- "C1", Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "CorrectionAlgorithm", IS_EQUAL_TO, "ExponentialCorrection"));
-
- setPropertyGroup("FirstTransmissionRun", "Transmission");
- setPropertyGroup("SecondTransmissionRun", "Transmission");
- setPropertyGroup("Params", "Transmission");
- setPropertyGroup("StartOverlap", "Transmission");
- setPropertyGroup("EndOverlap", "Transmission");
-
- // Only ask for transmission parameters when a FirstTranmissionRun has been
- // provided
- setPropertySettings("SecondTransmissionRun",
- Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "FirstTransmissionRun", IS_NOT_DEFAULT));
- setPropertySettings("Params",
- Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "FirstTransmissionRun", IS_NOT_DEFAULT));
- setPropertySettings("StartOverlap",
- Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "FirstTransmissionRun", IS_NOT_DEFAULT));
- setPropertySettings("EndOverlap",
- Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "FirstTransmissionRun", IS_NOT_DEFAULT));
-
- // Only use region of direct beam when in multi-detector analysis mode.
- setPropertySettings(
- "RegionOfDirectBeam",
- Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "AnalysisMode", IS_EQUAL_TO, "MultiDetectorAnalysis"));
- declareProperty("ScaleFactor", Mantid::EMPTY_DBL(),
- "Factor you wish to scale Q workspace by.", Direction::Input);
- declareProperty("MomentumTransferMinimum", Mantid::EMPTY_DBL(),
- "Minimum Q value in IvsQ "
- "Workspace. Used for Rebinning "
- "the IvsQ Workspace",
- Direction::Input);
- declareProperty("MomentumTransferStep", Mantid::EMPTY_DBL(),
- "Resolution value in IvsQ Workspace. Used for Rebinning the "
- "IvsQ Workspace. This value will be made minus to apply "
- "logarithmic rebinning. If you wish to have linear "
- "bin-widths then please provide a negative DQQ",
- Direction::Input);
- declareProperty("MomentumTransferMaximum", Mantid::EMPTY_DBL(),
- "Maximum Q value in IvsQ "
- "Workspace. Used for Rebinning "
- "the IvsQ Workspace",
- Direction::Input);
-}
-
-/**
-* Correct the position of the detectors based on the input theta value.
-* @param toCorrect : Workspace to correct detector positions on.
-* @param thetaInDeg : Theta in degrees to use in correction calculations.
-* @param isPointDetector : True if using point detector analysis
-* @return Copy with positions corrected.
-*/
-MatrixWorkspace_sptr
-ReflectometryReductionOne::correctPosition(API::MatrixWorkspace_sptr &toCorrect,
- const double &thetaInDeg,
- const bool isPointDetector) {
- g_log.debug("Correcting position using theta.");
-
- auto correctPosAlg = this->createChildAlgorithm(
- "SpecularReflectionPositionCorrect", -1, -1, true, 1);
- correctPosAlg->initialize();
- correctPosAlg->setProperty("InputWorkspace", toCorrect);
-
- const std::string analysisMode = this->getProperty("AnalysisMode");
- correctPosAlg->setProperty("AnalysisMode", analysisMode);
- auto instrument = toCorrect->getInstrument();
- IComponent_const_sptr sample = this->getSurfaceSampleComponent(instrument);
- correctPosAlg->setProperty("SampleComponentName", sample->getName());
- correctPosAlg->setProperty("TwoThetaIn", thetaInDeg * 2);
-
- if (isPointDetector) {
- IComponent_const_sptr detector =
- this->getDetectorComponent(instrument, isPointDetector);
- correctPosAlg->setProperty("DetectorComponentName", detector->getName());
- } else {
- auto specNumbers = getSpectrumNumbers(toCorrect);
- correctPosAlg->setProperty("SpectrumNumbersOfDetectors", specNumbers);
- for (auto specNumber : specNumbers) {
- std::stringstream buffer;
- buffer << "Writing out: " << specNumber;
- g_log.notice(buffer.str());
- }
- }
- correctPosAlg->execute();
- MatrixWorkspace_sptr corrected =
- correctPosAlg->getProperty("OutputWorkspace");
-
- return corrected;
-}
-/**
-* @param toConvert : workspace used to get instrument components
-* @param thetaOut : angle between sample and detectors (in Degrees)
-* @return Theta : the value by which we rotate the source (in Degrees)
-*/
-double ReflectometryReductionOne::getAngleForSourceRotation(
- MatrixWorkspace_sptr toConvert, double thetaOut) {
- auto instrument = toConvert->getInstrument();
- auto instrumentUpVector = instrument->getReferenceFrame()->vecPointingUp();
- // check to see if calculated theta is the same as theta from instrument setup
- auto instrumentBeamDirection = instrument->getBeamDirection();
- double currentThetaInFromInstrument =
- instrumentUpVector.angle(instrumentBeamDirection) * (180 / M_PI) - 90;
- bool isInThetaEqualToOutTheta =
- std::abs(currentThetaInFromInstrument - thetaOut) <
- Mantid::Kernel::Tolerance;
- // the angle by which we rotate the source
- double rotationTheta = 0.0;
- if (!isInThetaEqualToOutTheta /*source needs rotation*/) {
- rotationTheta = thetaOut - currentThetaInFromInstrument;
- }
- return rotationTheta;
-}
-
-/**
-* Convert an input workspace into an IvsQ workspace.
-*
-* @param toConvert : Workspace to convert
-* @param bCorrectPosition : Flag to indicate that detector positions should be
-*corrected based on the input theta values.
-* @param thetaInDeg : Theta in Degrees. Used for correction.
-* @param isPointDetector: Is point detector analysis
-* @return
-*/
-Mantid::API::MatrixWorkspace_sptr ReflectometryReductionOne::toIvsQ(
- API::MatrixWorkspace_sptr &toConvert, const bool bCorrectPosition,
- OptionalDouble &thetaInDeg, const bool isPointDetector) {
- /*
- * Can either calculate a missing theta value for the purposes of reporting,
- * or correct positions based on a theta value,
- * but not both. The processing is effectively circular if both are applied.
- */
- if (!thetaInDeg.is_initialized()) {
- g_log.debug("Calculating final theta.");
-
- auto correctThetaAlg = this->createChildAlgorithm(
- "SpecularReflectionCalculateTheta", -1, -1, true, 1);
- correctThetaAlg->initialize();
- correctThetaAlg->setProperty("InputWorkspace", toConvert);
- const std::string analysisMode = this->getProperty("AnalysisMode");
- correctThetaAlg->setProperty("AnalysisMode", analysisMode);
- const std::string sampleComponentName =
- this->getProperty("SampleComponentName");
- correctThetaAlg->setProperty("SampleComponentName", sampleComponentName);
- if (isPointDetector) {
- const std::string detectorComponentName =
- this->getPropertyValue("DetectorComponentName");
- correctThetaAlg->setProperty("DetectorComponentName",
- detectorComponentName);
- } else {
- std::vector<int> spectrumNumbers = getSpectrumNumbers(toConvert);
- correctThetaAlg->setProperty("SpectrumNumbersOfDetectors",
- spectrumNumbers);
- }
- correctThetaAlg->execute();
- const double twoTheta = correctThetaAlg->getProperty("TwoTheta");
-
- thetaInDeg = twoTheta / 2;
-
- } else if (bCorrectPosition) {
- toConvert = correctPosition(toConvert, thetaInDeg.get(), isPointDetector);
- }
-
- // Rotate the source (needed before ConvertUnits)
- double rotationTheta = getAngleForSourceRotation(toConvert, thetaInDeg.get());
- if (rotationTheta != 0.0) {
- auto rotateSource = this->createChildAlgorithm("RotateSource");
- rotateSource->setChild(true);
- rotateSource->initialize();
- rotateSource->setProperty("Workspace", toConvert);
- rotateSource->setProperty("Angle", rotationTheta);
- rotateSource->execute();
- }
-
- // Always convert units.
- auto convertUnits = this->createChildAlgorithm("ConvertUnits");
- convertUnits->initialize();
- convertUnits->setProperty("InputWorkspace", toConvert);
- convertUnits->setProperty("Target", "MomentumTransfer");
- convertUnits->execute();
- MatrixWorkspace_sptr inQ = convertUnits->getProperty("OutputWorkspace");
-
- // Rotate the source back to its original position
- if (rotationTheta != 0.0) {
- // for IvsLam Workspace
- auto rotateSource = this->createChildAlgorithm("RotateSource");
- rotateSource->setChild(true);
- rotateSource->initialize();
- rotateSource->setProperty("Workspace", toConvert);
- rotateSource->setProperty("Angle", -rotationTheta);
- rotateSource->execute();
- // for IvsQ Workspace
- rotateSource->setProperty("Workspace", inQ);
- rotateSource->setProperty("Angle", -rotationTheta);
- rotateSource->execute();
- }
-
- return inQ;
-}
-
-/**
-* Get the sample component. Use the name provided as a property as the basis
-*for the lookup as a priority.
-*
-* Throws if the name is invalid.
-* @param inst : Instrument to search through
-* @return : The component : The component object found.
-*/
-Mantid::Geometry::IComponent_const_sptr
-ReflectometryReductionOne::getSurfaceSampleComponent(
- Mantid::Geometry::Instrument_const_sptr inst) {
- std::string sampleComponent = "some-surface-holder";
- if (!isPropertyDefault("SampleComponentName")) {
- sampleComponent = this->getPropertyValue("SampleComponentName");
- }
- auto searchResult = inst->getComponentByName(sampleComponent);
- if (searchResult == nullptr) {
- throw std::invalid_argument(sampleComponent +
- " does not exist. Check input properties.");
- }
- return searchResult;
-}
-
-/**
-* Get the detector component. Use the name provided as a property as the basis
-*for the lookup as a priority.
-*
-* Throws if the name is invalid.
-* @param inst : Instrument to search through.
-* @param isPointDetector : True if this is a point detector. Used to guess a
-*name.
-* @return The component : The component object found.
-*/
-boost::shared_ptr<const Mantid::Geometry::IComponent>
-ReflectometryReductionOne::getDetectorComponent(
- Mantid::Geometry::Instrument_const_sptr inst, const bool isPointDetector) {
- std::string componentToCorrect =
- isPointDetector ? "point-detector" : "line-detector";
- if (!isPropertyDefault("DetectorComponentName")) {
- componentToCorrect = this->getPropertyValue("DetectorComponentName");
- }
- boost::shared_ptr<const IComponent> searchResult =
- inst->getComponentByName(componentToCorrect);
- if (searchResult == nullptr) {
- throw std::invalid_argument(componentToCorrect +
- " does not exist. Check input properties.");
- }
- return searchResult;
-}
-
-//----------------------------------------------------------------------------------------------
-/** Execute the algorithm.
-*/
-void ReflectometryReductionOne::exec() {
- MatrixWorkspace_sptr runWS = getProperty("InputWorkspace");
-
- OptionalMatrixWorkspace_sptr firstTransmissionRun;
- OptionalMatrixWorkspace_sptr secondTransmissionRun;
- OptionalDouble stitchingStart;
- OptionalDouble stitchingDelta;
- OptionalDouble stitchingEnd;
- OptionalDouble stitchingStartOverlap;
- OptionalDouble stitchingEndOverlap;
-
- getTransmissionRunInfo(firstTransmissionRun, secondTransmissionRun,
- stitchingStart, stitchingDelta, stitchingEnd,
- stitchingStartOverlap, stitchingEndOverlap);
-
- OptionalDouble theta;
- if (!isPropertyDefault("ThetaIn")) {
- double temp = this->getProperty("ThetaIn");
- theta = temp;
- }
- const std::string strAnalysisMode = getProperty("AnalysisMode");
- const bool isPointDetector = (pointDetectorAnalysis == strAnalysisMode);
- const bool isMultiDetector = (multiDetectorAnalysis == strAnalysisMode);
-
- const MinMax wavelengthInterval =
- this->getMinMax("WavelengthMin", "WavelengthMax");
-
- const std::string processingCommands = getWorkspaceIndexList();
-
- OptionalWorkspaceIndexes directBeam;
- fetchOptionalLowerUpperPropertyValue("RegionOfDirectBeam", isPointDetector,
- directBeam);
-
- auto instrument = runWS->getInstrument();
-
- const OptionalInteger i0MonitorIndex = checkForOptionalInstrumentDefault<int>(
- this, "I0MonitorIndex", instrument, "I0MonitorIndex");
-
- const OptionalMinMax monitorBackgroundWavelengthInterval = getOptionalMinMax(
- this, "MonitorBackgroundWavelengthMin", "MonitorBackgroundWavelengthMax",
- instrument, "MonitorBackgroundWavelengthMin",
- "MonitorBackgroundWavelengthMax");
- const OptionalMinMax monitorIntegrationWavelengthInterval = getOptionalMinMax(
- this, "MonitorIntegrationWavelengthMin",
- "MonitorIntegrationWavelengthMax", instrument,
- "MonitorIntegrationWavelengthMin", "MonitorIntegrationWavelengthMax");
-
- const bool correctDetectorPositions = getProperty("CorrectDetectorPositions");
-
- MatrixWorkspace_sptr IvsLam; // Output workspace
- MatrixWorkspace_sptr IvsQ; // Output workspace
-
- auto xUnitID = runWS->getAxis(0)->unit()->unitID();
-
- if (xUnitID == "Wavelength") {
- // If the input workspace is in lambda, we don't need to do any corrections,
- // just use it as is.
- g_log.information("Input workspace already in unit 'Wavelength'. Skipping "
- "lambda conversions.");
- IvsLam = runWS;
- } else if (xUnitID == "TOF") {
- // If the input workspace is in TOF, do some corrections and generate IvsLam
- // from it.
- DetectorMonitorWorkspacePair inLam =
- toLam(runWS, processingCommands, i0MonitorIndex, wavelengthInterval,
- monitorBackgroundWavelengthInterval);
- auto detectorWS = inLam.get<0>();
- auto monitorWS = inLam.get<1>();
-
- if (isMultiDetector) {
- if (directBeam.is_initialized()) {
- // Sum over the direct beam.
- WorkspaceIndexList db = directBeam.get();
- std::stringstream buffer;
- buffer << db.front() << "-" << db.back();
- MatrixWorkspace_sptr regionOfDirectBeamWS =
- this->toLamDetector(buffer.str(), runWS, wavelengthInterval);
-
- // Rebin to the detector workspace
- auto rebinToWorkspaceAlg =
- this->createChildAlgorithm("RebinToWorkspace");
- rebinToWorkspaceAlg->initialize();
- rebinToWorkspaceAlg->setProperty("WorkspaceToRebin",
- regionOfDirectBeamWS);
- rebinToWorkspaceAlg->setProperty("WorkspaceToMatch", detectorWS);
- rebinToWorkspaceAlg->execute();
- regionOfDirectBeamWS =
- rebinToWorkspaceAlg->getProperty("OutputWorkspace");
-
- // Normalize by the direct beam.
- detectorWS = divide(detectorWS, regionOfDirectBeamWS);
- }
- }
-
- const bool normalizeByIntMon = getProperty("NormalizeByIntegratedMonitors");
- if (normalizeByIntMon) {
- auto integrationAlg = this->createChildAlgorithm("Integration");
- integrationAlg->initialize();
- integrationAlg->setProperty("InputWorkspace", monitorWS);
- if (monitorIntegrationWavelengthInterval.is_initialized()) {
- integrationAlg->setProperty(
- "RangeLower", monitorIntegrationWavelengthInterval.get().get<0>());
- integrationAlg->setProperty(
- "RangeUpper", monitorIntegrationWavelengthInterval.get().get<1>());
- }
- integrationAlg->execute();
- MatrixWorkspace_sptr integratedMonitor =
- integrationAlg->getProperty("OutputWorkspace");
-
- IvsLam = divide(
- detectorWS,
- integratedMonitor); // Normalize by the integrated monitor counts.
- } else {
- IvsLam = divide(detectorWS, monitorWS);
- }
- } else {
- // Neither TOF or Lambda? Abort.
- throw std::invalid_argument(
- "InputWorkspace must have units of TOF or Wavelength");
- }
-
- if (firstTransmissionRun.is_initialized()) {
- // Perform transmission correction.
- IvsLam = this->transmissonCorrection(
- IvsLam, wavelengthInterval, monitorBackgroundWavelengthInterval,
- monitorIntegrationWavelengthInterval, i0MonitorIndex,
- firstTransmissionRun.get(), secondTransmissionRun, stitchingStart,
- stitchingDelta, stitchingEnd, stitchingStartOverlap,
- stitchingEndOverlap, processingCommands);
- } else if (getPropertyValue("CorrectionAlgorithm") != "None") {
- IvsLam = algorithmicCorrection(IvsLam);
- } else {
- g_log.warning("No transmission correction will be applied.");
- }
-
- IvsQ = this->toIvsQ(IvsLam, correctDetectorPositions, theta, isPointDetector);
- double momentumTransferMinimum = getProperty("MomentumTransferMinimum");
- double momentumTransferStep = getProperty("MomentumTransferStep");
- double momentumTransferMaximum = getProperty("MomentumTransferMaximum");
- MantidVec QParams;
- if (isDefault("MomentumTransferMinimum"))
- momentumTransferMinimum = calculateQ(IvsLam->x(0).back(), theta.get());
- if (isDefault("MomentumTransferMaximum"))
- momentumTransferMaximum = calculateQ(IvsLam->x(0).front(), theta.get());
- if (isDefault("MomentumTransferStep")) {
- // if the DQQ is not given for this run.
- // we will use NRCalculateSlitResolution to produce this value
- // for us.
- IAlgorithm_sptr calcResAlg =
- createChildAlgorithm("NRCalculateSlitResolution");
- calcResAlg->setProperty("Workspace", runWS);
- calcResAlg->setProperty("TwoTheta", theta.get());
- calcResAlg->execute();
- if (!calcResAlg->isExecuted())
- throw std::runtime_error(
- "NRCalculateSlitResolution failed. Please manually "
- "enter a value for MomentumTransferStep.");
- momentumTransferStep = calcResAlg->getProperty("Resolution");
- }
- if (momentumTransferMinimum > momentumTransferMaximum)
- throw std::invalid_argument("MomentumTransferMinimum must be less than "
- "MomentumTransferMaximum. Please check your "
- "inputs for these Properties.");
- QParams.push_back(momentumTransferMinimum);
- QParams.push_back(-momentumTransferStep);
- QParams.push_back(momentumTransferMaximum);
- IAlgorithm_sptr algRebin = this->createChildAlgorithm("Rebin");
- algRebin->initialize();
- algRebin->setProperty("InputWorkspace", IvsQ);
- algRebin->setProperty("OutputWorkspace", IvsQ);
- algRebin->setProperty("Params", QParams);
- algRebin->execute();
- if (!algRebin->isExecuted())
- throw std::runtime_error("Failed to run Rebin algorithm");
- IvsQ = algRebin->getProperty("OutputWorkspace");
- double scaleFactor = getProperty("ScaleFactor");
- if (!isDefault("ScaleFactor")) {
- IAlgorithm_sptr algScale = this->createChildAlgorithm("Scale");
- algScale->initialize();
- algScale->setProperty("InputWorkspace", IvsQ);
- algScale->setProperty("OutputWorkspace", IvsQ);
- algScale->setProperty("Factor", 1.0 / scaleFactor);
- algScale->execute();
- if (!algScale->isExecuted())
- throw std::runtime_error("Failed to run Scale algorithm");
- IvsQ = algScale->getProperty("OutputWorkspace");
- }
- setProperty("ThetaOut", theta.get());
- setProperty("OutputWorkspaceWavelength", IvsLam);
- setProperty("OutputWorkspace", IvsQ);
- // setting these values so the Interface can retrieve them from
- // ReflectometryReductionOneAuto.
- setProperty("MomentumTransferMinimum", momentumTransferMinimum);
- setProperty("MomentumTransferStep", momentumTransferStep);
- setProperty("MomentumTransferMaximum", momentumTransferMaximum);
-}
-
-/**
-* Perform Transmission Corrections.
-* @param IvsLam : Run workspace which is to be normalized by the results of the
-* transmission corrections.
-* @param wavelengthInterval : Wavelength interval for the run workspace.
-* @param wavelengthMonitorBackgroundInterval : Wavelength interval for the
-* monitor background
-* @param wavelengthMonitorIntegrationInterval : Wavelength interval for the
-* monitor integration
-* @param i0MonitorIndex : Monitor index for the I0 monitor
-* @param firstTransmissionRun : The first transmission run
-* @param secondTransmissionRun : The second transmission run (optional)
-* @param stitchingStart : Stitching start in wavelength (optional but dependent
-* on secondTransmissionRun)
-* @param stitchingDelta : Stitching delta in wavelength (optional but dependent
-* on secondTransmissionRun)
-* @param stitchingEnd : Stitching end in wavelength (optional but dependent on
-* secondTransmissionRun)
-* @param stitchingStartOverlap : Stitching start wavelength overlap (optional
-* but dependent on secondTransmissionRun)
-* @param stitchingEndOverlap : Stitching end wavelength overlap (optional but
-* dependent on secondTransmissionRun)
-* @param numeratorProcessingCommands: Processing commands used on detector
-* workspace.
-* @return Normalized run workspace by the transmission workspace, which have
-* themselves been converted to Lam, normalized by monitors and possibly
-* stitched together.
-*/
-MatrixWorkspace_sptr ReflectometryReductionOne::transmissonCorrection(
- MatrixWorkspace_sptr IvsLam, const MinMax &wavelengthInterval,
- const OptionalMinMax &wavelengthMonitorBackgroundInterval,
- const OptionalMinMax &wavelengthMonitorIntegrationInterval,
- const OptionalInteger &i0MonitorIndex,
- MatrixWorkspace_sptr firstTransmissionRun,
- OptionalMatrixWorkspace_sptr secondTransmissionRun,
- const OptionalDouble &stitchingStart, const OptionalDouble &stitchingDelta,
- const OptionalDouble &stitchingEnd,
- const OptionalDouble &stitchingStartOverlap,
- const OptionalDouble &stitchingEndOverlap,
- const std::string &numeratorProcessingCommands) {
- g_log.debug(
- "Extracting first transmission run workspace indexes from spectra");
-
- const bool strictSpectrumChecking = getProperty("StrictSpectrumChecking");
-
- MatrixWorkspace_sptr denominator = firstTransmissionRun;
- Unit_const_sptr xUnit = firstTransmissionRun->getAxis(0)->unit();
- if (xUnit->unitID() == tofUnitId) {
- std::string spectrumProcessingCommands = numeratorProcessingCommands;
- /*
- If we have strict spectrum checking, the processing commands need to be
- made from the
- numerator workspace AND the transmission workspace based on matching
- spectrum numbers.
- */
- if (strictSpectrumChecking) {
- spectrumProcessingCommands =
- createWorkspaceIndexListFromDetectorWorkspace(IvsLam,
- firstTransmissionRun);
- }
-
- // Make the transmission run.
- auto alg = this->createChildAlgorithm("CreateTransmissionWorkspace", -1, -1,
- true, 1);
- alg->initialize();
- alg->setProperty("FirstTransmissionRun", firstTransmissionRun);
- if (secondTransmissionRun.is_initialized()) {
- alg->setProperty("SecondTransmissionRun", secondTransmissionRun.get());
-
- if (stitchingStart.is_initialized() && stitchingEnd.is_initialized() &&
- stitchingDelta.is_initialized()) {
- const std::vector<double> params = {
- stitchingStart.get(), stitchingDelta.get(), stitchingEnd.get()};
- alg->setProperty("Params", params);
- } else if (stitchingDelta.is_initialized()) {
- alg->setProperty("Params",
- std::vector<double>(1, stitchingDelta.get()));
- }
- if (stitchingStartOverlap.is_initialized()) {
- alg->setProperty("StartOverlap", stitchingStartOverlap.get());
- }
- if (stitchingEndOverlap.is_initialized()) {
- alg->setProperty("EndOverlap", stitchingEndOverlap.get());
- }
- }
- alg->setProperty("ProcessingInstructions", spectrumProcessingCommands);
- if (i0MonitorIndex.is_initialized()) {
- alg->setProperty("I0MonitorIndex", i0MonitorIndex.get());
- }
- alg->setProperty("WavelengthMin", wavelengthInterval.get<0>());
- alg->setProperty("WavelengthMax", wavelengthInterval.get<1>());
- if (wavelengthMonitorBackgroundInterval.is_initialized()) {
- alg->setProperty("MonitorBackgroundWavelengthMin",
- wavelengthMonitorBackgroundInterval.get().get<0>());
- alg->setProperty("MonitorBackgroundWavelengthMax",
- wavelengthMonitorBackgroundInterval.get().get<1>());
- }
- if (wavelengthMonitorIntegrationInterval.is_initialized()) {
- alg->setProperty("MonitorIntegrationWavelengthMin",
- wavelengthMonitorIntegrationInterval.get().get<0>());
- alg->setProperty("MonitorIntegrationWavelengthMax",
- wavelengthMonitorIntegrationInterval.get().get<1>());
- }
- alg->execute();
- denominator = alg->getProperty("OutputWorkspace");
- }
-
- // Rebin the transmission run to be the same as the input.
- auto rebinToWorkspaceAlg = this->createChildAlgorithm("RebinToWorkspace");
- rebinToWorkspaceAlg->initialize();
- rebinToWorkspaceAlg->setProperty("WorkspaceToMatch", IvsLam);
- rebinToWorkspaceAlg->setProperty("WorkspaceToRebin", denominator);
- rebinToWorkspaceAlg->execute();
- denominator = rebinToWorkspaceAlg->getProperty("OutputWorkspace");
-
- verifySpectrumMaps(IvsLam, denominator, strictSpectrumChecking);
-
- // Do normalization.
- MatrixWorkspace_sptr normalizedIvsLam = divide(IvsLam, denominator);
- return normalizedIvsLam;
-}
-
-/**
-* Perform transmission correction using alternative correction algorithms.
-* @param IvsLam : Run workspace which is to be normalized by the results of the
-* transmission corrections.
-* @return Corrected workspace
-*/
-MatrixWorkspace_sptr
-ReflectometryReductionOne::algorithmicCorrection(MatrixWorkspace_sptr IvsLam) {
-
- const std::string corrAlgName = getProperty("CorrectionAlgorithm");
-
- IAlgorithm_sptr corrAlg = createChildAlgorithm(corrAlgName);
- corrAlg->initialize();
- if (corrAlgName == "PolynomialCorrection") {
- corrAlg->setPropertyValue("Coefficients", getPropertyValue("Polynomial"));
- } else if (corrAlgName == "ExponentialCorrection") {
- corrAlg->setPropertyValue("C0", getPropertyValue("C0"));
- corrAlg->setPropertyValue("C1", getPropertyValue("C1"));
- } else {
- throw std::runtime_error("Unknown correction algorithm: " + corrAlgName);
- }
-
- corrAlg->setProperty("InputWorkspace", IvsLam);
- corrAlg->setProperty("Operation", "Divide");
- corrAlg->execute();
-
- return corrAlg->getProperty("OutputWorkspace");
-}
-
-/**
-@param ws1 : First workspace to compare
-@param ws2 : Second workspace to compare against
-@param severe: True to indicate that failure to verify should result in an
-exception. Otherwise a warning is generated.
-*/
-void ReflectometryReductionOne::verifySpectrumMaps(
- MatrixWorkspace_const_sptr ws1, MatrixWorkspace_const_sptr ws2,
- const bool severe) {
- auto map1 = ws1->getSpectrumToWorkspaceIndexMap();
- auto map2 = ws2->getSpectrumToWorkspaceIndexMap();
- if (map1 != map2) {
- std::string message = "Spectrum maps between workspaces do NOT match up.";
- if (severe) {
- throw std::invalid_argument(message);
- } else {
- this->g_log.warning(message);
- }
- }
-}
-
-} // namespace Algorithms
-} // namespace Mantid
diff --git a/Framework/Algorithms/src/ReflectometryReductionOneAuto.cpp b/Framework/Algorithms/src/ReflectometryReductionOneAuto.cpp
deleted file mode 100644
index d2a2701bda63b4f12f4ac9a603b86d1ada1277d9..0000000000000000000000000000000000000000
--- a/Framework/Algorithms/src/ReflectometryReductionOneAuto.cpp
+++ /dev/null
@@ -1,848 +0,0 @@
-#include "MantidAlgorithms/BoostOptionalToAlgorithmProperty.h"
-#include "MantidAlgorithms/ReflectometryReductionOneAuto.h"
-#include "MantidAPI/WorkspaceGroup.h"
-#include "MantidAPI/WorkspaceUnitValidator.h"
-#include "MantidKernel/ArrayProperty.h"
-#include "MantidKernel/BoundedValidator.h"
-#include "MantidKernel/EnabledWhenProperty.h"
-#include "MantidKernel/ListValidator.h"
-#include "MantidKernel/RebinParamsValidator.h"
-#include <boost/optional.hpp>
-
-/*Anonymous namespace*/
-namespace {
-/**
-* Helper free function to calculate MomentumTransfer from lambda and theta
-* @param lambda : Value in wavelength
-* @param theta : Value in Degrees
-* @return MomentumTransfer
-* @
-*/
-double calculateQ(double lambda, double theta) {
- if (lambda == 0.0)
- throw std::runtime_error("Minimum/Maximum value of the IvsLambda Workspace "
- "is 0. Cannot calculate Q");
- double thetaInRad = theta * M_PI / 180;
- return (4 * M_PI * sin(thetaInRad)) / lambda;
-}
-}
-/*end of Anonymous namespace*/
-namespace Mantid {
-namespace Algorithms {
-
-using namespace Mantid::Kernel;
-using namespace Mantid::API;
-
-// Register the algorithm into the AlgorithmFactory
-DECLARE_ALGORITHM(ReflectometryReductionOneAuto)
-
-//----------------------------------------------------------------------------------------------
-
-/// Algorithm's name for identification. @see Algorithm::name
-const std::string ReflectometryReductionOneAuto::name() const {
- return "ReflectometryReductionOneAuto";
-}
-
-/// Algorithm's version for identification. @see Algorithm::version
-int ReflectometryReductionOneAuto::version() const { return 1; }
-
-/// Algorithm's category for identification. @see Algorithm::category
-const std::string ReflectometryReductionOneAuto::category() const {
- return "Reflectometry\\ISIS";
-}
-
-/// Algorithm's summary for use in the GUI and help. @see Algorithm::summary
-const std::string ReflectometryReductionOneAuto::summary() const {
- return "Reduces a single TOF/Lambda reflectometry run into a mod Q vs I/I0 "
- "workspace. Performs transmission corrections.";
-}
-
-//----------------------------------------------------------------------------------------------
-/** Initialize the algorithm's properties.
-*/
-void ReflectometryReductionOneAuto::init() {
- declareProperty(
- make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "InputWorkspace", "", Direction::Input, PropertyMode::Mandatory),
- "Input run in TOF or Lambda");
-
- std::vector<std::string> analysis_modes{"PointDetectorAnalysis",
- "MultiDetectorAnalysis"};
- auto analysis_mode_validator =
- boost::make_shared<StringListValidator>(analysis_modes);
-
- declareProperty(
- make_unique<ArrayProperty<int>>("RegionOfDirectBeam", Direction::Input),
- "Indices of the spectra a pair (lower, upper) that mark the ranges that "
- "correspond to the direct beam in multi-detector mode.");
-
- declareProperty("AnalysisMode", analysis_modes[0], analysis_mode_validator,
- "Analysis Mode to Choose", Direction::Input);
-
- declareProperty(
- make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "FirstTransmissionRun", "", Direction::Input, PropertyMode::Optional),
- "First transmission run workspace in TOF or Wavelength");
-
- auto tof_validator = boost::make_shared<WorkspaceUnitValidator>("TOF");
- declareProperty(make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "SecondTransmissionRun", "", Direction::Input,
- PropertyMode::Optional, tof_validator),
- "Second transmission run workspace in TOF");
- declareProperty(make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "OutputWorkspace", "", Direction::Output),
- "Output workspace in wavelength q");
- declareProperty(make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "OutputWorkspaceWavelength", "", Direction::Output),
- "Output workspace in wavelength");
-
- declareProperty(
- make_unique<ArrayProperty<double>>(
- "Params", boost::make_shared<RebinParamsValidator>(true)),
- "A comma separated list of first bin boundary, width, last bin boundary. "
- "These parameters are used for stitching together transmission runs. "
- "Values are in wavelength (angstroms). This input is only needed if a "
- "SecondTransmission run is provided.");
-
- declareProperty("StartOverlap", Mantid::EMPTY_DBL(), "Overlap in Q.",
- Direction::Input);
-
- declareProperty("EndOverlap", Mantid::EMPTY_DBL(), "End overlap in Q.",
- Direction::Input);
- declareProperty("ScaleFactor", 1.0,
- "Factor you wish to scale Q workspace by.", Direction::Input);
- auto index_bounds = boost::make_shared<BoundedValidator<int>>();
- index_bounds->setLower(0);
-
- declareProperty(make_unique<PropertyWithValue<int>>(
- "I0MonitorIndex", Mantid::EMPTY_INT(), Direction::Input),
- "I0 monitor workspace index. Optional.");
- declareProperty(make_unique<PropertyWithValue<std::string>>(
- "ProcessingInstructions", "", Direction::Input),
- "Grouping pattern of workspace indices to yield only the"
- " detectors of interest. See GroupDetectors for syntax.");
- declareProperty("WavelengthMin", Mantid::EMPTY_DBL(),
- "Wavelength Min in angstroms", Direction::Input);
- declareProperty("WavelengthMax", Mantid::EMPTY_DBL(),
- "Wavelength Max in angstroms", Direction::Input);
- declareProperty("WavelengthStep", Mantid::EMPTY_DBL(),
- "Wavelength step in angstroms", Direction::Input);
- declareProperty("MomentumTransferMinimum", Mantid::EMPTY_DBL(),
- "Minimum Q value in IvsQ "
- "Workspace. Used for Rebinning "
- "the IvsQ Workspace",
- Direction::Input);
- declareProperty("MomentumTransferStep", Mantid::EMPTY_DBL(),
- "Resolution value in IvsQ Workspace. Used for Rebinning the "
- "IvsQ Workspace. This value will be made minus to apply "
- "logarithmic rebinning. If you wish to have linear "
- "bin-widths then please provide a negative DQQ",
- Direction::Input);
- declareProperty("MomentumTransferMaximum", Mantid::EMPTY_DBL(),
- "Maximum Q value in IvsQ "
- "Workspace. Used for Rebinning "
- "the IvsQ Workspace",
- Direction::Input);
- declareProperty("MonitorBackgroundWavelengthMin", Mantid::EMPTY_DBL(),
- "Monitor wavelength background min in angstroms",
- Direction::Input);
- declareProperty("MonitorBackgroundWavelengthMax", Mantid::EMPTY_DBL(),
- "Monitor wavelength background max in angstroms",
- Direction::Input);
- declareProperty("MonitorIntegrationWavelengthMin", Mantid::EMPTY_DBL(),
- "Monitor integral min in angstroms", Direction::Input);
- declareProperty("MonitorIntegrationWavelengthMax", Mantid::EMPTY_DBL(),
- "Monitor integral max in angstroms", Direction::Input);
- declareProperty(make_unique<PropertyWithValue<std::string>>(
- "DetectorComponentName", "", Direction::Input),
- "Name of the detector component i.e. point-detector. If "
- "these are not specified, the algorithm will attempt lookup "
- "using a standard naming convention.");
- declareProperty(make_unique<PropertyWithValue<std::string>>(
- "SampleComponentName", "", Direction::Input),
- "Name of the sample component i.e. some-surface-holder. If "
- "these are not specified, the algorithm will attempt lookup "
- "using a standard naming convention.");
-
- declareProperty("ThetaIn", Mantid::EMPTY_DBL(), "Final theta in degrees",
- Direction::Input);
- declareProperty("ThetaOut", Mantid::EMPTY_DBL(),
- "Calculated final theta in degrees.", Direction::Output);
-
- declareProperty("NormalizeByIntegratedMonitors", true,
- "Normalize by dividing by the integrated monitors.");
-
- declareProperty("CorrectDetectorPositions", true,
- "Correct detector positions using ThetaIn (if given)");
-
- declareProperty("StrictSpectrumChecking", true,
- "Strict checking between spectrum numbers in input "
- "workspaces and transmission workspaces.");
- std::vector<std::string> correctionAlgorithms = {
- "None", "AutoDetect", "PolynomialCorrection", "ExponentialCorrection"};
- declareProperty("CorrectionAlgorithm", "AutoDetect",
- boost::make_shared<StringListValidator>(correctionAlgorithms),
- "The type of correction to perform.");
-
- declareProperty(make_unique<ArrayProperty<double>>("Polynomial"),
- "Coefficients to be passed to the PolynomialCorrection"
- " algorithm.");
-
- declareProperty(
- make_unique<PropertyWithValue<double>>("C0", 0.0, Direction::Input),
- "C0 value to be passed to the ExponentialCorrection algorithm.");
-
- declareProperty(
- make_unique<PropertyWithValue<double>>("C1", 0.0, Direction::Input),
- "C1 value to be passed to the ExponentialCorrection algorithm.");
-
- setPropertyGroup("CorrectionAlgorithm", "Polynomial Corrections");
- setPropertyGroup("Polynomial", "Polynomial Corrections");
- setPropertyGroup("C0", "Polynomial Corrections");
- setPropertyGroup("C1", "Polynomial Corrections");
-
- setPropertySettings(
- "Polynomial",
- Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "CorrectionAlgorithm", IS_EQUAL_TO, "PolynomialCorrection"));
- setPropertySettings(
- "C0", Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "CorrectionAlgorithm", IS_EQUAL_TO, "ExponentialCorrection"));
- setPropertySettings(
- "C1", Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "CorrectionAlgorithm", IS_EQUAL_TO, "ExponentialCorrection"));
-
- // Polarization correction inputs --------------
- std::vector<std::string> propOptions;
- propOptions.push_back(noPolarizationCorrectionMode());
- propOptions.push_back(pALabel());
- propOptions.push_back(pNRLabel());
-
- declareProperty("PolarizationAnalysis", noPolarizationCorrectionMode(),
- boost::make_shared<StringListValidator>(propOptions),
- "What Polarization mode will be used?\n"
- "None: No correction\n"
- "PNR: Polarized Neutron Reflectivity mode\n"
- "PA: Full Polarization Analysis PNR-PA");
- declareProperty(
- Kernel::make_unique<ArrayProperty<double>>(cppLabel(), Direction::Input),
- "Effective polarizing power of the polarizing system. "
- "Expressed as a ratio 0 < Pp < 1");
- declareProperty(
- Kernel::make_unique<ArrayProperty<double>>(cApLabel(), Direction::Input),
- "Effective polarizing power of the analyzing system. "
- "Expressed as a ratio 0 < Ap < 1");
- declareProperty(
- Kernel::make_unique<ArrayProperty<double>>(crhoLabel(), Direction::Input),
- "Ratio of efficiencies of polarizer spin-down to polarizer "
- "spin-up. This is characteristic of the polarizer flipper. "
- "Values are constants for each term in a polynomial "
- "expression.");
- declareProperty(Kernel::make_unique<ArrayProperty<double>>(cAlphaLabel(),
- Direction::Input),
- "Ratio of efficiencies of analyzer spin-down to analyzer "
- "spin-up. This is characteristic of the analyzer flipper. "
- "Values are factors for each term in a polynomial "
- "expression.");
- setPropertyGroup("PolarizationAnalysis", "Polarization Corrections");
- setPropertyGroup(cppLabel(), "Polarization Corrections");
- setPropertyGroup(cApLabel(), "Polarization Corrections");
- setPropertyGroup(crhoLabel(), "Polarization Corrections");
- setPropertyGroup(cAlphaLabel(), "Polarization Corrections");
- setPropertySettings(cppLabel(),
- Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "PolarizationAnalysis", IS_NOT_EQUAL_TO,
- noPolarizationCorrectionMode()));
- setPropertySettings(cApLabel(),
- Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "PolarizationAnalysis", IS_NOT_EQUAL_TO,
- noPolarizationCorrectionMode()));
- setPropertySettings(crhoLabel(),
- Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "PolarizationAnalysis", IS_NOT_EQUAL_TO,
- noPolarizationCorrectionMode()));
- setPropertySettings(cAlphaLabel(),
- Kernel::make_unique<Kernel::EnabledWhenProperty>(
- "PolarizationAnalysis", IS_NOT_EQUAL_TO,
- noPolarizationCorrectionMode()));
-}
-
-//----------------------------------------------------------------------------------------------
-/** Execute the algorithm.
-*/
-void ReflectometryReductionOneAuto::exec() {
- MatrixWorkspace_sptr in_ws = getProperty("InputWorkspace");
- auto instrument = in_ws->getInstrument();
-
- // Get all the inputs.
-
- std::string output_workspace_name = getPropertyValue("OutputWorkspace");
- std::string output_workspace_lam_name =
- getPropertyValue("OutputWorkspaceWavelength");
- std::string analysis_mode = getPropertyValue("AnalysisMode");
- MatrixWorkspace_sptr first_ws = getProperty("FirstTransmissionRun");
- MatrixWorkspace_sptr second_ws = getProperty("SecondTransmissionRun");
- auto start_overlap = isSet<double>("StartOverlap");
- auto end_overlap = isSet<double>("EndOverlap");
- auto params = isSet<MantidVec>("Params");
- auto i0_monitor_index = checkForOptionalInstrumentDefault<int>(
- this, "I0MonitorIndex", instrument, "I0MonitorIndex");
-
- std::string processing_commands;
- if (this->getPointerToProperty("ProcessingInstructions")->isDefault()) {
- if (analysis_mode == "PointDetectorAnalysis") {
- std::vector<double> pointStart =
- instrument->getNumberParameter("PointDetectorStart");
- std::vector<double> pointStop =
- instrument->getNumberParameter("PointDetectorStop");
-
- if (pointStart.empty() || pointStop.empty())
- throw std::runtime_error(
- "If ProcessingInstructions is not specified, BOTH "
- "PointDetectorStart "
- "and PointDetectorStop must exist as instrument parameters.\n"
- "Please check if you meant to enter ProcessingInstructions or "
- "if your instrument parameter file is correct.");
-
- const int detStart = static_cast<int>(pointStart[0]);
- const int detStop = static_cast<int>(pointStop[0]);
-
- if (detStart == detStop) {
- // If the range given only specifies one detector, we pass along just
- // that one detector
- processing_commands = std::to_string(detStart);
- } else {
- // Otherwise, we create a range.
- processing_commands =
- std::to_string(detStart) + ":" + std::to_string(detStop);
- }
- } else {
- std::vector<double> multiStart =
- instrument->getNumberParameter("MultiDetectorStart");
- if (multiStart.empty())
- throw std::runtime_error(
- "If ProcessingInstructions is not specified, MultiDetectorStart"
- "must exist as an instrument parameter.\n"
- "Please check if you meant to enter ProcessingInstructions or "
- "if your instrument parameter file is correct.");
- processing_commands = std::to_string(static_cast<int>(multiStart[0])) +
- ":" +
- std::to_string(in_ws->getNumberHistograms() - 1);
- }
- } else {
- std::string processing_commands_temp =
- this->getProperty("ProcessingInstructions");
- processing_commands = processing_commands_temp;
- }
-
- double wavelength_min = checkForMandatoryInstrumentDefault<double>(
- this, "WavelengthMin", instrument, "LambdaMin");
- double wavelength_max = checkForMandatoryInstrumentDefault<double>(
- this, "WavelengthMax", instrument, "LambdaMax");
- auto wavelength_step = isSet<double>("WavelengthStep");
- auto wavelength_back_min = checkForOptionalInstrumentDefault<double>(
- this, "MonitorBackgroundWavelengthMin", instrument,
- "MonitorBackgroundMin");
- auto wavelength_back_max = checkForOptionalInstrumentDefault<double>(
- this, "MonitorBackgroundWavelengthMax", instrument,
- "MonitorBackgroundMax");
- auto wavelength_integration_min = checkForOptionalInstrumentDefault<double>(
- this, "MonitorIntegrationWavelengthMin", instrument,
- "MonitorIntegralMin");
- auto wavelength_integration_max = checkForOptionalInstrumentDefault<double>(
- this, "MonitorIntegrationWavelengthMax", instrument,
- "MonitorIntegralMax");
-
- auto detector_component_name = isSet<std::string>("DetectorComponentName");
- auto sample_component_name = isSet<std::string>("SampleComponentName");
- auto theta_in = isSet<double>("ThetaIn");
- auto region_of_direct_beam = isSet<std::vector<int>>("RegionOfDirectBeam");
-
- bool correct_positions = this->getProperty("CorrectDetectorPositions");
- bool strict_spectrum_checking = this->getProperty("StrictSpectrumChecking");
- bool norm_by_int_mons = getProperty("NormalizeByIntegratedMonitors");
- const std::string correction_algorithm = getProperty("CorrectionAlgorithm");
-
- // Pass the arguments and execute the main algorithm.
-
- IAlgorithm_sptr refRedOne =
- createChildAlgorithm("ReflectometryReductionOne", -1, -1, true, 1);
- refRedOne->initialize();
- if (refRedOne->isInitialized()) {
- refRedOne->setProperty("InputWorkspace", in_ws);
- refRedOne->setProperty("AnalysisMode", analysis_mode);
- refRedOne->setProperty("OutputWorkspace", output_workspace_name);
- refRedOne->setProperty("OutputWorkspaceWavelength",
- output_workspace_lam_name);
- refRedOne->setProperty("NormalizeByIntegratedMonitors", norm_by_int_mons);
-
- if (i0_monitor_index.is_initialized()) {
- if (i0_monitor_index.get() >= 0)
- refRedOne->setProperty("I0MonitorIndex", i0_monitor_index.get());
- else
- throw std::invalid_argument(
- "I0MonitorIndex must be an integer greater than or equal to 0");
- }
- refRedOne->setProperty("ProcessingInstructions", processing_commands);
- refRedOne->setProperty("WavelengthMin", wavelength_min);
- refRedOne->setProperty("WavelengthMax", wavelength_max);
- if (wavelength_back_min.is_initialized())
- refRedOne->setProperty("MonitorBackgroundWavelengthMin",
- wavelength_back_min.get());
- if (wavelength_back_max.is_initialized())
- refRedOne->setProperty("MonitorBackgroundWavelengthMax",
- wavelength_back_max.get());
- if (wavelength_integration_min.is_initialized())
- refRedOne->setProperty("MonitorIntegrationWavelengthMin",
- wavelength_integration_min.get());
- if (wavelength_integration_max.is_initialized())
- refRedOne->setProperty("MonitorIntegrationWavelengthMax",
- wavelength_integration_max.get());
- refRedOne->setProperty("CorrectDetectorPositions", correct_positions);
- refRedOne->setProperty("StrictSpectrumChecking", strict_spectrum_checking);
- if (correction_algorithm == "PolynomialCorrection") {
- // Copy across the polynomial
- refRedOne->setProperty("CorrectionAlgorithm", "PolynomialCorrection");
- refRedOne->setProperty("Polynomial", getPropertyValue("Polynomial"));
- } else if (correction_algorithm == "ExponentialCorrection") {
- // Copy across c0 and c1
- refRedOne->setProperty("CorrectionAlgorithm", "ExponentialCorrection");
- refRedOne->setProperty("C0", getPropertyValue("C0"));
- refRedOne->setProperty("C1", getPropertyValue("C1"));
- } else if (correction_algorithm == "AutoDetect") {
- // Figure out what to do from the instrument
- try {
- auto inst = in_ws->getInstrument();
-
- const std::vector<std::string> corrVec =
- inst->getStringParameter("correction");
- const std::string correctionStr = !corrVec.empty() ? corrVec[0] : "";
-
- if (correctionStr.empty())
- throw std::runtime_error(
- "'correction' instrument parameter was not found.");
-
- const std::vector<std::string> polyVec =
- inst->getStringParameter("polynomial");
- const std::string polyStr = !polyVec.empty() ? polyVec[0] : "";
-
- const std::vector<std::string> c0Vec = inst->getStringParameter("C0");
- const std::string c0Str = !c0Vec.empty() ? c0Vec[0] : "";
-
- const std::vector<std::string> c1Vec = inst->getStringParameter("C1");
- const std::string c1Str = !c1Vec.empty() ? c1Vec[0] : "";
-
- if (correctionStr == "polynomial" && polyStr.empty())
- throw std::runtime_error(
- "'polynomial' instrument parameter was not found.");
-
- if (correctionStr == "exponential" && (c0Str.empty() || c1Str.empty()))
- throw std::runtime_error(
- "'C0' or 'C1' instrument parameter was not found.");
-
- if (correctionStr == "polynomial") {
- refRedOne->setProperty("CorrectionAlgorithm", "PolynomialCorrection");
- refRedOne->setProperty("Polynomial", polyStr);
- } else if (correctionStr == "exponential") {
- refRedOne->setProperty("CorrectionAlgorithm",
- "ExponentialCorrection");
- refRedOne->setProperty("C0", c0Str);
- refRedOne->setProperty("C1", c1Str);
- }
-
- } catch (std::runtime_error &e) {
- g_log.warning() << "Could not autodetect polynomial correction method. "
- "Polynomial correction will not be performed. "
- "Reason for failure: " << e.what() << '\n';
- refRedOne->setProperty("CorrectionAlgorithm", "None");
- }
-
- } else {
- // None was selected
- refRedOne->setProperty("CorrectionAlgorithm", "None");
- }
-
- if (first_ws) {
- refRedOne->setProperty("FirstTransmissionRun", first_ws);
- }
-
- if (second_ws) {
- refRedOne->setProperty("SecondTransmissionRun", second_ws);
- }
-
- if (start_overlap.is_initialized()) {
- refRedOne->setProperty("StartOverlap", start_overlap.get());
- }
-
- if (end_overlap.is_initialized()) {
- refRedOne->setProperty("EndOverlap", end_overlap.get());
- }
-
- if (params.is_initialized()) {
- refRedOne->setProperty("Params", params.get());
- }
-
- if (wavelength_step.is_initialized()) {
- refRedOne->setProperty("WavelengthStep", wavelength_step.get());
- }
-
- if (region_of_direct_beam.is_initialized()) {
- refRedOne->setProperty("RegionOfDirectBeam", region_of_direct_beam.get());
- }
-
- if (detector_component_name.is_initialized()) {
- refRedOne->setProperty("DetectorComponentName",
- detector_component_name.get());
- }
-
- if (sample_component_name.is_initialized()) {
- refRedOne->setProperty("SampleComponentName",
- sample_component_name.get());
- }
-
- if (theta_in.is_initialized()) {
- refRedOne->setProperty("ThetaIn", theta_in.get());
- }
- double scaleFactor = getProperty("ScaleFactor");
- if (scaleFactor != 1.0) {
- refRedOne->setProperty("ScaleFactor", scaleFactor);
- }
- auto momentumTransferMinimum = isSet<double>("MomentumTransferMinimum");
- auto momentumTransferStep = isSet<double>("MomentumTransferStep");
- auto momentumTransferMaximum = isSet<double>("MomentumTransferMaximum");
-
- if (momentumTransferStep.is_initialized()) {
- refRedOne->setProperty("MomentumTransferStep",
- momentumTransferStep.get());
- }
- if (momentumTransferMinimum.is_initialized())
- refRedOne->setProperty("MomentumTransferMinimum",
- momentumTransferMinimum.get());
- if (momentumTransferMaximum.is_initialized())
- refRedOne->setProperty("MomentumTransferMaximum",
- momentumTransferMaximum.get());
- if (theta_in.is_initialized()) {
- if (!momentumTransferMinimum.is_initialized())
- momentumTransferMinimum = calculateQ(wavelength_max, theta_in.get());
- if (!momentumTransferStep.is_initialized()) {
- IAlgorithm_sptr calcResAlg =
- AlgorithmManager::Instance().create("NRCalculateSlitResolution");
- calcResAlg->setProperty("Workspace", in_ws);
- calcResAlg->setProperty("TwoTheta", theta_in.get());
- calcResAlg->execute();
- if (!calcResAlg->isExecuted())
- throw std::runtime_error(
- "NRCalculateSlitResolution failed. Please manually "
- "enter a value in the dQ/Q column.");
- double resolution = calcResAlg->getProperty("Resolution");
- momentumTransferStep = resolution;
- }
- if (!momentumTransferMaximum.is_initialized())
- momentumTransferMaximum = calculateQ(wavelength_min, theta_in.get());
- refRedOne->setProperty("MomentumTransferMinimum",
- momentumTransferMinimum.get());
- refRedOne->setProperty("MomentumTransferStep",
- momentumTransferStep.get());
- refRedOne->setProperty("MomentumTransferMaximum",
- momentumTransferMaximum.get());
- }
- refRedOne->execute();
- if (!refRedOne->isExecuted()) {
- throw std::runtime_error(
- "ReflectometryReductionOne did not execute sucessfully");
- }
-
- MatrixWorkspace_sptr new_IvsQ1 = refRedOne->getProperty("OutputWorkspace");
- MatrixWorkspace_sptr new_IvsLam1 =
- refRedOne->getProperty("OutputWorkspaceWavelength");
- double thetaOut1 = refRedOne->getProperty("ThetaOut");
- setProperty("OutputWorkspace", new_IvsQ1);
- setProperty("OutputWorkspaceWavelength", new_IvsLam1);
- setProperty("ThetaOut", thetaOut1);
- // set properties so they can be retrieved by GenericDataProcesser if
- // necessary.
- setProperty("MomentumTransferMinimum",
- boost::lexical_cast<double>(
- refRedOne->getPropertyValue("MomentumTransferMinimum")));
- setProperty("MomentumTransferStep",
- boost::lexical_cast<double>(
- refRedOne->getPropertyValue("MomentumTransferStep")));
- setProperty("MomentumTransferMaximum",
- boost::lexical_cast<double>(
- refRedOne->getPropertyValue("MomentumTransferMaximum")));
- if (theta_in.is_initialized())
- setProperty("ThetaIn", theta_in.get());
- else
- setProperty("ThetaIn", thetaOut1 / 2.);
-
- } else {
- throw std::runtime_error(
- "ReflectometryReductionOne could not be initialised");
- }
-}
-
-template <typename T>
-boost::optional<T>
-ReflectometryReductionOneAuto::isSet(std::string propName) const {
- auto algProperty = this->getPointerToProperty(propName);
- if (algProperty->isDefault()) {
- return boost::optional<T>();
- } else {
- T value = this->getProperty(propName);
- return boost::optional<T>(value);
- }
-}
-
-bool ReflectometryReductionOneAuto::checkGroups() {
- std::string wsName = getPropertyValue("InputWorkspace");
-
- try {
- auto ws =
- AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(wsName);
- if (ws)
- return true;
- } catch (...) {
- }
- return false;
-}
-/**
- * Sum over transmission group workspaces to produce one
- * workspace.
- * @param transGroup : The transmission group to be processed
- * @return A workspace pointer containing the sum of transmission workspaces.
- */
-Mantid::API::Workspace_sptr
-ReflectometryReductionOneAuto::sumOverTransmissionGroup(
- WorkspaceGroup_sptr &transGroup) {
- // Handle transmission runs
-
- // we clone the first member of transmission group as to
- // avoid addition in place which would affect the original
- // workspace member.
- //
- // We used .release because clone() will return a unique_ptr.
- // we need to release the ownership of the pointer so that it
- // can be cast into a shared_ptr of type Workspace.
- Workspace_sptr transmissionRunSum(transGroup->getItem(0)->clone());
-
- // make a variable to store the overall total of the summation
- MatrixWorkspace_sptr total;
- // set up and initialize plus algorithm.
- auto plusAlg = this->createChildAlgorithm("Plus");
- plusAlg->setChild(true);
- // plusAlg->setRethrows(true);
- plusAlg->initialize();
- // now accumalate the group members
- for (size_t item = 1; item < transGroup->size(); ++item) {
- plusAlg->setProperty("LHSWorkspace", transmissionRunSum);
- plusAlg->setProperty("RHSWorkspace", transGroup->getItem(item));
- plusAlg->setProperty("OutputWorkspace", transmissionRunSum);
- plusAlg->execute();
- total = plusAlg->getProperty("OutputWorkspace");
- }
- return total;
-}
-
-bool ReflectometryReductionOneAuto::processGroups() {
- // isPolarizationCorrectionOn is used to decide whether
- // we should process our Transmission WorkspaceGroup members
- // as individuals (not multiperiod) when PolarizationCorrection is off,
- // or sum over all of the workspaces in the group
- // and used that sum as our TransmissionWorkspace when PolarizationCorrection
- // is on.
- const bool isPolarizationCorrectionOn =
- this->getPropertyValue("PolarizationAnalysis") !=
- noPolarizationCorrectionMode();
-
- // this algorithm effectively behaves as MultiPeriodGroupAlgorithm
- m_usingBaseProcessGroups = true;
-
- // Get our input workspace group
- auto group = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
- getPropertyValue("InputWorkspace"));
- // Get name of IvsQ workspace
- const std::string outputIvsQ = this->getPropertyValue("OutputWorkspace");
- // Get name of IvsLam workspace
- const std::string outputIvsLam =
- this->getPropertyValue("OutputWorkspaceWavelength");
-
- // Create a copy of ourselves
- Algorithm_sptr alg = this->createChildAlgorithm(
- this->name(), -1, -1, this->isLogging(), this->version());
- alg->setChild(false);
- alg->setRethrows(true);
-
- // Copy all the non-workspace properties over
- std::vector<Property *> props = this->getProperties();
- for (auto &prop : props) {
- if (prop) {
- IWorkspaceProperty *wsProp = dynamic_cast<IWorkspaceProperty *>(prop);
- if (!wsProp)
- alg->setPropertyValue(prop->name(), prop->value());
- }
- }
-
- // Check if the transmission runs are groups or not
- const std::string firstTrans = this->getPropertyValue("FirstTransmissionRun");
- WorkspaceGroup_sptr firstTransG;
- if (!firstTrans.empty()) {
- auto firstTransWS =
- AnalysisDataService::Instance().retrieveWS<Workspace>(firstTrans);
- firstTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(firstTransWS);
-
- if (!firstTransG) {
- // we only have one transmission workspace, so we use it as it is.
- alg->setProperty("FirstTransmissionRun", firstTrans);
- } else if (group->size() != firstTransG->size() &&
- !isPolarizationCorrectionOn) {
- // if they are not the same size then we cannot associate a transmission
- // group workspace member with every input group workpspace member.
- throw std::runtime_error("FirstTransmissionRun WorkspaceGroup must be "
- "the same size as the InputWorkspace "
- "WorkspaceGroup");
- }
- }
-
- const std::string secondTrans =
- this->getPropertyValue("SecondTransmissionRun");
- WorkspaceGroup_sptr secondTransG;
- if (!secondTrans.empty()) {
- auto secondTransWS =
- AnalysisDataService::Instance().retrieveWS<Workspace>(secondTrans);
- secondTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(secondTransWS);
-
- if (!secondTransG)
- // we only have one transmission workspace, so we use it as it is.
- alg->setProperty("SecondTransmissionRun", secondTrans);
-
- else if (group->size() != secondTransG->size() &&
- !isPolarizationCorrectionOn) {
- // if they are not the same size then we cannot associate a transmission
- // group workspace member with every input group workpspace member.
- throw std::runtime_error("SecondTransmissionRun WorkspaceGroup must be "
- "the same size as the InputWorkspace "
- "WorkspaceGroup");
- }
- }
- std::vector<std::string> IvsQGroup, IvsLamGroup;
-
- // Execute algorithm over each group member (or period, if this is
- // multiperiod)
- size_t numMembers = group->size();
- for (size_t i = 0; i < numMembers; ++i) {
- const std::string IvsQName = outputIvsQ + "_" + std::to_string(i + 1);
- const std::string IvsLamName = outputIvsLam + "_" + std::to_string(i + 1);
-
- // If our transmission run is a group and PolarizationCorrection is on
- // then we sum our transmission group members.
- //
- // This is done inside of the for loop to avoid the wrong workspace being
- // used when these arguments are passed through to the exec() method.
- // If this is not set in the loop, exec() will fetch the first workspace
- // from the specified Transmission Group workspace that the user entered.
- if (firstTransG && isPolarizationCorrectionOn) {
- auto firstTransmissionSum = sumOverTransmissionGroup(firstTransG);
- alg->setProperty("FirstTransmissionRun", firstTransmissionSum);
- }
- if (secondTransG && isPolarizationCorrectionOn) {
- auto secondTransmissionSum = sumOverTransmissionGroup(secondTransG);
- alg->setProperty("SecondTransmissionRun", secondTransmissionSum);
- }
-
- // Otherwise, if polarization correction is off, we process them
- // using one transmission group member at a time.
- if (firstTransG && !isPolarizationCorrectionOn) // polarization off
- alg->setProperty("FirstTransmissionRun",
- firstTransG->getItem(i)->getName());
- if (secondTransG && !isPolarizationCorrectionOn) // polarization off
- alg->setProperty("SecondTransmissionRun",
- secondTransG->getItem(i)->getName());
-
- alg->setProperty("InputWorkspace", group->getItem(i)->getName());
- alg->setProperty("OutputWorkspace", IvsQName);
- alg->setProperty("OutputWorkspaceWavelength", IvsLamName);
- alg->execute();
-
- MatrixWorkspace_sptr tempFirstTransWS =
- alg->getProperty("FirstTransmissionRun");
-
- IvsQGroup.push_back(IvsQName);
- IvsLamGroup.push_back(IvsLamName);
-
- // We use the first group member for our thetaout value
- if (i == 0)
- this->setPropertyValue("ThetaOut", alg->getPropertyValue("ThetaOut"));
- }
-
- // Group the IvsQ and IvsLam workspaces
- Algorithm_sptr groupAlg = this->createChildAlgorithm("GroupWorkspaces");
- groupAlg->setChild(false);
- groupAlg->setRethrows(true);
-
- groupAlg->setProperty("InputWorkspaces", IvsLamGroup);
- groupAlg->setProperty("OutputWorkspace", outputIvsLam);
- groupAlg->execute();
-
- groupAlg->setProperty("InputWorkspaces", IvsQGroup);
- groupAlg->setProperty("OutputWorkspace", outputIvsQ);
- groupAlg->execute();
-
- // If this is a multiperiod workspace and we have polarization corrections
- // enabled
- if (isPolarizationCorrectionOn) {
- if (group->isMultiperiod()) {
- // Perform polarization correction over the IvsLam group
- Algorithm_sptr polAlg =
- this->createChildAlgorithm("PolarizationCorrection");
- polAlg->setChild(false);
- polAlg->setRethrows(true);
-
- polAlg->setProperty("InputWorkspace", outputIvsLam);
- polAlg->setProperty("OutputWorkspace", outputIvsLam);
- polAlg->setProperty("PolarizationAnalysis",
- this->getPropertyValue("PolarizationAnalysis"));
- polAlg->setProperty("CPp", this->getPropertyValue(cppLabel()));
- polAlg->setProperty("CRho", this->getPropertyValue(crhoLabel()));
- polAlg->setProperty("CAp", this->getPropertyValue(cApLabel()));
- polAlg->setProperty("CAlpha", this->getPropertyValue(cAlphaLabel()));
- polAlg->execute();
-
- // Now we've overwritten the IvsLam workspaces, we'll need to recalculate
- // the IvsQ ones
- alg->setProperty("FirstTransmissionRun", "");
- alg->setProperty("SecondTransmissionRun", "");
- for (size_t i = 0; i < numMembers; ++i) {
- const std::string IvsQName = outputIvsQ + "_" + std::to_string(i + 1);
- const std::string IvsLamName =
- outputIvsLam + "_" + std::to_string(i + 1);
- alg->setProperty("InputWorkspace", IvsLamName);
- alg->setProperty("OutputWorkspace", IvsQName);
- alg->setProperty("CorrectionAlgorithm", "None");
- alg->setProperty("OutputWorkspaceWavelength", IvsLamName);
- alg->execute();
- }
- } else {
- g_log.warning("Polarization corrections can only be performed on "
- "multiperiod workspaces.");
- }
- }
-
- // We finished successfully
- // set the values of these properties so they can be retrieved by the
- // Interface.
- this->setProperty("MomentumTransferMinimum",
- boost::lexical_cast<double>(
- alg->getPropertyValue("MomentumTransferMinimum")));
- this->setProperty("MomentumTransferStep",
- boost::lexical_cast<double>(
- alg->getPropertyValue("MomentumTransferStep")));
- this->setProperty("MomentumTransferMaximum",
- boost::lexical_cast<double>(
- alg->getPropertyValue("MomentumTransferMaximum")));
- // setting output properties.
- this->setPropertyValue("OutputWorkspace", outputIvsQ);
- this->setPropertyValue("OutputWorkspaceWavelength", outputIvsLam);
- return true;
-}
-} // namespace Algorithms
-} // namespace Mantid
diff --git a/Framework/Algorithms/test/CreateTransmissionWorkspaceTest.h b/Framework/Algorithms/test/CreateTransmissionWorkspaceTest.h
index 9f715efd114ee6cd38c1f9eaa01e34482070dcbd..8b524bcdf6a3a88e1e33b809991dfdbe62553238 100644
--- a/Framework/Algorithms/test/CreateTransmissionWorkspaceTest.h
+++ b/Framework/Algorithms/test/CreateTransmissionWorkspaceTest.h
@@ -10,7 +10,6 @@
#include <cxxtest/TestSuite.h>
#include <algorithm>
-#include "MantidAlgorithms/ReflectometryReductionOne.h"
#include "MantidAPI/AlgorithmManager.h"
#include "MantidAPI/Axis.h"
#include "MantidAPI/FrameworkManager.h"
@@ -22,7 +21,6 @@
using namespace Mantid;
using namespace Mantid::Kernel;
using namespace Mantid::API;
-using namespace Mantid::Algorithms;
using namespace WorkspaceCreationHelper;
class CreateTransmissionWorkspaceTest : public CxxTest::TestSuite {
diff --git a/Framework/Algorithms/test/ReflectometryReductionOneAuto2Test.h b/Framework/Algorithms/test/ReflectometryReductionOneAuto2Test.h
index 7faa8beb0c14086329b187589b22f22070a5227f..328fd8d98ea89de92988c67e1981416f07747db4 100644
--- a/Framework/Algorithms/test/ReflectometryReductionOneAuto2Test.h
+++ b/Framework/Algorithms/test/ReflectometryReductionOneAuto2Test.h
@@ -244,7 +244,7 @@ public:
alg.setProperty("OutputWorkspace", "IvsQ");
alg.setProperty("OutputWorkspaceBinned", "IvsQ_binned");
alg.setProperty("OutputWorkspaceWavelength", "IvsLam");
- alg.setProperty("ProcessingInstructions", "3:4");
+ alg.setProperty("ProcessingInstructions", "3");
alg.execute();
MatrixWorkspace_sptr out = alg.getProperty("OutputWorkspace");
@@ -270,26 +270,17 @@ public:
TS_ASSERT_EQUALS(instIn->getComponentByName("linear-detector")->getPos(),
instOut->getComponentByName("linear-detector")->getPos());
- // Only 'point-detector' and 'point-detector2' should have been moved
- // vertically (along Y)
+ // Only 'point-detector' should have been moved vertically (along Y)
auto point1In = instIn->getComponentByName("point-detector")->getPos();
- auto point2In = instIn->getComponentByName("point-detector2")->getPos();
auto point1Out = instOut->getComponentByName("point-detector")->getPos();
- auto point2Out = instOut->getComponentByName("point-detector2")->getPos();
TS_ASSERT_EQUALS(point1In.X(), point1Out.X());
TS_ASSERT_EQUALS(point1In.Z(), point1Out.Z());
- TS_ASSERT_EQUALS(point2In.X(), point2Out.X());
- TS_ASSERT_EQUALS(point2In.Z(), point2Out.Z());
TS_ASSERT_DIFFERS(point1In.Y(), point1Out.Y());
- TS_ASSERT_DIFFERS(point2In.Y(), point2Out.Y());
TS_ASSERT_DELTA(point1Out.Y() /
(point1Out.Z() - instOut->getSample()->getPos().Z()),
std::tan(theta * 2 * M_PI / 180), 1e-4);
- TS_ASSERT_DELTA(point2Out.Y() /
- (point2Out.Z() - instOut->getSample()->getPos().Z()),
- std::tan(theta * 2 * M_PI / 180), 1e-4);
}
void test_correct_detector_position_rotation_POLREF() {
@@ -399,7 +390,7 @@ public:
alg.setProperty("OutputWorkspace", "IvsQ");
alg.setProperty("OutputWorkspaceBinned", "IvsQ_binned");
alg.setProperty("OutputWorkspaceWavelength", "IvsLam");
- alg.setProperty("ProcessingInstructions", "3:4");
+ alg.setProperty("ProcessingInstructions", "3");
alg.execute();
MatrixWorkspace_sptr corrected = alg.getProperty("OutputWorkspace");
@@ -417,26 +408,18 @@ public:
TS_ASSERT_EQUALS(instIn->getComponentByName("linear-detector")->getPos(),
instOut->getComponentByName("linear-detector")->getPos());
- // Only 'point-detector' and 'point-detector2' should have been moved
+ // Only 'point-detector' should have been moved
// vertically (along Y)
auto point1In = instIn->getComponentByName("point-detector")->getPos();
- auto point2In = instIn->getComponentByName("point-detector2")->getPos();
auto point1Out = instOut->getComponentByName("point-detector")->getPos();
- auto point2Out = instOut->getComponentByName("point-detector2")->getPos();
TS_ASSERT_EQUALS(point1In.X(), point1Out.X());
TS_ASSERT_EQUALS(point1In.Z(), point1Out.Z());
- TS_ASSERT_EQUALS(point2In.X(), point2Out.X());
- TS_ASSERT_EQUALS(point2In.Z(), point2Out.Z());
TS_ASSERT_DIFFERS(point1In.Y(), point1Out.Y());
- TS_ASSERT_DIFFERS(point2In.Y(), point2Out.Y());
TS_ASSERT_DELTA(point1Out.Y() /
(point1Out.Z() - instOut->getSample()->getPos().Z()),
std::tan(theta * 2 * M_PI / 180), 1e-4);
- TS_ASSERT_DELTA(point2Out.Y() /
- (point2Out.Z() - instOut->getSample()->getPos().Z()),
- std::tan(theta * 2 * M_PI / 180), 1e-4);
}
void test_override_ThetaIn_without_correcting_detectors() {
@@ -452,7 +435,7 @@ public:
alg.setProperty("OutputWorkspace", "IvsQ");
alg.setProperty("OutputWorkspaceBinned", "IvsQ_binned");
alg.setProperty("OutputWorkspaceWavelength", "IvsLam");
- alg.setProperty("ProcessingInstructions", "3:4");
+ alg.setProperty("ProcessingInstructions", "3");
alg.execute();
MatrixWorkspace_sptr corrected = alg.getProperty("OutputWorkspace");
@@ -463,12 +446,9 @@ public:
// the detectors should not have been moved
auto point1In = instIn->getComponentByName("point-detector")->getPos();
- auto point2In = instIn->getComponentByName("point-detector2")->getPos();
auto point1Out = instOut->getComponentByName("point-detector")->getPos();
- auto point2Out = instOut->getComponentByName("point-detector2")->getPos();
TS_ASSERT_EQUALS(point1In, point1Out);
- TS_ASSERT_EQUALS(point2In, point2Out);
}
void test_sum_transmission_workspaces() {
diff --git a/Framework/Algorithms/test/ReflectometryReductionOneAutoTest.h b/Framework/Algorithms/test/ReflectometryReductionOneAutoTest.h
deleted file mode 100644
index 4a452f1ee0f0a5e51badcca4bbe05ddb422701a9..0000000000000000000000000000000000000000
--- a/Framework/Algorithms/test/ReflectometryReductionOneAutoTest.h
+++ /dev/null
@@ -1,798 +0,0 @@
-#ifndef MANTID_ALGORITHMS_REFLECTOMETRYREDUCTIONONEAUTOTEST_H_
-#define MANTID_ALGORITHMS_REFLECTOMETRYREDUCTIONONEAUTOTEST_H_
-
-#include <cxxtest/TestSuite.h>
-
-#include "MantidAPI/AlgorithmManager.h"
-#include "MantidAPI/Axis.h"
-#include "MantidAPI/FrameworkManager.h"
-#include "MantidAPI/WorkspaceGroup.h"
-#include "MantidAPI/WorkspaceHistory.h"
-#include "MantidAlgorithms/ReflectometryReductionOneAuto.h"
-#include "MantidGeometry/Instrument.h"
-#include "MantidGeometry/Instrument/ReferenceFrame.h"
-#include "MantidKernel/Unit.h"
-#include "MantidTestHelpers/WorkspaceCreationHelper.h"
-
-using Mantid::Algorithms::ReflectometryReductionOneAuto;
-using namespace Mantid::API;
-using namespace Mantid::DataObjects;
-using namespace Mantid::Geometry;
-using namespace Mantid::Kernel;
-using Mantid::MantidVec;
-using Mantid::MantidVecPtr;
-using Mantid::HistogramData::BinEdges;
-
-namespace {
-class PropertyFinder {
-private:
- const std::string m_propertyName;
-
-public:
- PropertyFinder(const std::string &propertyName)
- : m_propertyName(propertyName) {}
- bool operator()(const PropertyHistories::value_type &candidate) const {
- return candidate->name() == m_propertyName;
- }
-};
-
-template <typename T>
-T findPropertyValue(PropertyHistories &histories,
- const std::string &propertyName) {
- PropertyFinder finder(propertyName);
- auto it = std::find_if(histories.begin(), histories.end(), finder);
- return boost::lexical_cast<T>((*it)->value());
-}
-}
-
-class ReflectometryReductionOneAutoTest : 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 ReflectometryReductionOneAutoTest *createSuite() {
- return new ReflectometryReductionOneAutoTest();
- }
- static void destroySuite(ReflectometryReductionOneAutoTest *suite) {
- delete suite;
- }
-
- MatrixWorkspace_sptr m_TOF;
- MatrixWorkspace_sptr m_NotTOF;
- MatrixWorkspace_sptr m_dataWorkspace;
- MatrixWorkspace_sptr m_transWorkspace1;
- MatrixWorkspace_sptr m_transWorkspace2;
- WorkspaceGroup_sptr m_multiDetectorWorkspace;
- const std::string outWSQName;
- const std::string outWSLamName;
- const std::string inWSName;
- const std::string transWSName;
-
- ReflectometryReductionOneAutoTest()
- : outWSQName("ReflectometryReductionOneAutoTest_OutputWS_Q"),
- outWSLamName("ReflectometryReductionOneAutoTest_OutputWS_Lam"),
- inWSName("ReflectometryReductionOneAutoTest_InputWS"),
- transWSName("ReflectometryReductionOneAutoTest_TransWS") {
- MantidVec xData = {0, 0, 0, 0};
- MantidVec yData = {0, 0, 0};
-
- auto createWorkspace =
- AlgorithmManager::Instance().create("CreateWorkspace");
- createWorkspace->initialize();
- createWorkspace->setProperty("UnitX", "1/q");
- createWorkspace->setProperty("DataX", xData);
- createWorkspace->setProperty("DataY", yData);
- createWorkspace->setProperty("NSpec", 1);
- createWorkspace->setPropertyValue("OutputWorkspace", "NotTOF");
- createWorkspace->execute();
- m_NotTOF =
- AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("NotTOF");
-
- createWorkspace->setProperty("UnitX", "TOF");
- createWorkspace->setProperty("DataX", xData);
- createWorkspace->setProperty("DataY", yData);
- createWorkspace->setProperty("NSpec", 1);
- createWorkspace->setPropertyValue("OutputWorkspace", "TOF");
- createWorkspace->execute();
- m_TOF = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("TOF");
-
- IAlgorithm_sptr lAlg = AlgorithmManager::Instance().create("Load");
- lAlg->setChild(true);
- lAlg->initialize();
- lAlg->setProperty("Filename", "INTER00013460.nxs");
- lAlg->setPropertyValue("OutputWorkspace", "demo_ws");
- lAlg->execute();
- Workspace_sptr temp = lAlg->getProperty("OutputWorkspace");
- m_dataWorkspace = boost::dynamic_pointer_cast<MatrixWorkspace>(temp);
- // m_dataWorkspace =
- // AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("data_ws");
-
- lAlg->setProperty("Filename", "INTER00013463.nxs");
- lAlg->setPropertyValue("OutputWorkspace", "trans_ws_1");
- lAlg->execute();
- temp = lAlg->getProperty("OutputWorkspace");
- m_transWorkspace1 = boost::dynamic_pointer_cast<MatrixWorkspace>(temp);
- // m_transWorkspace1 =
- // AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("trans_ws_1");
-
- lAlg->setProperty("Filename", "INTER00013464.nxs");
- lAlg->setPropertyValue("OutputWorkspace", "trans_ws_2");
- lAlg->execute();
- temp = lAlg->getProperty("OutputWorkspace");
- m_transWorkspace2 = boost::dynamic_pointer_cast<MatrixWorkspace>(temp);
- // m_transWorkspace2 =
- // AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("trans_ws_2");
-
- lAlg->setPropertyValue("Filename", "POLREF00004699.nxs");
- lAlg->setPropertyValue("OutputWorkspace", "multidetector_ws_1");
- lAlg->execute();
- temp = lAlg->getProperty("OutputWorkspace");
- m_multiDetectorWorkspace =
- boost::dynamic_pointer_cast<WorkspaceGroup>(temp);
- AnalysisDataService::Instance().addOrReplace("multidetector_group",
- m_multiDetectorWorkspace);
- }
- ~ReflectometryReductionOneAutoTest() override {
- AnalysisDataService::Instance().remove("TOF");
- AnalysisDataService::Instance().remove("NotTOF");
- AnalysisDataService::Instance().remove("multidetector_group");
- AnalysisDataService::Instance().remove("multidetector_group_1");
- AnalysisDataService::Instance().remove("multidetector_group_2");
- }
-
- IAlgorithm_sptr construct_standard_algorithm() {
- auto alg =
- AlgorithmManager::Instance().create("ReflectometryReductionOneAuto", 1);
- alg->initialize();
- alg->setProperty("InputWorkspace", m_TOF);
- alg->setProperty("WavelengthMin", 0.0);
- alg->setProperty("WavelengthMax", 1.0);
- alg->setProperty("I0MonitorIndex", 0);
- alg->setProperty("MonitorBackgroundWavelengthMin", 0.0);
- alg->setProperty("MonitorBackgroundWavelengthMax", 1.0);
- alg->setProperty("MonitorIntegrationWavelengthMin", 0.0);
- alg->setProperty("MonitorIntegrationWavelengthMax", 1.0);
- alg->setProperty("MomentumTransferStep", 0.1);
- alg->setPropertyValue("ProcessingInstructions", "0");
- alg->setPropertyValue("OutputWorkspace", outWSQName);
- alg->setPropertyValue("OutputWorkspaceWavelength", outWSLamName);
- alg->setRethrows(true);
- return alg;
- }
-
- void test_Init() {
- ReflectometryReductionOneAuto alg;
- TS_ASSERT_THROWS_NOTHING(alg.initialize());
- TS_ASSERT(alg.isInitialized());
- }
-
- void test_check_input_workpace_not_tof_or_wavelength_throws() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("InputWorkspace", m_NotTOF);
- TS_ASSERT_THROWS(alg->execute(), std::invalid_argument);
- }
-
- void test_check_first_transmission_workspace_not_tof_or_wavelength_throws() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("FirstTransmissionRun", m_NotTOF);
- TS_ASSERT_THROWS(alg->execute(), std::invalid_argument);
- }
-
- void test_check_second_transmission_workspace_not_tof_throws() {
- auto alg = construct_standard_algorithm();
- TS_ASSERT_THROWS(alg->setProperty("SecondTransmissionRun", m_NotTOF),
- std::invalid_argument);
- }
-
- void test_proivde_second_transmission_run_without_first_throws() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("SecondTransmissionRun", m_TOF);
- TS_ASSERT_THROWS(alg->execute(), std::invalid_argument);
- }
-
- void test_end_overlap_must_be_greater_than_start_overlap_or_throw() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("FirstTransmissionRun", m_TOF);
- alg->setProperty("SecondTransmissionRun", m_TOF);
- MantidVec params = {0.0, 0.1, 1.0};
- alg->setProperty("Params", params);
- alg->setProperty("StartOverlap", 0.6);
- alg->setProperty("EndOverlap", 0.4);
- TS_ASSERT_THROWS(alg->execute(), std::invalid_argument);
- }
-
- void test_must_provide_wavelengths() {
- auto algWithMax =
- AlgorithmManager::Instance().create("ReflectometryReductionOneAuto", 1);
- algWithMax->initialize();
- algWithMax->setProperty("InputWorkspace", m_TOF);
- algWithMax->setProperty("FirstTransmissionRun", m_TOF);
- algWithMax->setProperty("SecondTransmissionRun", m_TOF);
- algWithMax->setProperty("ProcessingInstructions", "3:4");
- algWithMax->setProperty("MomentumTransferStep", 0.1);
- algWithMax->setProperty("WavelengthMax", 1.0);
- algWithMax->setPropertyValue("OutputWorkspace", "out_ws_Q");
- algWithMax->setPropertyValue("OutputWorkspaceWavelength", "out_ws_Lam");
- algWithMax->setRethrows(true);
- TS_ASSERT_THROWS(algWithMax->execute(), std::runtime_error);
-
- auto algWithMin =
- AlgorithmManager::Instance().create("ReflectometryReductionOneAuto", 1);
- algWithMin->initialize();
- algWithMin->setProperty("InputWorkspace", m_TOF);
- algWithMin->setProperty("FirstTransmissionRun", m_TOF);
- algWithMin->setProperty("SecondTransmissionRun", m_TOF);
- algWithMin->setProperty("ProcessingInstructions", "3:4");
- algWithMin->setProperty("MomentumTransferStep", 0.1);
- algWithMin->setProperty("WavelengthMin", 1.0);
- algWithMin->setPropertyValue("OutputWorkspace", "out_ws_Q");
- algWithMin->setPropertyValue("OutputWorkspaceWavelength", "out_ws_Lam");
- algWithMin->setRethrows(true);
- TS_ASSERT_THROWS(algWithMin->execute(), std::runtime_error);
- }
-
- void test_wavelength_min_greater_wavelength_max_throws() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("WavelengthMin", 1.0);
- alg->setProperty("WavelengthMax", 0.0);
- TS_ASSERT_THROWS(alg->execute(), std::invalid_argument);
- }
-
- void
- test_monitor_background_wavelength_min_greater_monitor_background_wavelength_max_throws() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("MonitorBackgroundWavelengthMin", 1.0);
- alg->setProperty("MonitorBackgroundWavelengthMax", 0.0);
- TS_ASSERT_THROWS(alg->execute(), std::invalid_argument);
- }
-
- void
- test_monitor_integration_wavelength_min_greater_monitor_integration_wavelength_max_throws() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("MonitorIntegrationWavelengthMin", 1.0);
- alg->setProperty("MonitorIntegrationWavelengthMax", 0.0);
- TS_ASSERT_THROWS(alg->execute(), std::invalid_argument);
- }
-
- void test_monitor_index_positive() {
- auto alg = construct_standard_algorithm();
- auto tempInst = m_TOF->getInstrument();
- m_TOF->setInstrument(m_dataWorkspace->getInstrument());
- alg->setProperty("InputWorkspace", m_TOF);
- TS_ASSERT_THROWS(alg->execute(), std::runtime_error);
- m_TOF->setInstrument(tempInst);
- }
- void
- test_cannot_set_direct_beam_region_of_interest_without_multidetector_run() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("AnalysisMode", "PointDetectorAnalysis");
- std::vector<int> RegionOfDirectBeam = {1, 2};
- alg->setProperty("RegionOfDirectBeam", RegionOfDirectBeam);
- TS_ASSERT_THROWS(alg->execute(), std::invalid_argument);
- }
-
- void test_region_of_direct_beam_indexes_cannot_be_negative_or_throws() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("AnalysisMode", "MultiDetectorAnalysis");
- std::vector<int> RegionOfDirectBeam = {0, -1};
- alg->setProperty("RegionOfDirectBeam", RegionOfDirectBeam);
- TS_ASSERT_THROWS(alg->execute(), std::invalid_argument);
- }
-
- void
- test_region_of_direct_beam_indexes_must_be_provided_as_min_max_order_or_throws() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("AnalysisMode", "MultiDetectorAnalysis");
- std::vector<int> RegionOfDirectBeam = {1, 0};
- alg->setProperty("RegionOfDirectBeam", RegionOfDirectBeam);
- TS_ASSERT_THROWS(alg->execute(), std::invalid_argument);
- }
-
- void test_bad_detector_component_name_throws() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("DetectorComponentName", "made-up");
- TS_ASSERT_THROWS(alg->execute(), std::runtime_error);
- }
-
- void test_bad_sample_component_name_throws() {
- auto alg = construct_standard_algorithm();
- alg->setProperty("SampleComponentName", "made-up");
- TS_ASSERT_THROWS(alg->execute(), std::runtime_error);
- }
- void test_exec() {
- IAlgorithm_sptr alg =
- AlgorithmManager::Instance().create("ReflectometryReductionOneAuto", 1);
- alg->setRethrows(true);
- TS_ASSERT_THROWS_NOTHING(alg->initialize());
- TS_ASSERT_THROWS_NOTHING(
- alg->setProperty("InputWorkspace", m_dataWorkspace));
- TS_ASSERT_THROWS_NOTHING(
- alg->setProperty("AnalysisMode", "PointDetectorAnalysis"));
- TS_ASSERT_THROWS_NOTHING(
- alg->setPropertyValue("OutputWorkspace", outWSQName));
- TS_ASSERT_THROWS_NOTHING(
- alg->setPropertyValue("OutputWorkspaceWavelength", outWSLamName));
- TS_ASSERT_THROWS_NOTHING(alg->setProperty("MomentumTransferStep", 0.1));
- alg->execute();
- TS_ASSERT(alg->isExecuted());
-
- MatrixWorkspace_sptr outWS =
- AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(outWSQName);
-
- auto inst = m_dataWorkspace->getInstrument();
- auto workspaceHistory = outWS->getHistory();
- AlgorithmHistory_const_sptr workerAlgHistory =
- workspaceHistory.getAlgorithmHistory(0)->getChildAlgorithmHistory(0);
- auto vecPropertyHistories = workerAlgHistory->getProperties();
-
- const double wavelengthMin =
- findPropertyValue<double>(vecPropertyHistories, "WavelengthMin");
- const double wavelengthMax =
- findPropertyValue<double>(vecPropertyHistories, "WavelengthMax");
- const double monitorBackgroundWavelengthMin = findPropertyValue<double>(
- vecPropertyHistories, "MonitorBackgroundWavelengthMin");
- const double monitorBackgroundWavelengthMax = findPropertyValue<double>(
- vecPropertyHistories, "MonitorBackgroundWavelengthMax");
- const double monitorIntegrationWavelengthMin = findPropertyValue<double>(
- vecPropertyHistories, "MonitorIntegrationWavelengthMin");
- const double monitorIntegrationWavelengthMax = findPropertyValue<double>(
- vecPropertyHistories, "MonitorIntegrationWavelengthMax");
- const int i0MonitorIndex =
- findPropertyValue<int>(vecPropertyHistories, "I0MonitorIndex");
- std::string processingInstructions = findPropertyValue<std::string>(
- vecPropertyHistories, "ProcessingInstructions");
- std::vector<std::string> pointDetectorStartStop;
- boost::split(pointDetectorStartStop, processingInstructions,
- boost::is_any_of(":"));
-
- TS_ASSERT_EQUALS(inst->getNumberParameter("LambdaMin")[0], wavelengthMin);
- TS_ASSERT_EQUALS(inst->getNumberParameter("LambdaMax")[0], wavelengthMax);
- TS_ASSERT_EQUALS(inst->getNumberParameter("MonitorBackgroundMin")[0],
- monitorBackgroundWavelengthMin);
- TS_ASSERT_EQUALS(inst->getNumberParameter("MonitorBackgroundMax")[0],
- monitorBackgroundWavelengthMax);
- TS_ASSERT_EQUALS(inst->getNumberParameter("MonitorIntegralMin")[0],
- monitorIntegrationWavelengthMin);
- TS_ASSERT_EQUALS(inst->getNumberParameter("MonitorIntegralMax")[0],
- monitorIntegrationWavelengthMax);
- TS_ASSERT_EQUALS(inst->getNumberParameter("I0MonitorIndex")[0],
- i0MonitorIndex);
- TS_ASSERT_EQUALS(inst->getNumberParameter("PointDetectorStart")[0],
- boost::lexical_cast<double>(pointDetectorStartStop[0]));
- TS_ASSERT_EQUALS(pointDetectorStartStop.size(), 1);
-
- // Remove workspace from the data service.
- AnalysisDataService::Instance().remove(outWSQName);
- AnalysisDataService::Instance().remove(outWSLamName);
- }
-
- void test_missing_instrument_parameters_throws() {
- auto tinyWS =
- WorkspaceCreationHelper::create2DWorkspaceWithReflectometryInstrument();
- auto inst = tinyWS->getInstrument();
-
- inst->getParameterMap()->addDouble(inst.get(), "I0MonitorIndex", 1.0);
-
- tinyWS->mutableRun().addLogData(
- new PropertyWithValue<double>("Theta", 0.12345));
- tinyWS->mutableRun().addLogData(
- new PropertyWithValue<std::string>("run_number", "12345"));
-
- IAlgorithm_sptr alg =
- AlgorithmManager::Instance().create("ReflectometryReductionOneAuto", 1);
- alg->setRethrows(true);
- TS_ASSERT_THROWS_NOTHING(alg->initialize());
- TS_ASSERT_THROWS_NOTHING(alg->setProperty("InputWorkspace", tinyWS));
- TS_ASSERT_THROWS_NOTHING(
- alg->setPropertyValue("OutputWorkspace", outWSQName));
- TS_ASSERT_THROWS_NOTHING(alg->setProperty("MomentumTransferStep", 0.1));
- TS_ASSERT_THROWS_NOTHING(
- alg->setPropertyValue("OutputWorkspaceWavelength", outWSLamName));
- TS_ASSERT_THROWS_ANYTHING(alg->execute());
-
- // Remove workspace from the data service.
- AnalysisDataService::Instance().remove(outWSQName);
- AnalysisDataService::Instance().remove(outWSLamName);
- }
-
- void test_normalize_by_detmon() {
- // Prepare workspace
- //-----------------
- // Single bin from 1->2
- BinEdges x{1, 2};
-
- // 2 spectra, 2 x values, 1 y value per spectra
- auto tinyWS = createWorkspace<Workspace2D>(2, 2, 1);
- tinyWS->setBinEdges(0, x);
- tinyWS->setBinEdges(1, x);
- tinyWS->setCounts(0, 1, 10.0);
- tinyWS->setCountStandardDeviations(0, 1, 0.0);
- tinyWS->setCounts(1, 1, 5.0);
- tinyWS->setCountStandardDeviations(1, 1, 0.0);
-
- tinyWS->setTitle("Test histogram");
- tinyWS->getAxis(0)->setUnit("Wavelength");
- tinyWS->setYUnit("Counts");
-
- // Prepare instrument
- //------------------
- Instrument_sptr instrument = boost::make_shared<Instrument>();
- instrument->setReferenceFrame(
- boost::make_shared<ReferenceFrame>(Y, X, 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");
- source->setPos(V3D(15, 0, 0));
- instrument->add(sample);
- instrument->markAsSamplePos(sample);
-
- Detector *det = new Detector("point-detector", 1, nullptr);
- det->setPos(20, (20 - sample->getPos().X()), 0);
- instrument->add(det);
- instrument->markAsDetector(det);
-
- Detector *monitor = new Detector("Monitor", 2, nullptr);
- monitor->setPos(14, 0, 0);
- instrument->add(monitor);
- instrument->markAsMonitor(monitor);
-
- // Add instrument to workspace
- tinyWS->setInstrument(instrument);
- tinyWS->getSpectrum(0).addDetectorID(det->getID());
- tinyWS->getSpectrum(1).addDetectorID(monitor->getID());
-
- // Now we can parameterize the instrument
- auto tinyInst = tinyWS->getInstrument();
- ParameterMap_sptr params = tinyInst->getParameterMap();
- params->addDouble(tinyInst.get(), "PointDetectorStart", 0.0);
- params->addDouble(tinyInst.get(), "PointDetectorStop", 0.0);
- params->addDouble(tinyInst.get(), "I0MonitorIndex", 1.0);
- params->addDouble(tinyInst.get(), "LambdaMin", 0.0);
- params->addDouble(tinyInst.get(), "LambdaMax", 10.0);
- params->addDouble(tinyInst.get(), "MonitorBackgroundMin", 0.0);
- params->addDouble(tinyInst.get(), "MonitorBackgroundMax", 0.0);
- params->addDouble(tinyInst.get(), "MonitorIntegralMin", 0.0);
- params->addDouble(tinyInst.get(), "MonitorIntegralMax", 10.0);
-
- tinyWS->mutableRun().addLogData(
- new PropertyWithValue<double>("Theta", 0.1));
-
- // Run the required algorithms
- //---------------------------
-
- // Convert units
- IAlgorithm_sptr conv = AlgorithmManager::Instance().create("ConvertUnits");
- conv->initialize();
- conv->setProperty("InputWorkspace", tinyWS);
- conv->setProperty("OutputWorkspace", inWSName);
- conv->setProperty("Target", "TOF");
- conv->execute();
- TS_ASSERT(conv->isExecuted());
-
- // Reduce
- IAlgorithm_sptr alg =
- AlgorithmManager::Instance().create("ReflectometryReductionOneAuto", 1);
- alg->setRethrows(true);
- TS_ASSERT_THROWS_NOTHING(alg->initialize());
- TS_ASSERT_THROWS_NOTHING(alg->setProperty("InputWorkspace", inWSName));
- TS_ASSERT_THROWS_NOTHING(
- alg->setProperty("NormalizeByIntegratedMonitors", false));
- TS_ASSERT_THROWS_NOTHING(alg->setProperty("MomentumTransferStep", 0.1));
- TS_ASSERT_THROWS_NOTHING(
- alg->setPropertyValue("OutputWorkspace", outWSQName));
- TS_ASSERT_THROWS_NOTHING(
- alg->setPropertyValue("OutputWorkspaceWavelength", outWSLamName));
- alg->execute();
- TS_ASSERT(alg->isExecuted());
-
- // Get results
- MatrixWorkspace_sptr outWSLam =
- AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
- outWSLamName);
-
- // Check results (10 / 5 = 2)
- TS_ASSERT_DELTA(outWSLam->readY(0)[0], 2, 1e-5);
- TS_ASSERT_DELTA(outWSLam->readX(0)[0], 1, 1e-5);
- TS_ASSERT_DELTA(outWSLam->readX(0)[1], 2, 1e-5);
-
- // Remove workspace from the data service.
- AnalysisDataService::Instance().remove(inWSName);
- AnalysisDataService::Instance().remove(outWSQName);
- AnalysisDataService::Instance().remove(outWSLamName);
- }
-
- void test_i0_monitor_index_not_required() {
- // Prepare instrument
- //------------------
- // hold the current instrument assigned to m_dataWorkspace
- auto m_dataWorkspaceInstHolder = m_dataWorkspace->getInstrument();
- Instrument_sptr instrument = boost::make_shared<Instrument>();
- instrument->setReferenceFrame(
- boost::make_shared<ReferenceFrame>(Y, X, 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");
- source->setPos(V3D(15, 0, 0));
- instrument->add(sample);
- instrument->markAsSamplePos(sample);
-
- Detector *det = new Detector("point-detector", 1, nullptr);
- det->setPos(20, (20 - sample->getPos().X()), 0);
- instrument->add(det);
- instrument->markAsDetector(det);
-
- Detector *monitor = new Detector("Monitor", 2, nullptr);
- monitor->setPos(14, 0, 0);
- instrument->add(monitor);
- instrument->markAsMonitor(monitor);
-
- // Add new instrument to workspace
- m_dataWorkspace->setInstrument(instrument);
-
- // Now we can parameterize the instrument
- // without setting the I0MonitorIndex
- auto tinyInst = m_dataWorkspace->getInstrument();
- ParameterMap_sptr params = tinyInst->getParameterMap();
- params->addDouble(tinyInst.get(), "PointDetectorStart", 0.0);
- params->addDouble(tinyInst.get(), "PointDetectorStop", 0.0);
- params->addDouble(tinyInst.get(), "LambdaMin", 0.0);
- params->addDouble(tinyInst.get(), "LambdaMax", 10.0);
- params->addDouble(tinyInst.get(), "MonitorBackgroundMin", 0.0);
- params->addDouble(tinyInst.get(), "MonitorBackgroundMax", 0.0);
- params->addDouble(tinyInst.get(), "MonitorIntegralMin", 0.0);
- params->addDouble(tinyInst.get(), "MonitorIntegralMax", 10.0);
-
- // Reduce
- IAlgorithm_sptr alg =
- AlgorithmManager::Instance().create("ReflectometryReductionOneAuto", 1);
- alg->setRethrows(true);
- alg->setChild(true);
- TS_ASSERT_THROWS_NOTHING(alg->initialize());
- TS_ASSERT_THROWS_NOTHING(
- alg->setProperty("InputWorkspace", m_dataWorkspace));
- TS_ASSERT_THROWS_NOTHING(
- alg->setProperty("I0MonitorIndex", Mantid::EMPTY_INT()));
- TS_ASSERT_THROWS_NOTHING(alg->setProperty("MomentumTransferStep", 0.1));
- TS_ASSERT_THROWS_NOTHING(
- alg->setPropertyValue("OutputWorkspace", outWSQName));
- TS_ASSERT_THROWS_NOTHING(
- alg->setPropertyValue("OutputWorkspaceWavelength", outWSLamName));
- // we have intentionally not set
- TS_ASSERT_THROWS_NOTHING(alg->execute());
-
- // Remove workspace from the data service.
- AnalysisDataService::Instance().remove(inWSName);
- AnalysisDataService::Instance().remove(outWSQName);
- AnalysisDataService::Instance().remove(outWSLamName);
-
- // reset the instrument associated with m_dataWorkspace
- m_dataWorkspace->setInstrument(m_dataWorkspaceInstHolder);
- }
- void test_point_detector_run_with_single_transmission_workspace() {
- ReflectometryReductionOneAuto alg;
- alg.initialize();
- alg.setChild(true);
- alg.setProperty("WavelengthMin", 1.0);
- alg.setProperty("WavelengthMax", 2.0);
- alg.setProperty("I0MonitorIndex", 0);
- alg.setProperty("ProcessingInstructions", "3,4");
- alg.setProperty("MonitorBackgroundWavelengthMin", 0.0);
- alg.setProperty("MonitorBackgroundWavelengthMax", 1.0);
- alg.setProperty("MonitorIntegrationWavelengthMin", 0.0);
- alg.setProperty("MonitorIntegrationWavelengthMax", 1.0);
- alg.setProperty("InputWorkspace", m_dataWorkspace);
- alg.setProperty("FirstTransmissionRun", m_transWorkspace1);
- alg.setProperty("ThetaIn", 0.2);
- alg.setPropertyValue("OutputWorkspace", "IvsQ");
- alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
-
- TS_ASSERT_THROWS_NOTHING(alg.execute());
-
- double thetaOut = alg.getProperty("ThetaOut");
- TSM_ASSERT_EQUALS("Theta in and out should be the same", thetaOut, 0.2);
-
- MatrixWorkspace_sptr IvsLam = alg.getProperty("OutputWorkspaceWavelength");
- TSM_ASSERT("OutputWorkspaceWavelength should be a valid matrix workspace",
- IvsLam);
-
- MatrixWorkspace_sptr IvsQ = alg.getProperty("OutputWorkspace");
- TSM_ASSERT("OutputWorkspace should be a valid matrix workspace", IvsQ);
-
- TSM_ASSERT_EQUALS("OutputWorkspaceWavelength should have two histograms",
- IvsLam->getNumberHistograms(), 2);
- }
-
- void test_point_detector_run_with_two_transmission_workspaces() {
- ReflectometryReductionOneAuto alg;
- alg.initialize();
- alg.setChild(true);
- alg.setProperty("WavelengthMin", 1.0);
- alg.setProperty("WavelengthMax", 2.0);
- alg.setProperty("I0MonitorIndex", 0);
- alg.setProperty("ProcessingInstructions", "3, 4");
- alg.setProperty("MonitorBackgroundWavelengthMin", 0.0);
- alg.setProperty("MonitorBackgroundWavelengthMax", 1.0);
- alg.setProperty("MonitorIntegrationWavelengthMin", 0.0);
- alg.setProperty("MonitorIntegrationWavelengthMax", 1.0);
- alg.setProperty("InputWorkspace", m_dataWorkspace);
- alg.setProperty("FirstTransmissionRun", m_transWorkspace1);
- alg.setProperty("SecondTransmissionRun", m_transWorkspace2);
- alg.setPropertyValue("OutputWorkspace", "IvsQ");
- alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
-
- TS_ASSERT_THROWS_NOTHING(alg.execute());
- }
-
- void test_spectrum_map_mismatch_throws_when_strict() {
- ReflectometryReductionOneAuto alg;
- alg.initialize();
- alg.setChild(true);
- alg.setProperty("WavelengthMin", 1.0);
- alg.setProperty("WavelengthMax", 2.0);
- alg.setProperty("I0MonitorIndex", 0);
- alg.setProperty("ProcessingInstructions", "3");
- alg.setProperty("MonitorBackgroundWavelengthMin", 0.0);
- alg.setProperty("MonitorBackgroundWavelengthMax", 1.0);
- alg.setProperty("MonitorIntegrationWavelengthMin", 0.0);
- alg.setProperty("MonitorIntegrationWavelengthMax", 1.0);
- alg.setPropertyValue("OutputWorkspace", "IvsQ");
- alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
-
- alg.setProperty("InputWorkspace", m_dataWorkspace);
- alg.execute();
-
- MatrixWorkspace_sptr trans = alg.getProperty("OutputWorkspaceWavelength");
- alg.setProperty("FirstTransmissionRun", trans);
- alg.setProperty("ProcessingInstructions", "4");
- TS_ASSERT_THROWS_ANYTHING(alg.execute());
- }
-
- void test_spectrum_map_mismatch_doesnt_throw_when_not_strict() {
- ReflectometryReductionOneAuto alg;
- alg.initialize();
- alg.setChild(true);
- alg.setProperty("WavelengthMin", 1.0);
- alg.setProperty("WavelengthMax", 2.0);
- alg.setProperty("I0MonitorIndex", 0);
- alg.setProperty("ProcessingInstructions", "3");
- alg.setProperty("MonitorBackgroundWavelengthMin", 0.0);
- alg.setProperty("MonitorBackgroundWavelengthMax", 1.0);
- alg.setProperty("MonitorIntegrationWavelengthMin", 0.0);
- alg.setProperty("MonitorIntegrationWavelengthMax", 1.0);
- alg.setPropertyValue("OutputWorkspace", "IvsQ");
- alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
-
- alg.setProperty("InputWorkspace", m_dataWorkspace);
- alg.execute();
-
- MatrixWorkspace_sptr trans = alg.getProperty("OutputWorkspaceWavelength");
- alg.setProperty("FirstTransmissionRun", trans);
- alg.setProperty("ProcessingInstructions", "4");
- alg.setProperty("StrictSpectrumChecking", "0");
- TS_ASSERT_THROWS_NOTHING(alg.execute());
- }
-
- void test_multidetector_run() {
- ReflectometryReductionOneAuto alg;
- alg.initialize();
- alg.setChild(false);
- alg.setProperty("WavelengthMin", 1.0);
- alg.setProperty("WavelengthMax", 2.0);
- alg.setProperty("I0MonitorIndex", 0);
- alg.setProperty("ProcessingInstructions", "10");
- alg.setProperty("AnalysisMode", "MultiDetectorAnalysis");
- alg.setProperty("CorrectDetectorPositions", "0");
- alg.setProperty("DetectorComponentName", "lineardetector");
- alg.setProperty("RegionOfDirectBeam", "20, 30");
- alg.setProperty("MonitorBackgroundWavelengthMin", 0.0);
- alg.setProperty("MonitorBackgroundWavelengthMax", 1.0);
- alg.setProperty("MonitorIntegrationWavelengthMin", 0.0);
- alg.setProperty("MonitorIntegrationWavelengthMax", 1.0);
- alg.setProperty("ThetaIn", 0.1);
- alg.setPropertyValue("OutputWorkspace", "IvsQ");
- alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
- alg.setPropertyValue("InputWorkspace", "multidetector_group");
-
- TS_ASSERT_THROWS_NOTHING(alg.execute());
-
- MatrixWorkspace_sptr IvsLam_1 =
- AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("IvsLam_1");
- TSM_ASSERT("OutputWorkspaceWavelength should be a matrix workspace",
- IvsLam_1);
- TS_ASSERT_EQUALS("Wavelength", IvsLam_1->getAxis(0)->unit()->unitID());
- MatrixWorkspace_sptr IvsLam_2 =
- AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("IvsLam_2");
- TSM_ASSERT("OutputWorkspaceWavelength should be a matrix workspace",
- IvsLam_2);
- TS_ASSERT_EQUALS("Wavelength", IvsLam_2->getAxis(0)->unit()->unitID());
-
- MatrixWorkspace_sptr IvsQ_1 =
- AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("IvsQ_1");
- TSM_ASSERT("OutputWorkspace should be a matrix workspace", IvsQ_1);
- TS_ASSERT_EQUALS("MomentumTransfer", IvsQ_1->getAxis(0)->unit()->unitID());
- MatrixWorkspace_sptr IvsQ_2 =
- AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("IvsQ_2");
- TSM_ASSERT("OutputWorkspace should be a matrix workspace", IvsQ_2);
- TS_ASSERT_EQUALS("MomentumTransfer", IvsQ_2->getAxis(0)->unit()->unitID());
-
- MatrixWorkspace_sptr tempWS = boost::dynamic_pointer_cast<MatrixWorkspace>(
- m_multiDetectorWorkspace->getItem(0));
- auto instrBefore = tempWS->getInstrument();
- auto detectorBefore = instrBefore->getComponentByName("lineardetector");
- auto instrAfter = IvsLam_1->getInstrument();
- auto detectorAfter = instrAfter->getComponentByName("lineardetector");
- TS_ASSERT_DELTA(detectorBefore->getPos().Z(), detectorAfter->getPos().Z(),
- 0.0001)
-
- AnalysisDataService::Instance().remove("IvsLam");
- AnalysisDataService::Instance().remove("IvsLam_1");
- AnalysisDataService::Instance().remove("IvsLam_2");
- AnalysisDataService::Instance().remove("IvsQ");
- AnalysisDataService::Instance().remove("IvsQ_1");
- AnalysisDataService::Instance().remove("IvsQ_2");
- }
-
- void test_multidetector_run_correct_positions() {
- ReflectometryReductionOneAuto alg;
- alg.initialize();
- alg.setChild(false);
- alg.setProperty("WavelengthMin", 1.0);
- alg.setProperty("WavelengthMax", 2.0);
- alg.setProperty("I0MonitorIndex", 0);
- alg.setProperty("ProcessingInstructions", "73");
- alg.setProperty("AnalysisMode", "MultiDetectorAnalysis");
- alg.setProperty("CorrectDetectorPositions", "1");
- alg.setProperty("DetectorComponentName", "lineardetector");
- alg.setProperty("RegionOfDirectBeam", "28, 29");
- alg.setProperty("MonitorBackgroundWavelengthMin", 0.0);
- alg.setProperty("MonitorBackgroundWavelengthMax", 1.0);
- alg.setProperty("MonitorIntegrationWavelengthMin", 0.0);
- alg.setProperty("MonitorIntegrationWavelengthMax", 1.0);
- alg.setProperty("ThetaIn", 0.49);
- alg.setPropertyValue("OutputWorkspace", "IvsQ");
- alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
- alg.setPropertyValue("InputWorkspace", "multidetector_group");
-
- TS_ASSERT_THROWS_NOTHING(alg.execute());
-
- MatrixWorkspace_sptr IvsLam_1 =
- AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("IvsLam_1");
- TSM_ASSERT("OutputWorkspaceWavelength should be a matrix workspace",
- IvsLam_1);
- TS_ASSERT_EQUALS("Wavelength", IvsLam_1->getAxis(0)->unit()->unitID());
- MatrixWorkspace_sptr IvsLam_2 =
- AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("IvsLam_2");
- TSM_ASSERT("OutputWorkspaceWavelength should be a matrix workspace",
- IvsLam_2);
- TS_ASSERT_EQUALS("Wavelength", IvsLam_2->getAxis(0)->unit()->unitID());
-
- MatrixWorkspace_sptr IvsQ_1 =
- AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("IvsQ_1");
- TSM_ASSERT("OutputWorkspace should be a matrix workspace", IvsQ_1);
- TS_ASSERT_EQUALS("MomentumTransfer", IvsQ_1->getAxis(0)->unit()->unitID());
- MatrixWorkspace_sptr IvsQ_2 =
- AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>("IvsQ_2");
- TSM_ASSERT("OutputWorkspace should be a matrix workspace", IvsQ_2);
- TS_ASSERT_EQUALS("MomentumTransfer", IvsQ_2->getAxis(0)->unit()->unitID());
-
- auto instr = IvsLam_1->getInstrument();
- auto detectorPos = instr->getComponentByName("lineardetector");
- TS_ASSERT_DELTA(-0.05714, detectorPos->getPos().Z(), 0.0001)
-
- AnalysisDataService::Instance().remove("IvsLam");
- AnalysisDataService::Instance().remove("IvsLam_1");
- AnalysisDataService::Instance().remove("IvsLam_2");
- AnalysisDataService::Instance().remove("IvsQ");
- AnalysisDataService::Instance().remove("IvsQ_1");
- AnalysisDataService::Instance().remove("IvsQ_2");
- }
-};
-
-#endif /* MANTID_ALGORITHMS_REFLECTOMETRYREDUCTIONONEAUTOTEST_H_ */
diff --git a/Framework/Algorithms/test/ReflectometryReductionOneTest.h b/Framework/Algorithms/test/ReflectometryReductionOneTest.h
deleted file mode 100644
index a8072ac9bd1df85b01ffa14a0eee9bb67922cccd..0000000000000000000000000000000000000000
--- a/Framework/Algorithms/test/ReflectometryReductionOneTest.h
+++ /dev/null
@@ -1,395 +0,0 @@
-#ifndef ALGORITHMS_TEST_REFLECTOMETRYREDUCTIONONETEST_H_
-#define ALGORITHMS_TEST_REFLECTOMETRYREDUCTIONONETEST_H_
-
-#include <cxxtest/TestSuite.h>
-#include <algorithm>
-#include "MantidAlgorithms/ReflectometryReductionOne.h"
-#include "MantidAPI/AlgorithmManager.h"
-#include "MantidAPI/Axis.h"
-#include "MantidAPI/FrameworkManager.h"
-#include "MantidAPI/MatrixWorkspace.h"
-#include "MantidTestHelpers/WorkspaceCreationHelper.h"
-#include "MantidGeometry/Instrument/ReferenceFrame.h"
-#include "MantidGeometry/Instrument.h"
-#include "MantidKernel/Unit.h"
-
-using namespace Mantid;
-using namespace Mantid::Kernel;
-using namespace Mantid::API;
-using namespace Mantid::Algorithms;
-using namespace Mantid::Geometry;
-using namespace WorkspaceCreationHelper;
-
-class ReflectometryReductionOneTest : public CxxTest::TestSuite {
-private:
- MatrixWorkspace_sptr m_tinyReflWS;
-
-public:
- // This pair of boilerplate methods prevent the suite being created statically
- // This means the constructor isn't called when running other tests
- static ReflectometryReductionOneTest *createSuite() {
- return new ReflectometryReductionOneTest();
- }
- static void destroySuite(ReflectometryReductionOneTest *suite) {
- delete suite;
- }
-
- ReflectometryReductionOneTest() {
- FrameworkManager::Instance();
- m_tinyReflWS = create2DWorkspaceWithReflectometryInstrument();
- }
-
- void test_tolam() {
- MatrixWorkspace_sptr toConvert = m_tinyReflWS;
- std::vector<int> detectorIndexRange;
- size_t workspaceIndexToKeep1 = 1;
- const int monitorIndex = 0;
-
- specnum_t specId1 =
- toConvert->getSpectrum(workspaceIndexToKeep1).getSpectrumNo();
- specnum_t monitorSpecId =
- toConvert->getSpectrum(monitorIndex).getSpectrumNo();
-
- // Define one spectra to keep
- detectorIndexRange.push_back(static_cast<int>(workspaceIndexToKeep1));
- std::stringstream buffer;
- buffer << workspaceIndexToKeep1;
- const std::string detectorIndexRangesStr = buffer.str();
-
- // Define a wavelength range for the detector workspace
- const double wavelengthMin = 1.0;
- const double wavelengthMax = 15;
- const double backgroundWavelengthMin = 17;
- const double backgroundWavelengthMax = 20;
-
- ReflectometryReductionOne alg;
-
- // Run the conversion.
- ReflectometryWorkflowBase::DetectorMonitorWorkspacePair inLam =
- alg.toLam(toConvert, detectorIndexRangesStr, monitorIndex,
- boost::tuple<double, double>(wavelengthMin, wavelengthMax),
- boost::tuple<double, double>(backgroundWavelengthMin,
- backgroundWavelengthMax));
-
- // Unpack the results
- MatrixWorkspace_sptr detectorWS = inLam.get<0>();
- MatrixWorkspace_sptr monitorWS = inLam.get<1>();
-
- /* ---------- Checks for the detector workspace ------------------*/
-
- // Check units.
- TS_ASSERT_EQUALS("Wavelength", detectorWS->getAxis(0)->unit()->unitID());
-
- // Check the number of spectrum kept.
- TS_ASSERT_EQUALS(1, detectorWS->getNumberHistograms());
-
- auto map = detectorWS->getSpectrumToWorkspaceIndexMap();
- // Check the spectrum Nos retained.
- TS_ASSERT_EQUALS(map[specId1], 0);
-
- // Check the cropped x range
- auto copyX = detectorWS->x(0);
- std::sort(copyX.begin(), copyX.end());
- TS_ASSERT(copyX.front() >= wavelengthMin);
- TS_ASSERT(copyX.back() <= wavelengthMax);
-
- /* ------------- Checks for the monitor workspace --------------------*/
- // Check units.
- TS_ASSERT_EQUALS("Wavelength", monitorWS->getAxis(0)->unit()->unitID());
-
- // Check the number of spectrum kept. This should only ever be 1.
- TS_ASSERT_EQUALS(1, monitorWS->getNumberHistograms());
-
- map = monitorWS->getSpectrumToWorkspaceIndexMap();
- // Check the spectrum Nos retained.
- TS_ASSERT_EQUALS(map[monitorSpecId], 0);
- }
-
- IAlgorithm_sptr construct_standard_algorithm() {
- auto alg =
- AlgorithmManager::Instance().create("ReflectometryReductionOne", 1);
- alg->setRethrows(true);
- alg->setChild(true);
- alg->initialize();
- alg->setProperty("InputWorkspace", m_tinyReflWS);
- alg->setProperty("WavelengthMin", 1.0);
- alg->setProperty("WavelengthMax", 2.0);
- alg->setProperty("I0MonitorIndex", 1);
- alg->setProperty("MonitorBackgroundWavelengthMin", 1.0);
- alg->setProperty("MonitorBackgroundWavelengthMax", 2.0);
- alg->setProperty("MonitorIntegrationWavelengthMin", 1.2);
- alg->setProperty("MonitorIntegrationWavelengthMax", 1.5);
- alg->setProperty("MomentumTransferStep", 0.1);
- alg->setPropertyValue("ProcessingInstructions", "0");
- alg->setPropertyValue("OutputWorkspace", "x");
- alg->setPropertyValue("OutputWorkspaceWavelength", "y");
- alg->setRethrows(true);
- return alg;
- }
-
- void test_execute() {
- auto alg = construct_standard_algorithm();
- TS_ASSERT_THROWS_NOTHING(alg->execute());
- MatrixWorkspace_sptr workspaceInQ = alg->getProperty("OutputWorkspace");
- MatrixWorkspace_sptr workspaceInLam =
- alg->getProperty("OutputWorkspaceWavelength");
- const double theta = alg->getProperty("ThetaOut");
- UNUSED_ARG(theta)
- UNUSED_ARG(workspaceInQ)
- UNUSED_ARG(workspaceInLam)
- }
-
- void test_calculate_theta() {
-
- auto alg = construct_standard_algorithm();
-
- alg->execute();
- // Should not throw
-
- const double outTwoTheta = alg->getProperty("ThetaOut");
- TS_ASSERT_DELTA(45.0, outTwoTheta, 0.00001);
- }
-
- void test_source_rotation_after_second_reduction() {
- // set up the axis for the instrument
- Instrument_sptr instrument = boost::make_shared<Instrument>();
- instrument->setReferenceFrame(boost::make_shared<ReferenceFrame>(
- Y /*up*/, Z /*along*/, Right, "0,0,0"));
-
- // add a source
- ObjComponent *source = new ObjComponent("source");
- source->setPos(V3D(0, 0, -1));
- instrument->add(source);
- instrument->markAsSource(source);
-
- // add a sample
- ObjComponent *sample = new ObjComponent("some-surface-holder");
- sample->setPos(V3D(0, 0, 0));
- instrument->add(sample);
- instrument->markAsSamplePos(sample);
-
- // add a detector
- Detector *det = new Detector("point-detector", 1, nullptr);
- det->setPos(V3D(0, 1, 1));
- instrument->add(det);
- instrument->markAsDetector(det);
-
- // set the instrument to this workspace
- m_tinyReflWS->setInstrument(instrument);
- // set this detector ready for processing instructions
- m_tinyReflWS->getSpectrum(0).setDetectorID(det->getID());
-
- auto alg =
- AlgorithmManager::Instance().create("ReflectometryReductionOne", 1);
- alg->setRethrows(true);
- alg->setChild(true);
- alg->initialize();
- alg->setProperty("InputWorkspace", m_tinyReflWS);
- alg->setProperty("WavelengthMin", 1.0);
- alg->setProperty("WavelengthMax", 15.0);
- alg->setProperty("I0MonitorIndex", 0);
- alg->setProperty("MonitorBackgroundWavelengthMin", 0.0);
- alg->setProperty("MonitorBackgroundWavelengthMax", 0.0);
- alg->setProperty("MonitorIntegrationWavelengthMin", 0.0);
- alg->setProperty("MonitorIntegrationWavelengthMax", 0.0);
- alg->setProperty("MomentumTransferStep", 0.1);
- alg->setProperty("NormalizeByIntegratedMonitors", false);
- alg->setProperty("CorrectDetectorPositions", true);
- alg->setProperty("CorrectionAlgorithm", "None");
- alg->setPropertyValue("ProcessingInstructions", "1");
- alg->setPropertyValue("OutputWorkspace", "x");
- alg->setPropertyValue("OutputWorkspaceWavelength", "y");
- alg->setRethrows(true);
- TS_ASSERT_THROWS_NOTHING(alg->execute());
- MatrixWorkspace_sptr outLam = alg->getProperty("OutputWorkspaceWavelength");
- MatrixWorkspace_sptr outQ = alg->getProperty("OutputWorkspace");
-
- TS_ASSERT_EQUALS(m_tinyReflWS->getInstrument()->getSource()->getPos(),
- outLam->getInstrument()->getSource()->getPos());
- TS_ASSERT_EQUALS(outLam->getInstrument()->getSource()->getPos(),
- outQ->getInstrument()->getSource()->getPos());
- }
- void test_post_processing_scale_step() {
- auto alg = construct_standard_algorithm();
- auto inWS =
- WorkspaceCreationHelper::create2DWorkspaceWithReflectometryInstrument(
- 2.0);
- inWS->getAxis(0)->setUnit("Wavelength");
- alg->setProperty("InputWorkspace", inWS);
- alg->setProperty("ScaleFactor", 1.0);
- alg->setProperty("ThetaIn", 1.5);
- alg->setProperty("OutputWorkspace", "Test");
- TS_ASSERT_THROWS_NOTHING(alg->execute());
- MatrixWorkspace_sptr nonScaledWS = alg->getProperty("OutputWorkspace");
- alg->setProperty("InputWorkspace", inWS);
- alg->setProperty("ScaleFactor", 0.5);
- alg->setProperty("OutputWorkspace", "scaledTest");
- TS_ASSERT_THROWS_NOTHING(alg->execute());
- MatrixWorkspace_sptr scaledWS = alg->getProperty("OutputWorkspace");
- // compare y data instead of workspaces.
- auto &scaledYData = scaledWS->y(0);
- auto &nonScaledYData = nonScaledWS->y(0);
- TS_ASSERT_EQUALS(scaledYData.front(), 2 * nonScaledYData.front());
- TS_ASSERT_EQUALS(scaledYData[scaledYData.size() / 2],
- 2 * nonScaledYData[nonScaledYData.size() / 2]);
- TS_ASSERT_EQUALS(scaledYData.back(), 2 * nonScaledYData.back());
- // Remove workspace from the data service.
- AnalysisDataService::Instance().remove("Test");
- AnalysisDataService::Instance().remove("scaledTest");
- }
- void test_post_processing_rebin_step_with_params_not_provided() {
- auto alg = construct_standard_algorithm();
- auto inWS = create2DWorkspace154(1, 10, true);
- // this instrument does not have a "slit-gap" property
- // defined in the IPF, so NRCalculateSlitResolution should throw.
- inWS->setInstrument(m_tinyReflWS->getInstrument());
- inWS->getAxis(0)->setUnit("Wavelength");
- // Setup bad bin edges, Rebin will throw (not NRCalculateSlitResolution?)
- inWS->mutableX(0) = inWS->x(0)[0];
- alg->setProperty("InputWorkspace", inWS);
- alg->setProperty("OutputWorkspace", "rebinnedWS");
- TS_ASSERT_THROWS(alg->execute(), std::invalid_argument);
- }
- void test_post_processing_rebin_step_with_partial_params_provided() {
- auto alg = construct_standard_algorithm();
- auto inWS = create2DWorkspace154(1, 10, true);
- inWS->setInstrument(m_tinyReflWS->getInstrument());
- inWS->getAxis(0)->setUnit("Wavelength");
- alg->setProperty("InputWorkspace", inWS);
- alg->setProperty("MomentumTransferMaximum", 15.0);
- alg->setProperty("OutputWorkspace", "rebinnedWS");
- TS_ASSERT_THROWS_NOTHING(alg->execute());
- MatrixWorkspace_sptr rebinnedIvsQWS = alg->getProperty("OutputWorkspace");
- auto &xData = rebinnedIvsQWS->x(0);
- // based off the equation for logarithmic binning X(i+1)=X(i)(1+|dX|)
- double binWidthFromLogarithmicEquation = fabs((xData[1] / xData[0]) - 1);
- TSM_ASSERT_DELTA("DQQ should be the same as abs(x[1]/x[0] - 1)",
- binWidthFromLogarithmicEquation, 0.1, 1e-06);
- TSM_ASSERT_DELTA("Qmax should be the same as last Params entry (5.0)",
- xData.back(), 15.0, 1e-06);
- }
- void test_post_processing_rebin_step_with_logarithmic_rebinning() {
- auto alg = construct_standard_algorithm();
- auto inWS = create2DWorkspace154(1, 10, true);
- inWS->setInstrument(m_tinyReflWS->getInstrument());
- inWS->getAxis(0)->setUnit("Wavelength");
- alg->setProperty("InputWorkspace", inWS);
- alg->setProperty("MomentumTransferMinimum", 1.0);
- alg->setProperty("MomentumTransferStep", 0.2);
- alg->setProperty("MomentumTransferMaximum", 5.0);
- alg->setProperty("OutputWorkspace", "rebinnedWS");
- TS_ASSERT_THROWS_NOTHING(alg->execute());
- MatrixWorkspace_sptr rebinnedIvsQWS = alg->getProperty("OutputWorkspace");
- auto &xData = rebinnedIvsQWS->x(0);
- TSM_ASSERT_EQUALS("QMin should be the same as first Param entry (1.0)",
- xData[0], 1.0);
- // based off the equation for logarithmic binning X(i+1)=X(i)(1+|dX|)
- double binWidthFromLogarithmicEquation = fabs((xData[1] / xData[0]) - 1);
- TSM_ASSERT_DELTA("DQQ should be the same as abs(x[1]/x[0] - 1)",
- binWidthFromLogarithmicEquation, 0.2, 1e-06);
- TSM_ASSERT_EQUALS("QMax should be the same as last Param entry",
- xData.back(), 5.0);
- }
- void test_post_processing_rebin_step_with_linear_rebinning() {
- auto alg = construct_standard_algorithm();
- auto inWS = create2DWorkspace154(1, 10, true);
- inWS->setInstrument(m_tinyReflWS->getInstrument());
- inWS->getAxis(0)->setUnit("Wavelength");
- alg->setProperty("InputWorkspace", inWS);
- alg->setProperty("MomentumTransferMinimum", 1.577);
- alg->setProperty("MomentumTransferStep", -0.2);
- alg->setProperty("MomentumTransferMaximum", 5.233);
- alg->setProperty("OutputWorkspace", "rebinnedWS");
- TS_ASSERT_THROWS_NOTHING(alg->execute());
- MatrixWorkspace_sptr rebinnedIvsQWS = alg->getProperty("OutputWorkspace");
- auto &xData = rebinnedIvsQWS->x(0);
- TSM_ASSERT_DELTA("QMin should be the same as the first Param entry (1.577)",
- xData[0], 1.577, 1e-06);
- TSM_ASSERT_DELTA("DQQ should the same as 0.2", xData[1] - xData[0], 0.2,
- 1e-06);
- TSM_ASSERT_DELTA("QMax should be the same as the last Param entry (5.233)",
- xData.back(), 5.233, 1e-06);
- }
- void test_Qrange() {
- // set up the axis for the instrument
- Instrument_sptr instrument = boost::make_shared<Instrument>();
- instrument->setReferenceFrame(boost::make_shared<ReferenceFrame>(
- Y /*up*/, Z /*along*/, Right, "0,0,0"));
-
- // add a source
- ObjComponent *source = new ObjComponent("source");
- source->setPos(V3D(0, 0, -1));
- instrument->add(source);
- instrument->markAsSource(source);
-
- // add a sample
- ObjComponent *sample = new ObjComponent("some-surface-holder");
- sample->setPos(V3D(0, 0, 0));
- instrument->add(sample);
- instrument->markAsSamplePos(sample);
-
- // add a detector
- Detector *det = new Detector("point-detector", 1, nullptr);
- det->setPos(V3D(0, 1, 1));
- instrument->add(det);
- instrument->markAsDetector(det);
-
- // set the instrument to this workspace
- m_tinyReflWS->setInstrument(instrument);
- // set this detector ready for processing instructions
- m_tinyReflWS->getSpectrum(0).setDetectorID(det->getID());
-
- auto alg =
- AlgorithmManager::Instance().create("ReflectometryReductionOne", 1);
- alg->setRethrows(true);
- alg->setChild(true);
- alg->initialize();
- alg->setProperty("InputWorkspace", m_tinyReflWS);
- alg->setProperty("WavelengthMin", 1.0);
- alg->setProperty("WavelengthMax", 15.0);
- alg->setProperty("I0MonitorIndex", 0);
- alg->setProperty("MonitorBackgroundWavelengthMin", 0.0);
- alg->setProperty("MonitorBackgroundWavelengthMax", 0.0);
- alg->setProperty("MonitorIntegrationWavelengthMin", 0.0);
- alg->setProperty("MonitorIntegrationWavelengthMax", 0.0);
- alg->setProperty("MomentumTransferStep", 0.1);
- alg->setProperty("NormalizeByIntegratedMonitors", false);
- alg->setProperty("CorrectDetectorPositions", true);
- alg->setProperty("CorrectionAlgorithm", "None");
- alg->setPropertyValue("ProcessingInstructions", "1");
- alg->setPropertyValue("OutputWorkspace", "x");
- alg->setPropertyValue("OutputWorkspaceWavelength", "y");
- alg->setRethrows(true);
- TS_ASSERT_THROWS_NOTHING(alg->execute());
-
- // retrieve the IvsLam workspace
- MatrixWorkspace_sptr inLam = alg->getProperty("OutputWorkspaceWavelength");
- // retrieve the IvsQ workspace
- MatrixWorkspace_sptr inQ = alg->getProperty("OutputWorkspace");
- // retrieve our Theta
- double outTheta = alg->getProperty("ThetaOut");
-
- TS_ASSERT_DELTA(45.0, outTheta, 0.00001);
- TS_ASSERT_EQUALS(source->getPos(),
- inQ->getInstrument()->getSource()->getPos());
- // convert from degrees to radians for sin() function
- double outThetaInRadians = outTheta * M_PI / 180;
-
- double lamMin = inLam->x(0).front();
- double lamMax = inLam->x(0).back();
-
- // Derive our QMin and QMax from the equation
- double qMinFromEQ = (4 * M_PI * sin(outThetaInRadians)) / lamMax;
- double qMaxFromEQ = (4 * M_PI * sin(outThetaInRadians)) / lamMin;
-
- // Get our QMin and QMax from the workspace
- auto qMinFromWS = inQ->x(0).front();
- auto qMaxFromWS = inQ->x(0).back();
-
- // Compare the two values (they should be identical)
- TS_ASSERT_DELTA(qMinFromEQ, qMinFromWS, 0.00001);
- TS_ASSERT_DELTA(qMaxFromEQ, qMaxFromWS, 0.00001);
- }
-};
-
-#endif /* ALGORITHMS_TEST_REFLECTOMETRYREDUCTIONONETEST_H_ */
diff --git a/Framework/Algorithms/test/SpecularReflectionPositionCorrect2Test.h b/Framework/Algorithms/test/SpecularReflectionPositionCorrect2Test.h
index e9e8e0b82c0253f9e8b28d9462af3f47dda102d0..abb29b7f35ecbbca701ef90a2a971e68f9ec95be 100644
--- a/Framework/Algorithms/test/SpecularReflectionPositionCorrect2Test.h
+++ b/Framework/Algorithms/test/SpecularReflectionPositionCorrect2Test.h
@@ -164,7 +164,7 @@ public:
auto detIn = instrIn->getComponentByName("point-detector")->getPos();
auto detOut = instrOut->getComponentByName("point-detector")->getPos();
TS_ASSERT_EQUALS(detIn.X(), detOut.X());
- TS_ASSERT_DELTA(detOut.Z(), 19.69921, 1e-5);
+ TS_ASSERT_DELTA(detOut.Z(), 2.66221, 1e-5);
TS_ASSERT_DELTA(detOut.Y(), 0.06506, 1e-5);
}
@@ -205,7 +205,7 @@ public:
auto detIn = instrIn->getComponentByName("linear-detector")->getPos();
auto detOut = instrOut->getComponentByName("linear-detector")->getPos();
TS_ASSERT_EQUALS(detIn.X(), detOut.X());
- TS_ASSERT_DELTA(detOut.Z(), 20.19906, 1e-5);
+ TS_ASSERT_DELTA(detOut.Z(), 3.162055, 1e-5);
TS_ASSERT_DELTA(detOut.Y(), 0.07728, 1e-5);
}
};
diff --git a/Testing/SystemTests/tests/analysis/OFFSPECReflRedOneAuto.py b/Testing/SystemTests/tests/analysis/OFFSPECReflRedOneAuto.py
deleted file mode 100644
index f61dc4634f95d9e9c7c45bbc92b1cf19a361fda8..0000000000000000000000000000000000000000
--- a/Testing/SystemTests/tests/analysis/OFFSPECReflRedOneAuto.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# pylint: disable=no-init,invalid-name,attribute-defined-outside-init
-"""
-This system test verifies that OFFSPEC data is processed correctly by
-ReflectometryReductionOneAuto
-"""
-
-import stresstesting
-from mantid.simpleapi import *
-
-
-class OFFSPECReflRedOneAuto(stresstesting.MantidStressTest):
- def runTest(self):
- offspec75 = Load("OFFSPEC00027575.raw") #th=0.35
- offspec76 = Load("OFFSPEC00027576.raw") #th=1.00
- offspec78 = Load("OFFSPEC00027578.raw") #th=1.70
- offspec85 = Load("OFFSPEC00027585.raw") #transmission run
-
- #Process using ReflectometryReductionOneAuto
- ivq_75, __, __ = ReflectometryReductionOneAuto(offspec75,
- ThetaIn=0.70,#2*th
- MomentumTransferStep=1e-3,
- FirstTransmissionRun=offspec85,
- Version=1)
-
- ivq_76, __, __ = ReflectometryReductionOneAuto(offspec76,
- ThetaIn=2.00,#2*th
- MomentumTransferStep=1e-3,
- FirstTransmissionRun=offspec85,
- Version=1)
-
- ivq_78, __, __ = ReflectometryReductionOneAuto(offspec78,
- ThetaIn=3.40,#2*th
- MomentumTransferStep=1e-3,
- FirstTransmissionRun=offspec85,
- Version=1)
-
- ivq_75_76, __ = Stitch1D(ivq_75, ivq_76, Params="1e-3")
- #pylint: disable=unused-variable
- ivq_75_76_78, __ = Stitch1D(ivq_75_76, ivq_78, Params="0,1e-3,0.25")
- return True
-
- def validate(self):
- '''
- we only wish to check the Q-range in this system test. It is not necessary
- to check the Instrument definition or Instrument Parameters
- '''
- self.disableChecking = ["Instrument"]
- return ("ivq_75_76_78","OFFSPECReflRedOneAuto_good_v3.nxs")
-
- def requiredFiles(self):
- return ["OFFSPEC00027575.raw",
- "OFFSPEC00027576.raw",
- "OFFSPEC00027578.raw",
- "OFFSPEC00027585.raw",
- "OFFSPECReflRedOneAuto_good_v3.nxs"]
diff --git a/Testing/SystemTests/tests/analysis/OFFSPECReflRedOneAutoPolarizationCorrection.py b/Testing/SystemTests/tests/analysis/OFFSPECReflRedOneAutoPolarizationCorrection.py
deleted file mode 100644
index b4aaf1e46802965bff96694d9069b9289226984d..0000000000000000000000000000000000000000
--- a/Testing/SystemTests/tests/analysis/OFFSPECReflRedOneAutoPolarizationCorrection.py
+++ /dev/null
@@ -1,48 +0,0 @@
-# pylint: disable=no-init, invalid-name, line-too-long, attribute-defined-outside-init
-
-"""
-This system test verifies that OFFSPEC data is processed correctly
-by ReflectometryReductionAutoOne with PolarizationCorrection performed
-as part of the workflow.
-"""
-
-import stresstesting
-from mantid.simpleapi import *
-
-
-class OFFSPECReflRedOneAutoPolarizationCorrection(stresstesting.MantidStressTest):
- def runTest(self):
- inputWorkspace = Load("OFFSPEC00033767.nxs")
- transmissionGroup = Load("OFFSPEC00033772.nxs")
- #set up our transmission workspace
- transWorkspace = CreateTransmissionWorkspaceAuto(transmissionGroup,
- AnalysisMode="MultiDetectorAnalysis",
- ProcessingInstructions="110-120",
- WavelengthMin=2.0, WavelengthMax=12.0, Version=1)
- # set up our efficiency constants
- CRho=[1]
- CAlpha=[1]
- CAp=[1]
- CPp=[1]
- #run reflectometryReductionOneAuto
- __, _IvsLam_polCorr,__ = ReflectometryReductionOneAuto(inputWorkspace, AnalysisMode="MultiDetectorAnalysis",
- ProcessingInstructions="110-120",
- FirstTransmissionRun=transWorkspace,
- ThetaIn="1.2",WavelengthMin=2.0,
- WavelengthMax=12.0,CorrectionAlgorithm='None',
- PolarizationAnalysis='PA', MomentumTransferStep=0.1,
- CPp=CPp,CAp=CAp,CRho=CRho,CAlpha=CAlpha, Version=1)
- return True
-
- def validate(self):
- '''
- we only wish to check the data from PolarizationCorrection in this system test.
- It is not necessary to check the Instrument definition or Instrument Parameters
- '''
- self.disableChecking = ["Instrument"]
- return ("_IvsLam_polCorr", "OFFSPECReflRedOneAutoPolarizationCorrection_good_v2.nxs")
-
- def requiredFiles(self):
- return ["OFFSPEC00033767.nxs",
- "OFFSPEC00033772.nxs",
- "OFFSPECReflRedOneAutoPolarizationCorrection_good_v2.nxs"]
diff --git a/Testing/SystemTests/tests/analysis/reference/L2QReferenceResult.nxs.md5 b/Testing/SystemTests/tests/analysis/reference/L2QReferenceResult.nxs.md5
index 309459a3b1c478ef048fa1a80b8d26c0a545a267..e2e298fb93f01e9614ef7e7179e3fb5c7693ca26 100644
--- a/Testing/SystemTests/tests/analysis/reference/L2QReferenceResult.nxs.md5
+++ b/Testing/SystemTests/tests/analysis/reference/L2QReferenceResult.nxs.md5
@@ -1 +1 @@
-57144b9309c8dbb1232a15c6daa2e904
\ No newline at end of file
+1445797a969c8f96e9ffe402af0dded7
diff --git a/Testing/SystemTests/tests/analysis/reference/QuickReferenceResult.nxs.md5 b/Testing/SystemTests/tests/analysis/reference/QuickReferenceResult.nxs.md5
index 74079775cfa039ecf45d8f2b179315ca03272c8b..15dd6430cabde6b3f4a2d6bd259bbf5e142d8219 100644
--- a/Testing/SystemTests/tests/analysis/reference/QuickReferenceResult.nxs.md5
+++ b/Testing/SystemTests/tests/analysis/reference/QuickReferenceResult.nxs.md5
@@ -1 +1 @@
-24e66b8ccfde55c58ac97d71d736211d
\ No newline at end of file
+0e367a48dd764b901c9176d37f5bf713
diff --git a/Testing/SystemTests/tests/analysis/reference/QuickStitchedReferenceResult.nxs.md5 b/Testing/SystemTests/tests/analysis/reference/QuickStitchedReferenceResult.nxs.md5
index 7966506607d91e3e7274a8fa01a8a5425dcb2bad..4a3b6c8a4078e8aa65e5f85670abc29eb8cd83c5 100644
--- a/Testing/SystemTests/tests/analysis/reference/QuickStitchedReferenceResult.nxs.md5
+++ b/Testing/SystemTests/tests/analysis/reference/QuickStitchedReferenceResult.nxs.md5
@@ -1 +1 @@
-8f7725692c8f287ce01b8648e64e70b2
\ No newline at end of file
+f19753635948066d7ce6a45e58640f6f
diff --git a/docs/source/algorithms/ReflectometryReductionOne-v1.rst b/docs/source/algorithms/ReflectometryReductionOne-v1.rst
deleted file mode 100644
index a39a841536b2974ca73aa2ee1859678d6339f721..0000000000000000000000000000000000000000
--- a/docs/source/algorithms/ReflectometryReductionOne-v1.rst
+++ /dev/null
@@ -1,248 +0,0 @@
-.. algorithm::
-
-.. summary::
-
-.. alias::
-
-.. properties::
-
-Description
------------
-
-Reduces a single TOF reflectometry run into a mod Q vs I/I0 workspace.
-Performs transmission corrections. Handles both point detector and
-multidetector cases. The algorithm can correct detector locations based
-on an input theta value.
-
-Historically the work performed by this algorithm was known as the Quick
-script.
-
-If :literal:`MonitorBackgroundWavelengthMin` and
-:literal:`MonitorBackgroundWavelengthMax` are both set to :literal:`0`, then
-background normalization will not be performed on the monitors.
-
-The properties of this algorithm should be manually selected by the user. If you
-wish to use the default values (found in the Instrument Defintion File) for the
-properties of this algorithm, you may want to consider using
-:ref:`algm-ReflectometryReductionOneAuto`.
-
-:ref:`algm-ReflectometryReductionOneAuto` also performs extra processing steps
-such as Background subtraction and :ref:`algm-PolarizationCorrection`. If you
-want to know how these processing steps are used, please refer to the
-:ref:`algm-ReflectometryReductionOneAuto` documentation.
-
-High-Level Workflow
--------------------
-
-The diagram below displays a high-level version of the algorithm workflow,
-illustrating the main steps taking place in the ReflectometryReductionOne
-algorithm. These individual steps are described in more detail in the next
-sections.
-
-.. diagram:: ReflectometryReductionOne_HighLvl-v1_wkflw.dot
-
-Low-Level Workflow
-------------------
-
-Conversion to Wavelength
-########################
-
-The following diagram describes the steps taken in converting the input
-workspace into units of wavelength and dividing its constituent detectors by
-monitors.
-
-.. diagram:: ReflectometryReductionOne_ConvertToWavelength-v1_wkflw.dot
-
-The default analysis mode is *PointDetectorAnalysis*. For PointAnalysisMode the
-analysis can be roughly reduced to IvsLam = DetectorWS / sum(I0) /
-TransmissionWS / sum(I0). For MultiDetectorAnalysis the analysis can be roughly
-reduced to IvsLam = DetectorWS / RegionOfDirectBeamWS / sum(I0) / TransmissionWS
-/ sum(I0).
-
-Transmission Correction
-#######################
-
-This diagram shows how the resultant workspace of the previous step is corrected
-by either by provided transmission runs or by a specific correction algorithm.
-
-.. diagram:: ReflectometryReductionOne_TransmissionCorrection-v1_wkflw.dot
-
-Transmission correction is a normalization step, which may be applied to both
-*PointDetectorAnalysis* and *MultiDetectorAnalysis* reduction.
-
-Transmission runs are expected to be in TOF. The spectra numbers in the
-Transmission run workspaces must be the same as those in the Input Run
-workspace. If two Transmission runs are provided then the Stitching
-parameters associated with the transmission runs will also be required.
-If a single Transmission run is provided, then no stitching parameters
-will be needed.
-
-The normalization by tranmission run(s) is optional.
-
-The input workspace provided to the workflow in this instance is the original
-:literal:`InputWorkspace` after conversion to wavelength and normalization by
-monitors, as shown in the previous :literal:`Conversion To Wavelength` diagram.
-
-The output workspace given is not the output to the whole algorithm. Rather it
-will serve as the input workspace to the :literal:`Polynomial Correction`
-workflow, where further steps will be applied to it.
-
-Polynomial Correction
-=====================
-
-If no Transmission runs are provided, then polynomial correction can be
-performed instead. Polynomial correction is enabled by setting the
-:literal:`CorrectionAlgorithm` property. If set to
-:literal:`PolynomialCorrection` it runs the :ref:`algm-PolynomialCorrection`
-algorithm, with this algorithms :literal:`Polynomial` property used as its
-:literal:`Coefficients` property.
-
-If the :literal:`CorrectionAlgorithm` property is set to
-:literal:`ExponentialCorrection`, then the :Ref:`algm-ExponentialCorrection`
-algorithm is used, with C0 and C1 taken from the :literal:`C0` and :literal:`C1`
-properties.
-
-Detector Position Correction
-############################
-
-The diagram below describes how the input workspace is then corrected by
-detector positions after transmission correction.
-
-.. diagram:: ReflectometryReductionOne_CorrectDetectorPositions-v1_wkflw.dot
-
-Detector Position Correction is used for when the position of the detector
-is not aligned with the reflected beamline. The correction algorithm used is
-:ref:`algm-SpecularReflectionPositionCorrect-v1` which is a purely vertical
-position correction.
-
-The detector positions in this process are corrected in terms of
-:literal:`ThetaIn`. In general, the detector posistions should always be
-corrected unless the :literal:`InputWorkspace` already has the detectors in the
-right positions. This can be achieved by running
-:literal:`MoveInstrumentComponent` before :literal:`ReflectometryReductionOne`.
-
-Convert To Momentum Transfer (Q)
-################################
-
-The last diagram describes the steps involved in converting the input workspace
-from units of wavelength into momentum transfer (Q).
-
-.. diagram:: ReflectometryReductionOne_ConvertToMomentum-v1_wkflw.dot
-
-ReflectometryReductionOne contains 2 post-processing options that will be
-applied to the IvsQ workspace. These two options are `Rebin` and `Scale`.
-
-Rebinning
-=========
-
-To Rebin your IvsQ workspace you will have to provide values for the following
-properties: `MomentumTransferMinimum`, `MomentumTransferStep` and
-`MomentumTransferMaximum`. These values will be appended to each other to form
-your :ref:`algm-Rebin` Params. These values correspond to your `MinimumExtent`,
-`BinWidth` and `MaximumExtent` respectively.
-
-If you provide a positive `MomentumTransferStep` value then the algorithm will
-automatically negate this value which will allow for Logarithmic Rebinning.
-Alternatively, a negative `MomentumTransferStep` will result in Linear
-Rebinning. More details about the Rebinning process can be found in the
-documentation for :ref:`algm-Rebin`.
-
-If no values are provided for `MomentumTransferMinimum` and
-`MomentumTransferMaximum` then the algorithm will attempt to calculate these
-values by using the equations below:
-
- :math:`Q_{min} = 2 \, k \, sin \, \theta = \frac{4 \pi sin \theta}{\lambda_{max}}`
-
- :math:`Q_{max} = 2 \, k \, sin \, \theta = \frac{4 \pi sin \theta}{\lambda_{min}}`
-
-Where :math:`\lambda_{min}` is the minimum extent of the `IvsLambda` Workspace
-and :math:`\lambda_{max}` is the maximum extent of the `IvsLambda` Workspace.
-
-If you have not provided a value for `MomentumTransferStep` then the algorithm
-will use :ref:`algm-NRCalculateSlitResolution` to calculate this value for you.
-
-Scaling
-=======
-
-To apply a scaling to the IvsQ workspace that has been produced by the
-reduction, you will need to provide a value for the `ScaleFactor` property in
-the algorithm. The default for this value is 1.0 and thus no scaling is applied
-to the workspace. The scaling of the IvsQ workspace is performed in-place by the
-:ref:`algm-Scale` algorithm and your IvsQ workspace will be set to the product
-of this algorithm.
-
-Source Rotation
-===============
-
-In the workflow diagram above, after we produce the IvsLambda workspace, it may
-be necessary to rotate the position of the source to match the value of
-ThetaOut (:math:`\theta_f`).
-
-Below we see the typical experimental setup for a Reflectometry instrument. The
-source direction (Beam vector) is along the horizon. This setup is defined in
-the Instrument Defintion File and this instrument setup will be attached to any
-workspaces associated with that instrument. When we pass the IvsLambda workspace
-to :ref:`algm-ConvertUnits` to produce an IvsQ workspace,
-:ref:`algm-ConvertUnits` will assume that :math:`2\theta` is the angle between
-the Beam vector and the sample-to-detector vector. When we have the typical
-setup seen below, :math:`2\theta` will be exactly half the value we wish it to
-be.
-
-.. figure:: /images/CurrentExperimentSetupForReflectometry.png
- :width: 650px
- :height: 250px
- :align: center
-
-We rotate the position of the Source (and therefore the Beam vector) in the
-Instrument Defintion associated with the IvsLambda workspace until the condition
-:math:`\theta_i = \theta_f` is satisfied. This will achieve the desired result
-for :math:`2\theta` (see below for rotated source diagram). After
-:ref:`algm-ConvertUnits` has produced our IvsQ workspace, we will rotate the
-position of the source back to its original position so that the experimental
-setup remains unchanged for other algorithms that may need to manipulate/use it.
-
-.. figure:: /images/RotatedExperimentSetupForReflectometry.png
- :width: 650px
- :height: 250px
- :align: center
-
-
-Processing Instructions
-#######################
-
-These enable a grouping pattern on workspace indices to yield only the detectors of interest. It allows usage of the operators :literal:`,:+-` to specify or exclude specific indices or to add
-spectra together. See :literal:`Grouping Pattern` from :Ref:`algm-GroupDetectors` for further details on their usage.
-
-Usage
------
-
-**Example - Reduce a Run**
-
-.. testcode:: ExReflRedOneSimple
-
- run = Load(Filename='INTER00013460.nxs')
- # Basic reduction with no transmission run
- IvsQ, IvsLam, thetaOut = ReflectometryReductionOne(InputWorkspace=run, ThetaIn=0.7, I0MonitorIndex=2, ProcessingInstructions='3:4',
- WavelengthMin=1.0, WavelengthMax=17.0,
- MonitorBackgroundWavelengthMin=15.0, MonitorBackgroundWavelengthMax=17.0,
- MonitorIntegrationWavelengthMin=4.0, MonitorIntegrationWavelengthMax=10.0, Version=1)
-
- print("The first four IvsLam Y values are: [ {:.4e}, {:.4e}, {:.4e}, {:.4e} ]".format(
- IvsLam.readY(0)[0], IvsLam.readY(0)[1], IvsLam.readY(0)[2], IvsLam.readY(0)[3]))
- print("The first four IvsQ Y values are: [ {:.4e}, {:.4e}, {:.4e}, {:.4e} ]".format(
- IvsQ.readY(0)[0], IvsQ.readY(0)[1], IvsQ.readY(0)[2], IvsQ.readY(0)[3]))
- print("Theta out is the same as theta in: {}".format(thetaOut))
-
-
-Output:
-
-.. testoutput:: ExReflRedOneSimple
-
- The first four IvsLam Y values are: [ 0.0000e+00, 0.0000e+00, 7.8118e-07, 1.9346e-06 ]
- The first four IvsQ Y values are: [ 1.3845e-03, 1.9717e-03, 2.7579e-03, 4.1467e-03 ]
- Theta out is the same as theta in: 0.7
-
-
-.. categories::
-
-.. sourcelink::
diff --git a/docs/source/algorithms/ReflectometryReductionOneAuto-v1.rst b/docs/source/algorithms/ReflectometryReductionOneAuto-v1.rst
deleted file mode 100644
index de816114e3f2feb392fa4ff9da17df161f9764eb..0000000000000000000000000000000000000000
--- a/docs/source/algorithms/ReflectometryReductionOneAuto-v1.rst
+++ /dev/null
@@ -1,166 +0,0 @@
-.. algorithm::
-
-.. summary::
-
-.. alias::
-
-.. properties::
-
-Description
------------
-
-Facade over :ref:`algm-ReflectometryReductionOne`.
-
-Pulls numeric parameters out of the instrument parameters where possible. You can override any of these automatically applied defaults by providing your own value for the input.
-
-See :ref:`algm-ReflectometryReductionOne` for more information on the wrapped algorithm.
-
-ProcessingInstructions
-######################
-
-If ProcessingInstructions is not set its value is inferred from other properties:
-
-* If AnalysisMode = PointDetectorAnalaysis and PointDetectorStart = PointDetectorStop then the spectrum specified by PointDetectorStart is used.
-* If AnalysisMode = PointDetectorAnalaysis and PointDetectorStart ≠PointDetectorStop then the sum of the spectra from PointDetectorStart to PointDetectorStop is used.
-* If AnalysisMode = MultiDetectorAnalaysis then all of the spectra from MultiDetectorStart onwards are used.
-
-Note, the ProcessingInstructions are workspace indicies, not detector IDs. The first few workspaces may correspond to monitors, rather than detectors of interest.
-For the syntax of this property, see :ref:`algm-GroupDetectors`.
-
-Workflow for WorkspaceGroups
-############################
-
-If a WorkspaceGroup is provided to ReflectometryReductionOneAuto, it will follow the steps shown in the diagram below to produce its output.
-
-.. diagram:: ReflectometryReductionOneAuto-v1-Groups_wkflw.dot
-
-Workflow for Polarization Correction
-####################################
-
-If polarization correction is enabled, it is performed as an additional step once the main processing has completed.
-The following diagram shows how the :ref:`algm-PolarizationCorrection` algorithm is used.
-
-.. diagram:: ReflectometryReductionOneAuto-v1-PolarizationCorrection_wkflw.dot
-
-Polynomial Correction
-#####################
-
-If no Transmission runs are provided, then polynomial correction can be
-performed instead. Polynomial correction is enabled by setting the
-:literal:`CorrectionAlgorithm` property.
-
-If set to :literal:`AutoDetect`, it looks at the instrument
-parameters for the :literal:`correction` parameter. If it is set to
-:literal:`polynomial`, then polynomial correction is performed using the
-:ref:`algm-PolynomialCorrection` algorithm, with the polynomial string taken
-from the instrument's :literal:`polynomial` parameter. If the
-:literal:`correction` parameter is set to :literal:`exponential` instead, then
-the :Ref:`algm-ExponentialCorrection` algorithm is used, with C0 and C1 taken
-from the instrument parameters, :literal:`C0` and :literal:`C1`.
-
-These can be specified manually by setting the :literal:`CorrectionAlgorithm`,
-:literal:`Polynomial`, :literal:`C0`, and :literal:`C1` properties accordingly.
-
-Usage
------
-
-**Example - Reduce a Run**
-
-.. testcode:: ExReflRedOneAutoSimple
-
- run = Load(Filename='INTER00013460.nxs')
- # Basic reduction with no transmission run
- IvsQ, IvsLam, thetaOut = ReflectometryReductionOneAuto(InputWorkspace=run, ThetaIn=0.7, Version=1)
-
- print("The first four IvsLam Y values are: [ {:.4e}, {:.4e}, {:.4e}, {:.4e} ]".format(
- IvsLam.readY(0)[0], IvsLam.readY(0)[1], IvsLam.readY(0)[2], IvsLam.readY(0)[3]))
- print("The first four IvsQ Y values are: [ {:.4e}, {:.4e}, {:.4e}, {:.4e} ]".format(
- IvsQ.readY(0)[0], IvsQ.readY(0)[1], IvsQ.readY(0)[2], IvsQ.readY(0)[3]))
- print("Theta out is the same as theta in: {}".format(thetaOut))
-
-Output:
-
-.. testoutput:: ExReflRedOneAutoSimple
-
- The first four IvsLam Y values are: [ 5.3860e-06, 9.3330e-06, 6.9796e-06, 6.5687e-06 ]
- The first four IvsQ Y values are: [ 1.3648e-03, 1.9490e-03, 2.7277e-03, 4.0995e-03 ]
- Theta out is the same as theta in: 0.7
-
-**Example - Reduce a Run with a transmission run**
-
-.. testcode:: ExReflRedOneAutoTrans
-
- run = Load(Filename='INTER00013460.nxs')
- trans = Load(Filename='INTER00013463.nxs')
- # Basic reduction with a transmission run
- IvsQ, IvsLam, thetaOut = ReflectometryReductionOneAuto(InputWorkspace=run, FirstTransmissionRun=trans, ThetaIn=0.7, Version=1)
-
- print("The first four IvsLam Y values are: [ {:.4e}, {:.4e}, {:.4e}, {:.4e} ]".format(
- IvsLam.readY(0)[0], IvsLam.readY(0)[1], IvsLam.readY(0)[2], IvsLam.readY(0)[3]))
- print("The first four IvsQ Y values are: [ {:.4e}, {:.4e}, {:.4e}, {:.4e} ]".format(
- IvsQ.readY(0)[0], IvsQ.readY(0)[1], IvsQ.readY(0)[2], IvsQ.readY(0)[3]))
- print("Theta out is the same as theta in: {}".format(thetaOut))
-
-Output:
-
-.. testoutput:: ExReflRedOneAutoTrans
-
- The first four IvsLam Y values are: [ 3.2705e-05, 5.5450e-05, 3.9630e-05, 3.5770e-05 ]
- The first four IvsQ Y values are: [ 9.3930e-01, 1.3251e+00, 1.2766e+00, 1.1977e+00 ]
- Theta out is the same as theta in: 0.7
-
-**Example - Reduce a Run overloading default parameters**
-
-.. testcode:: ExReflRedOneAutoOverload
-
- run = Load(Filename='INTER00013460.nxs')
- # Reduction overriding the default values for MonitorBackgroundWavelengthMin and MonitorBackgroundWavelengthMax which would otherwise be retirieved from the workspace
- IvsQ, IvsLam, thetaOut = ReflectometryReductionOneAuto(InputWorkspace=run, ThetaIn=0.7, MonitorBackgroundWavelengthMin=0.0, MonitorBackgroundWavelengthMax=1.0, Version=1)
-
- print("The first four IvsLam Y values are: [ {:.4e}, {:.4e}, {:.4e}, {:.4e} ]".format(
- IvsLam.readY(0)[0], IvsLam.readY(0)[1], IvsLam.readY(0)[2], IvsLam.readY(0)[3]))
- print("The first four IvsQ Y values are: [ {:.4e}, {:.4e}, {:.4e}, {:.4e} ]".format(
- IvsQ.readY(0)[0], IvsQ.readY(0)[1], IvsQ.readY(0)[2], IvsQ.readY(0)[3]))
- print("Theta out is the same as theta in: {}".format(thetaOut))
-
-Output:
-
-.. testoutput:: ExReflRedOneAutoOverload
-
- The first four IvsLam Y values are: [ 5.3868e-06, 9.3344e-06, 6.9807e-06, 6.5696e-06 ]
- The first four IvsQ Y values are: [ 1.3650e-03, 1.9493e-03, 2.7281e-03, 4.1001e-03 ]
- Theta out is the same as theta in: 0.7
-
-**Example - Polynomial correction**
-
-.. testcode:: ExReflRedOneAutoPoly
-
- run = Load(Filename='INTER00013460.nxs')
- # Set up some paramters, allowing the algorithm to automatically detect the correction to use
- SetInstrumentParameter(run, "correction", Value="polynomial")
- SetInstrumentParameter(run, "polynomial", Value="0,0.5,1,2,3")
-
- IvsQ, IvsLam, thetaOut = ReflectometryReductionOneAuto(InputWorkspace=run, ThetaIn=0.7, Version=1)
-
- def findByName(histories, name):
- return next(x for x in histories if x.name() == name)
-
- # Find the PolynomialCorrection entry in the workspace's history
- algHist = IvsLam.getHistory()
- refRedOneAutoHist = findByName(algHist.getAlgorithmHistories(), "ReflectometryReductionOneAuto")
- refRedOneHist = findByName(refRedOneAutoHist.getChildHistories(), "ReflectometryReductionOne")
- polyCorHist = findByName(refRedOneHist.getChildHistories(), "PolynomialCorrection")
-
- coefProp = findByName(polyCorHist.getProperties(), "Coefficients")
-
- print("Coefficients: '{}'".format(coefProp.value()))
-
-Output:
-
-.. testoutput:: ExReflRedOneAutoPoly
-
- Coefficients: '0,0.5,1,2,3'
-
-.. categories::
-
-.. sourcelink::
diff --git a/docs/source/algorithms/ReflectometryReductionOneAuto-v2.rst b/docs/source/algorithms/ReflectometryReductionOneAuto-v2.rst
index 2bb6d64880052340b85f7d877f04c954f744278d..a923be6b6548d6e80ea02dde9fd1be789ad9b3c0 100644
--- a/docs/source/algorithms/ReflectometryReductionOneAuto-v2.rst
+++ b/docs/source/algorithms/ReflectometryReductionOneAuto-v2.rst
@@ -43,7 +43,7 @@ The rest of the input properties are not inferred from the parameter file, and m
property that allows users to specify a region of direct beam that will be used to normalize
the detector signal. The region of direct beam is specified by workspace indices. For instance, :literal:`RegionOfDirectBeam='2-3'`
means that spectra with workspace indices :literal:`2` and :literal:`3` will be summed and the resulting
-workspace will be used as the direct beam workspace.
+workspace will be used as the direct beam workspace.
Transmission corrections can be optionally applied by providing either one or
two transmission runs or polynomial corrections. Polynomial correction is enabled by setting the
diff --git a/docs/source/release/v3.13.0/reflectometry.rst b/docs/source/release/v3.13.0/reflectometry.rst
index 7875f5476718bb0ae1ecf8099b01eb44bb63ea75..98aa3777f200afa8157604472e9d019aef913890 100644
--- a/docs/source/release/v3.13.0/reflectometry.rst
+++ b/docs/source/release/v3.13.0/reflectometry.rst
@@ -9,4 +9,34 @@ Reflectometry Changes
putting new features at the top of the section, followed by
improvements, followed by bug fixes.
+ISIS Reflectometry Interface
+----------------------------
+
+New features
+############
+
+Improvements
+############
+
+Bug fixes
+#########
+
+Features Removed
+################
+
+Algorithms
+----------
+
+* Removed version 1 of ``ReflectometryReductionOne`` and ``ReflectometryReductionOneAuto``.
+
+New features
+############
+
+
+Improvements
+############
+
+Bug fixes
+#########
+
:ref:`Release 3.13.0 <v3.13.0>`
diff --git a/instrument/INTER_Definition.xml b/instrument/INTER_Definition.xml
index f93d09929fa45b9d30ae7889b71fb57848529b70..fa286b8d69cdb06c8bc55b37896c2c6ad7c268d2 100644
--- a/instrument/INTER_Definition.xml
+++ b/instrument/INTER_Definition.xml
@@ -1,10 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
+<!-- For help on the notation used to specify an Instrument Definition File
+ see http://www.mantidproject.org/IDF -->
<instrument xmlns="http://www.mantidproject.org/IDF/1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd"
- name="INTER" valid-from ="1900-01-31 23:59:59"
- valid-to ="2100-01-31 23:59:59"
- last-modified="2010-11-04 00:00:00">
+ name="INTER"
+ valid-from="1900-01-31 23:59:59"
+ valid-to= "2017-02-13 23:59:59"
+ last-modified="2018-02-16 00:00:00">
+
<defaults>
<length unit="meter" />
<angle unit="degree" />
@@ -16,57 +20,34 @@
<default-view axis-view="z+"/>
</defaults>
- <!-- Definition of instrument specific parameters for data reduction (e.g. wavelength cutoffs etc.) , could go into paramter file
- MonitorBackground= [7.6,8.5]
- MonitorsToCorrect=[1]
- PointDetectorStart=[0] # Note: Since we are removing the monitors in the load raw command they are not counted here.
- PointDetectorStop=[0]
- MultiDetectorStart=[1]
- I0MonitorIndex=1
- -->
-
-<!-- here we need to add the other monitors -->
- <!-- parameters for efficiency correction -->
- <parameter name="correction" type="string">
- <value val="polynomial"/>
- </parameter>
-
- <parameter name="polystring" type="string">
- <value val="35.5893,-24.5591,9.20375,-1.89265,0.222291,-0.0148746,0.00052709,-7.66807e-6"/>
- <!--<value val="28.0051,-19.396,7.5629,-1.624,0.1986,-0.013783,0.00050478,-7.56647e-6"/>-->
- </parameter>
-
- <!-- BRIEF DESCRIPTION OF Inter INSTRUMENT:
-
- Here Z=0 is defined by the neutron beam which slopes down at 2.3 deg.
- from the horizon. This description is based on data provided by Tim
- Charlton and Rob Dalgliesh.
-
- Note from Tim spreedsheet
- theta is a rotation about the y axis
- phi is a rotation about the x axis
- chi is a rotation about the z axis
-
- Noticed the face of the monitors/detector shapes that faces the
- beam/sample path is in this IDF defined to be the y-z plane.
-
- Note the status of the instrument during a run is stored in the
- logfile RunNo_status.txt
- -->
+<!-- source and sample-position components START============================= -->
+
+ <component type="source">
+ <location z="-17.037" />
+ </component>
+ <type name="source" is="Source">
+ <properties>
+ 40mm(H) x 60mm(W)
+ </properties>
+ </type>
+
+ <component type="some-surface-holder">
+ <location x="0.0" y="0.0" z="0.0"/>
+ </component>
+ <type name="some-surface-holder" is="SamplePos"/>
- <!-- LIST OF PHYSICAL COMPONENTS (which the instrument consists of) -->
+<!-- source and sample-position components END=============================== -->
- <!-- detector components (including monitors) -->
+<!-- LIST OF PHYSICAL COMPONENTS (which the instrument consists of) -->
+<!-- detector components (including monitors) -->
+
+<!-- ================MONITOR 1 START========================================= -->
<component type="monitor1" idlist="monitor1">
- <location z="6.96" />
+ <location z="-10.077" />
</component>
<type name="monitor1" is="monitor">
- <!-- Shape specified at least big enough to cover the beam which
- is 10mm high and 40mm wide. Note it is described as tube, hence
- the choice of a cylinder shape.
- -->
<percent-transparency val="95" />
<cylinder id="shape">
<centre-of-bottom-base z="0.0" x="-0.02" y="0.0" />
@@ -76,17 +57,14 @@
</cylinder>
<algebra val="shape" />
</type>
+<!-- ================MONITOR 1 END=========================================== -->
+<!-- ================MONITOR 2 START========================================= -->
<component type="monitor2" idlist="monitor2">
- <location z="13.791" /> <!-- x = 23.0-5.05 -->
+ <location z="-3.246" />
</component>
<type name="monitor2" is="monitor">
- <!-- Shape specified as a minimum needs to cover the beam which
- is 10mm high and 40mm wide. The 'top' shape is included to
- more easily recognise this monitor when visualised in MantidPlot.
- This monitor is suppose to look a bit like a German hand grenade.
- -->
<percent-transparency val="95" />
<cuboid id="base">
<left-front-bottom-point z="0.04" x="-0.02" y="-0.01" />
@@ -101,23 +79,16 @@
<radius val="0.02" />
<height val="0.04" />
</cylinder>
-
<algebra val="base : top" />
</type>
+<!-- ================MONITOR 2 END=========================================== -->
+<!-- ================MONITOR 3 START========================================= -->
<component type="monitor3" idlist="monitor3">
- <location z="16.785" /> <!-- 23.0-0.425 -->
+ <location z="-0.252" />
</component>
<type name="monitor3" is="monitor">
- <!-- Shape specified as a minimum needs to cover the beam which
- is 10mm high and 40mm wide. The 'top' shape is included to
- more easily recognise this monitor when visualised in MantidPlot.
- This monitor is suppose to look a bit like a German hand grenade.
-
-
-
- -->
<percent-transparency val="95" />
<cuboid id="base">
<left-front-bottom-point z="0.04" x="-0.02" y="-0.01" />
@@ -135,26 +106,15 @@
<algebra val="base : top" />
</type>
+<!-- ================MONITOR 2 END=========================================== -->
+<!-- ================POINT DETECTOR START==================================== -->
<component type="point-detector" idlist="point-detector">
- <location z="19.700" /> <!-- x= 23.0+2.6 -->
-
- <!-- Link to log file that stores the z position. This angle can be used to
- calculate the z position since the distance along the x-axis between
- the sample and this detector is known (2.6m). Also theta in the logfile is
- assumed to in degrees, hence the reason for the pi/180=0.0174533 transformation
- to radians factor in the eq attribute.
-
-
- This calculation becomes more complex due to the detector table and height stage above it.
- It should be revisited when the log files become more stable.
-
- We may actually want to draw in the table for clarity.
- -->
+ <location z="2.663" /> <!-- x= 23.0+2.6 -->
<parameter name="y">
- <logfile id="PD1H" eq="(value+201.0)/1000." extract-single-value-as="last_value"/>
- <!--<logfile id="theta" eq="2.6*sin(value*0.0174533)" extract-single-value-as="last_value"/>-->
+ <!-- <logfile id="PD1H" eq="(value+201.0)/1000." extract-single-value-as="last_value"/> -->
+ <logfile id="theta" eq="2.663*sin(2*value*0.0174533)" extract-single-value-as="last_value"/>
</parameter>
</component>
@@ -173,53 +133,13 @@
</cuboid>
<algebra val="shape" />
</type>
+<!-- ================POINT DETECTOR END====================================== -->
-
- <component type="point-detector2" idlist="point-detector2">
-
- <location z="19.700" /> <!-- x= 23.0+2.6 -->
-
- <!-- Link to log file that stores the z position. This angle can be used to
- calculate the z position since the distance along the x-axis between
- the sample and this detector is known (2.6m). Also theta in the logfile is
- assumed to in degrees, hence the reason for the pi/180=0.0174533 transformation
- to radians factor in the eq attribute.
-
-
- This calculation becomes more complex due to the detector table and height stage above it.
- It should be revisited when the log files become more stable.
-
- We may actually want to draw in the table for clarity.
- -->
- <parameter name="y">
- <logfile id="PD1H" eq="(value+301.0)/1000" extract-single-value-as="last_value"/>
- <!--<logfile id="Theta" eq="2.7*sin((value+1)*0.0174533)" extract-single-value-as="last_value"/> -->
- </parameter>
-
- </component>
-
- <type name="point-detector2" is="detector">
- <!-- Not exactly sure about the dimensions of this one. But pretty sure
- it at least covers the beam. Also, just in front of it is a slit which
- at the end of day will determine which neutrons get through to this
- detector I believe.
- -->
- <cuboid id="shape">
- <left-front-bottom-point z="0.01" x="-0.02" y="-0.005" />
- <left-front-top-point z="0.01" x="-0.02" y="0.005" />
- <left-back-bottom-point z="-0.01" x="-0.02" y="-0.005" />
- <right-front-bottom-point z="0.01" x="0.02" y="-0.005" />
- </cuboid>
- <algebra val="shape" />
- </type>
-
-
-
- <!-- ################################### -->
+<!-- ================LINEAR DETECTOR START=================================== -->
<component type="panel" idstart="2001" idfillbyfirst="y" idstep="1" idstepbyrow="1">
- <location z="20.200" name="linear-detector"/>
+ <location z="3.163" name="linear-detector"/>
<parameter name="y">
- <logfile id="Theta" eq="3.2*tan(value*0.0174533)-46*0.0012" extract-single-value-as="last_value"/>
+ <logfile id="Theta" eq="3.163*tan(2*value*0.0174533)-46*0.0012" extract-single-value-as="last_value"/>
</parameter>
</component>
@@ -239,57 +159,12 @@
</cuboid>
<algebra val="shape" />
</type>
+<!-- ================LINEAR DETECTOR END-==================================== -->
-
- <!-- source and sample-position components -->
-
- <component type="source">
- <location />
- </component>
-
- <type name="source" is="Source">
- <properties>
- 40mm(H) x 60mm(W)
- </properties>
- </type>
-
-
- <component type="some-surface-holder">
- <!-- worry about linking relevant logfiles for y,z,theta,phi up later -->
- <location z="17.037"/>
- </component>
-
- <type name="some-surface-holder" is="SamplePos">
- </type>
-
-
- <!-- other components -->
-
- <!-- Must change the distances below to match polref -->
-
- <component type="test" name="test1">
- <location z="13.200"/>
- <parameter name="y">
- <value val="-0.1"/>
- </parameter>
- <location z="13.00" />
- <parameter name="y">
- <value val="0.1"/>
- </parameter>
- </component>
-
- <type name="test">
- <percent-transparency val="50" />
- <cuboid id="bottom">
- <left-front-bottom-point z="0.0005" x="-0.025" y="-0.03" />
- <left-front-top-point z="0.0005" x="-0.025" y="0.0" />
- <left-back-bottom-point z="-0.0005" x="-0.025" y="-0.03" />
- <right-front-bottom-point z="0.0005" x="0.025" y="-0.03" />
- </cuboid>
- </type>
+<!-- other components -->
<component type="slit" name="slit1">
- <location z="14.801"/>
+ <location z="-2.236"/>
<!-- This log file stores the vertical opening of slit -->
<parameter name="vertical gap">
<logfile id="S1_VG" extract-single-value-as="last_value" />
@@ -297,15 +172,10 @@
<parameter name="y">
<logfile id="S1_VG" eq="-value*0.001/2.0" extract-single-value-as="last_value" />
</parameter>
-
- <parameter name="y2">
- <logfile id="S1_VG" eq="0.3+value*0.001/2.0" extract-single-value-as="last_value" />
- </parameter>
- <location z="15.250" y="0.3"/>
- </component>
+ </component>
<component type="slit" name="slit2">
- <location z="16.724"/>
+ <location z="-0.313"/>
<!-- This log file stores the vertical opening of this. Note this
slit can also be translated in the z. However this info not stored
in log file since it is not used in the data analysis process. -->
@@ -315,7 +185,7 @@
</component>
<component type="slit" name="slit3">
- <location z="18.200"/> <!-- x=23.0+0.960 -->
+ <location z="1.163"/> <!-- x=23.0+0.960 -->
<!-- This log file stores the vertical opening of slit -->
<parameter name="vertical gap">
<logfile id="S3_VG" extract-single-value-as="last_value" />
@@ -323,7 +193,7 @@
</component>
<component type="slit" name="slit4">
- <location z="19.700"/> <!-- x=23.0+2.445 -->
+ <location z="2.663"/> <!-- x=23.0+2.445 -->
<!-- This log file stores the vertical opening of slit. Note this slit
is fixed to the point detector. -->
<parameter name="vertical gap">
@@ -340,33 +210,15 @@
<right-front-bottom-point z="0.0005" x="0.025" y="-0.03" />
</cuboid>
</type>
- <!-- <cuboid id="top">
- <left-front-bottom-point z="0.0005" x="-0.025" y="0.01" />
- <left-front-top-point z="0.0005" x="-0.025" y="0.04" />
- <left-back-bottom-point z="-0.0005" x="-0.025" y="0.01" />
- <right-front-bottom-point z="0.0005" x="0.025" y="0.01" />
- </cuboid>
- <algebra val="top : bottom" />
- <type name="slit2"></type>
- <type name="slit3"></type>
- <type name="slit4"></type>
- -->
-
<component type="supermirror">
- <!-- Worry about linking relevant logfiles for z,theta up later -->
<location z="28.52"/> <!-- x=32.0-3.480 -->
</component>
-
<type name="supermirror" />
-
- <!-- DETECTOR and MONITOR ID LISTS -->
-
-
-
+<!-- DETECTOR and MONITOR ID LISTS -->
<idlist idname="monitor1">
<id val="1" />
</idlist>
@@ -383,9 +235,6 @@
<id val="4" />
</idlist>
- <idlist idname="point-detector2">
- <id val="5" />
- </idlist>
<!--
<idlist idname="linear-detector">
<id start="2001" end="2240" />
diff --git a/instrument/INTER_Definition_2017.xml b/instrument/INTER_Definition_2017.xml
new file mode 100644
index 0000000000000000000000000000000000000000..b29e15202d7fc3ea3acf122a9d0085d199f9f664
--- /dev/null
+++ b/instrument/INTER_Definition_2017.xml
@@ -0,0 +1,243 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- For help on the notation used to specify an Instrument Definition File
+ see http://www.mantidproject.org/IDF -->
+<instrument xmlns="http://www.mantidproject.org/IDF/1.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd"
+ name="INTER"
+ valid-from="2017-02-14 00:00:00"
+ valid-to= "2100-01-31 23:59:59"
+ last-modified="2018-02-16 00:00:00">
+
+ <defaults>
+ <length unit="meter" />
+ <angle unit="degree" />
+ <reference-frame>
+ <along-beam axis="z" />
+ <pointing-up axis="y" />
+ <handedness val="right" />
+ </reference-frame>
+ <default-view axis-view="z+"/>
+ </defaults>
+
+<!-- source and sample-position components START============================= -->
+
+ <component type="source">
+ <location z="-17.037" />
+ </component>
+ <type name="source" is="Source">
+ <properties>
+ 40mm(H) x 60mm(W)
+ </properties>
+ </type>
+
+ <component type="some-surface-holder">
+ <location x="0.0" y="0.0" z="0.0"/>
+ </component>
+ <type name="some-surface-holder" is="SamplePos"/>
+
+<!-- source and sample-position components END=============================== -->
+
+
+<!-- LIST OF PHYSICAL COMPONENTS (which the instrument consists of) -->
+<!-- detector components (including monitors) -->
+
+<!-- ================MONITOR 1 START========================================= -->
+ <component type="monitor1" idlist="monitor1">
+ <location z="-10.077" />
+ </component>
+
+ <type name="monitor1" is="monitor">
+ <percent-transparency val="95" />
+ <cylinder id="shape">
+ <centre-of-bottom-base z="0.0" x="-0.02" y="0.0" />
+ <axis z="0.0" x="1.0" y="0.0" />
+ <radius val="0.01" />
+ <height val="0.04" />
+ </cylinder>
+ <algebra val="shape" />
+ </type>
+<!-- ================MONITOR 1 END=========================================== -->
+
+<!-- ================MONITOR 2 START========================================= -->
+ <component type="monitor2" idlist="monitor2">
+ <location z="-3.246" />
+ </component>
+
+ <type name="monitor2" is="monitor">
+ <percent-transparency val="95" />
+ <cuboid id="base">
+ <left-front-bottom-point z="0.04" x="-0.02" y="-0.01" />
+ <left-front-top-point z="0.04" x="-0.02" y="0.01" />
+ <left-back-bottom-point z="-0.04" x="-0.02" y="-0.01" />
+ <right-front-bottom-point z="0.04" x="0.02" y="-0.01" />
+ </cuboid>
+
+ <cylinder id="top">
+ <centre-of-bottom-base z="0.0" x="0.0" y="0.01" />
+ <axis z="0.0" x="0.0" y="1.0" />
+ <radius val="0.02" />
+ <height val="0.04" />
+ </cylinder>
+ <algebra val="base : top" />
+ </type>
+<!-- ================MONITOR 2 END=========================================== -->
+
+<!-- ================MONITOR 3 START========================================= -->
+ <component type="monitor3" idlist="monitor3">
+ <location z="-0.252" />
+ </component>
+
+ <type name="monitor3" is="monitor">
+ <percent-transparency val="95" />
+ <cuboid id="base">
+ <left-front-bottom-point z="0.04" x="-0.02" y="-0.01" />
+ <left-front-top-point z="0.04" x="-0.02" y="0.01" />
+ <left-back-bottom-point z="-0.04" x="-0.02" y="-0.01" />
+ <right-front-bottom-point z="0.04" x="0.02" y="-0.01" />
+ </cuboid>
+
+ <cylinder id="top">
+ <centre-of-bottom-base z="0.0" x="0.0" y="0.01" />
+ <axis z="0.0" x="0.0" y="1.0" />
+ <radius val="0.02" />
+ <height val="0.04" />
+ </cylinder>
+
+ <algebra val="base : top" />
+ </type>
+<!-- ================MONITOR 2 END=========================================== -->
+
+<!-- ================POINT DETECTOR START==================================== -->
+ <component type="point-detector" idlist="point-detector">
+
+ <location z="2.663" /> <!-- x= 23.0+2.6 -->
+ <parameter name="y">
+ <logfile id="PD1H" eq="(value+201.0)/1000." extract-single-value-as="last_value"/>
+ <!--<logfile id="theta" eq="2.6*sin(value*0.0174533)" extract-single-value-as="last_value"/>-->
+ </parameter>
+
+ </component>
+
+ <type name="point-detector" is="detector">
+ <!-- Not exactly sure about the dimensions of this one. But pretty sure
+ it at least covers the beam. Also, just in front of it is a slit which
+ at the end of day will determine which neutrons get through to this
+ detector I believe.
+ -->
+ <cuboid id="shape">
+ <left-front-bottom-point z="0.01" x="-0.02" y="-0.005" />
+ <left-front-top-point z="0.01" x="-0.02" y="0.005" />
+ <left-back-bottom-point z="-0.01" x="-0.02" y="-0.005" />
+ <right-front-bottom-point z="0.01" x="0.02" y="-0.005" />
+ </cuboid>
+ <algebra val="shape" />
+ </type>
+<!-- ================POINT DETECTOR END====================================== -->
+
+<!-- ================LINEAR DETECTOR START=================================== -->
+ <component type="panel" idstart="2001" idfillbyfirst="y" idstep="1" idstepbyrow="1">
+ <location z="3.163" name="linear-detector"/>
+ <parameter name="y">
+ <logfile id="Theta" eq="3.163*tan(2*value*0.0174533)-46*0.0012" extract-single-value-as="last_value"/>
+ </parameter>
+
+ </component>
+
+ <type name="panel" is="rectangular_detector" type="linear-detector-pixel"
+ xpixels="1" xstart="0.0" xstep="0.05"
+ ypixels="243" ystart="0.0" ystep="+0.0012" >
+ <properties/>
+ </type>
+ <!--"-0.0576"-->
+ <type name="linear-detector-pixel" is="detector">
+ <cuboid id="shape">
+ <left-front-bottom-point z="0.01" x="-0.025" y="-0.0006" />
+ <left-front-top-point z="0.01" x="-0.025" y="0.0006" />
+ <left-back-bottom-point z="-0.01" x="-0.025" y="-0.0006" />
+ <right-front-bottom-point z="0.01" x="0.025" y="-0.0006" />
+ </cuboid>
+ <algebra val="shape" />
+ </type>
+<!-- ================LINEAR DETECTOR END-==================================== -->
+
+<!-- other components -->
+
+ <component type="slit" name="slit1">
+ <location z="-2.236"/>
+ <!-- This log file stores the vertical opening of slit -->
+ <parameter name="vertical gap">
+ <logfile id="S1VG" extract-single-value-as="last_value" />
+ </parameter>
+ <parameter name="y">
+ <logfile id="S1VG" eq="-value*0.001/2.0" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <component type="slit" name="slit2">
+ <location z="-0.313"/>
+ <!-- This log file stores the vertical opening of this. Note this
+ slit can also be translated in the z. However this info not stored
+ in log file since it is not used in the data analysis process. -->
+ <parameter name="vertical gap">
+ <logfile id="S2VG" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <component type="slit" name="slit3">
+ <location z="1.163"/> <!-- x=23.0+0.960 -->
+ <!-- This log file stores the vertical opening of slit -->
+ <parameter name="vertical gap">
+ <logfile id="S3VG" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <component type="slit" name="slit4">
+ <location z="2.663"/> <!-- x=23.0+2.445 -->
+ <!-- This log file stores the vertical opening of slit. Note this slit
+ is fixed to the point detector. -->
+ <parameter name="vertical gap">
+ <logfile id="S4VG" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <type name="slit">
+ <percent-transparency val="50" />
+ <cuboid id="bottom">
+ <left-front-bottom-point z="0.0005" x="-0.025" y="-0.03" />
+ <left-front-top-point z="0.0005" x="-0.025" y="0.0" />
+ <left-back-bottom-point z="-0.0005" x="-0.025" y="-0.03" />
+ <right-front-bottom-point z="0.0005" x="0.025" y="-0.03" />
+ </cuboid>
+ </type>
+
+ <component type="supermirror">
+ <location z="28.52"/> <!-- x=32.0-3.480 -->
+ </component>
+ <type name="supermirror" />
+
+
+
+<!-- DETECTOR and MONITOR ID LISTS -->
+ <idlist idname="monitor1">
+ <id val="1" />
+ </idlist>
+
+ <idlist idname="monitor2">
+ <id val="2" />
+ </idlist>
+
+ <idlist idname="monitor3">
+ <id val="3" />
+ </idlist>
+
+ <idlist idname="point-detector">
+ <id val="4" />
+ </idlist>
+
+ <!--
+ <idlist idname="linear-detector">
+ <id start="2001" end="2240" />
+ </idlist>
+ -->
+</instrument>
diff --git a/instrument/SURF_Definition.xml b/instrument/SURF_Definition.xml
index 41da6e13809972cc37be02ebb7e13d45b8a1e646..382c01e0c02513a1cbf825f1153fca4640082d51 100644
--- a/instrument/SURF_Definition.xml
+++ b/instrument/SURF_Definition.xml
@@ -1,10 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
-<instrument xmlns="http://www.mantidproject.org/IDF/1.0"
+<!-- For help on the notation used to specify an Instrument Definition File
+ see http://www.mantidproject.org/IDF -->
+<instrument xmlns="http://www.mantidproject.org/IDF/1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd"
- name="SRF" valid-from ="2010-01-10 23:59:59"
- valid-to ="2100-01-30 23:59:59"
- last-modified="2010-11-04 00:00:00">
+ name="SURF"
+ valid-from="2010-01-10 23:59:59"
+ valid-to="2017-02-13 23:59:59"
+ last-modified="2018-03-15 00:00:00">
+
<defaults>
<length unit="meter" />
<angle unit="degree" />
@@ -13,99 +17,87 @@
<pointing-up axis="y" />
<handedness val="right" />
</reference-frame>
- <default-view axis-view="z-"/>
+ <default-view axis-view="z+"/>
</defaults>
- <!-- Definition of instrument specific parameters for data reduction (e.g. wavelength cutoffs etc.) , could go into paramter file
- MonitorBackground= [7.6,8.5]
- MonitorsToCorrect=[1]
- PointDetectorStart=[0] # Note: Since we are removing the monitors in the load raw command they are not counted here.
- PointDetectorStop=[0]
- MultiDetectorStart=[1]
- I0MonitorIndex=1
- -->
-
- <!-- BRIEF DESCRIPTION OF CRISP INSTRUMENT:
-
- Here Z=0 is defined by the neutron beam which slopes down at 1.5 deg.
- from the horizon. This description is based on data provided by Tim
- Charlton and Rob Dalgliesh.
-
- Note from Tim spreedsheet
- theta is a rotation about the y axis
- phi is a rotation about the x axis
- chi is a rotation about the z axis
-
- Noticed the face of the monitors/detector shapes that faces the
- beam/sample path is in this IDF defined to be the y-z plane.
-
- Note the status of the instrument during a run is stored in the
- logfile RunNo_status.txt
- -->
-
-
- <!-- LIST OF PHYSICAL COMPONENTS (which the instrument consists of) -->
-
- <!-- detector components (including monitors) -->
-
+<!-- source and sample-position components START============================= -->
+
+ <component type="source">
+ <location z="-8.869" />
+ </component>
+ <type name="source" is="Source">
+ <properties>
+ 40mm(H) x 60mm(W)
+ </properties>
+ </type>
+
+ <component type="some-surface-holder">
+ <location x="0.0" y="0.0" z="0.0"/>
+ </component>
+ <type name="some-surface-holder" is="SamplePos"/>
+
+<!-- source and sample-position components END=============================== -->
+
+
+<!-- LIST OF PHYSICAL COMPONENTS (which the instrument consists of) -->
+<!-- detector components (including monitors) -->
+
+<!-- ================MONITOR 1 START========================================= -->
<component type="monitor1" idlist="monitor1">
- <location z="7.2055"/>
+ <location z="-1.663"/>
</component>
-
+
<type name="monitor1" is="monitor">
<!-- Shape specified at least big enough to cover the beam which
is 10mm high and 40mm wide. Note it is described as tube, hence
the choice of a cylinder shape.
- -->
+ -->
<percent-transparency val="95" />
<cylinder id="shape">
<centre-of-bottom-base x="-0.02" y="0.0" z="0.0" />
- <axis x="1.0" y="0.0" z="0.0" />
+ <axis x="1.0" y="0.0" z="0.0" />
<radius val="0.01" />
<height val="0.04" />
- </cylinder>
+ </cylinder>
<algebra val="shape" />
- </type>
-
+ </type>
+<!-- ================MONITOR 1 END=========================================== -->
+
+<!-- ================MONITOR 2 START========================================= -->
<component type="monitor2" idlist="monitor2">
- <location z="8.72" />
- </component>
-
+ <location z="-0.149" />
+ </component>
+
<type name="monitor2" is="monitor">
<!-- Original shape included a Sphere attached to the cuboid
- but that was cosmetic only as it is not in the beam,
- and was causing problems with opencascade on windows 8.
- Therefore it has been removed. -->
+ but that was cosmetic only as it is not in the beam,
+ and was causing problems with opencascade on windows 8.
+ Therefore it has been removed. -->
<percent-transparency val="95" />
<cuboid id="base">
<left-front-bottom-point x="0.02" y="-0.005" z="0.0" />
<left-front-top-point x="0.02" y="0.005" z="0.0" />
<left-back-bottom-point x="0.02" y="-0.005" z="-0.01" />
- <right-front-bottom-point x="-0.02" y="-0.005" z="0.0" />
+ <right-front-bottom-point x="-0.02" y="-0.005" z="0.0" />
</cuboid>
-
- </type>
-
+ </type>
+<!-- ================MONITOR 2 END=========================================== -->
+
+<!-- ================POINT DETECTOR START==================================== -->
<component type="point-detector" idlist="point-detector">
- <location z="11.43" />
-
- <!-- Link to log file that stores the z position. This angle can be used to
- calculate the y position since the distance along the z-axis between
- the sample and this detector is known (11.43-8.869=2.561). Also theta in the logfile is
- assumed to in degrees, hence the reason for the pi/180=0.0174533 transformation
- to radians factor in the eq attribute. -->
+ <location z="2.561" />
<parameter name="y">
- <logfile id="theta" eq="2.561*sin(value*0.0174533)" />
+ <logfile id="THETA" eq="2.561*sin(2*value*0.0174533)" extract-single-value-as="last_value"/>
</parameter>
-
+
</component>
<type name="point-detector" is="detector">
<!-- Not exactly sure about the dimensions of this one. But pretty sure
it at least covers the beam. Also, just in front of it is a slit which
- at the end of day will determine which neutrons get through to this
+ at the end of day will determine which neutrons get through to this
detector I believe.
- -->
+ -->
<cuboid id="shape">
<left-front-bottom-point x="0.02" y="-0.005" z="0.0" />
<left-front-top-point x="0.02" y="0.005" z="0.0" />
@@ -113,34 +105,20 @@
<right-front-bottom-point x="-0.02" y="-0.005" z="0.0" />
</cuboid>
<algebra val="shape" />
- </type>
+ </type>
+<!-- ================POINT DETECTOR END====================================== -->
+<!-- ================AREA DETECTOR START=================================== -->
<component type="panel" idstart="10001" idfillbyfirst="y" idstep="1" idstepbyrow="64">
- <location z="11.93" name="multi-detector"/>
+ <location z="3.061" name="multi-detector"/>
</component>
-
- <!--
- <component type="multi-detector" idlist="multi-detector">
- -->
- <!-- Link to log file that stores the z position -->
-<!-- <parameter name="z">
- <logfile id="multi_det_height" eq="0.001*value" extract-single-value-as="position 1" />
- </parameter>
-
- <properties>
- square pixels 2.2mm width in z-y direction
- </properties>
-
- <location x="12.403" />
- </component>
--->
- <type name="panel" is="rectangular_detector" type="multi-detector-pixel"
+ <type name="panel" is="rectangular_detector" type="multi-detector-pixel"
xpixels="40" xstart="-0.044" xstep="+0.0022"
ypixels="46" ystart="0.0" ystep="+0.0022" >
<properties/>
- </type>
-
+ </type>
+
<type name="multi-detector-pixel" is="detector">
<cuboid id="shape">
<left-front-bottom-point x="0.01" y="-0.0011" z="-0.0011" />
@@ -149,65 +127,43 @@
<right-front-bottom-point x="0.01" y="0.0011" z="-0.0011" />
</cuboid>
<algebra val="shape" />
- </type>
+ </type>
-
- <!-- source and sample-position components -->
- <component type="source">
- <location />
- </component>
-
- <type name="source" is="Source">
- <properties>
- 10mm(H) x 40mm(W)
- </properties>
- </type>
-
-
- <component type="some-surface-holder">
- <!-- worry about linking relevant logfiles for y,z,theta,phi up later -->
- <location z="8.869"/>
- </component>
+ <!-- other components -->
- <type name="some-surface-holder" is="SamplePos">
- </type>
-
-
- <!-- other components -->
-
<component type="slit" name="slit1">
- <location z="7.032"/>
+ <location z="-1.873"/>
<!-- This log file stores the vertical opening of slit -->
- <parameter name="vertical gap">
+ <parameter name="vertical gap">
<logfile id="S1" extract-single-value-as="last_value" />
</parameter>
</component>
-
- <component type="slit" name="slit2">
- <location z="8.532"/>
+
+ <component type="slit" name="slit2">
+ <location z="-0.254"/>
<!-- This log file stores the vertical opening of this. Note this
slit can also be translated in the z. However this info not stored
in log file since it is not used in the data analysis process. -->
- <parameter name="vertical gap">
+ <parameter name="vertical gap">
<logfile id="S2" extract-single-value-as="last_value" />
</parameter>
- </component>
-
- <component type="slit" name="slit3">
- <location z="9.174"/>
- <!-- This log file stores the vertical opening of slit -->
+ </component>
+
+ <component type="slit" name="slit3">
+ <location z="0.298"/>
+ <!-- This log file stores the vertical opening of slit -->
<parameter name="vertical gap">
<logfile id="S3" extract-single-value-as="last_value" />
</parameter>
- </component>
-
- <component type="slit" name="slit4">
- <location z="11.300"/>
+ </component>
+
+ <component type="slit" name="slit4">
+ <location z="2.431"/>
<!-- This log file stores the vertical opening of slit. Note this slit
is fixed to the point detector. -->
- <parameter name="vertical gap">
- <logfile id="S4" extract-single-value-as="last_value" />
+ <parameter name="vertical gap">
+ <logfile id="S4" extract-single-value-as="last_value" />
</parameter>
</component>
@@ -220,76 +176,30 @@
<right-front-bottom-point z="0.0005" x="0.025" y="-0.03" />
</cuboid>
</type>
-
-
-
-
+
+
+
<component type="supermirror">
<!-- Worry about linking relevant logfiles for z,theta up later -->
- <location z="7.7685"/>
- </component>
-
- <type name="supermirror" />
+ <location z="-1.103"/>
+ </component>
+ <type name="supermirror" />
-
<!-- DETECTOR and MONITOR ID LISTS -->
<idlist idname="monitor1">
- <id val="20001" />
+ <id val="20001" />
</idlist>
-
+
<idlist idname="monitor2">
- <id val="20002" />
+ <id val="20002" />
</idlist>
<idlist idname="point-detector">
- <id val="30001" />
+ <id val="30001" />
</idlist>
-<!--
- <idlist idname="multi-detector">
- <id start="10001" end="10046" />
- <id start="10065" end="10110" />
- <id start="10129" end="10174" />
- <id start="10193" end="10238" />
- <id start="10257" end="10302" />
- <id start="10321" end="10366" />
- <id start="10385" end="10430" />
- <id start="10449" end="10494" />
- <id start="10513" end="10558" />
- <id start="10577" end="10622" />
- <id start="10641" end="10686" />
- <id start="10705" end="10750" />
- <id start="10769" end="10814" />
- <id start="10833" end="10878" />
- <id start="10897" end="10942" />
- <id start="10961" end="11006" />
- <id start="11025" end="11070" />
- <id start="11089" end="11134" />
- <id start="11153" end="11198" />
- <id start="11217" end="11262" />
- <id start="11281" end="11326" />
- <id start="11345" end="11390" />
- <id start="11409" end="11454" />
- <id start="11473" end="11518" />
- <id start="11537" end="11582" />
- <id start="11601" end="11646" />
- <id start="11665" end="11710" />
- <id start="11729" end="11774" />
- <id start="11793" end="11838" />
- <id start="11857" end="11902" />
- <id start="11921" end="11966" />
- <id start="11985" end="12030" />
- <id start="12049" end="12094" />
- <id start="12113" end="12158" />
- <id start="12177" end="12222" />
- <id start="12241" end="12286" />
- <id start="12305" end="12350" />
- <id start="12369" end="12414" />
- <id start="12433" end="12478" />
- <id start="12497" end="12542" />
- </idlist>
- -->
+
</instrument>
diff --git a/instrument/SURF_Definition_2017.xml b/instrument/SURF_Definition_2017.xml
new file mode 100644
index 0000000000000000000000000000000000000000..4bec930ff53ae4cae65ca1babce15215822cf361
--- /dev/null
+++ b/instrument/SURF_Definition_2017.xml
@@ -0,0 +1,205 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- For help on the notation used to specify an Instrument Definition File
+ see http://www.mantidproject.org/IDF -->
+<instrument xmlns="http://www.mantidproject.org/IDF/1.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd"
+ name="SURF"
+ valid-from="2017-02-14 00:00:00"
+ valid-to="2100-01-30 23:59:59"
+ last-modified="2018-03-15 00:00:00">
+
+ <defaults>
+ <length unit="meter" />
+ <angle unit="degree" />
+ <reference-frame>
+ <along-beam axis="z" />
+ <pointing-up axis="y" />
+ <handedness val="right" />
+ </reference-frame>
+ <default-view axis-view="z+"/>
+ </defaults>
+
+<!-- source and sample-position components START============================= -->
+
+ <component type="source">
+ <location z="-8.869" />
+ </component>
+ <type name="source" is="Source">
+ <properties>
+ 40mm(H) x 60mm(W)
+ </properties>
+ </type>
+
+ <component type="some-surface-holder">
+ <location x="0.0" y="0.0" z="0.0"/>
+ </component>
+ <type name="some-surface-holder" is="SamplePos"/>
+
+<!-- source and sample-position components END=============================== -->
+
+
+<!-- LIST OF PHYSICAL COMPONENTS (which the instrument consists of) -->
+<!-- detector components (including monitors) -->
+
+<!-- ================MONITOR 1 START========================================= -->
+ <component type="monitor1" idlist="monitor1">
+ <location z="-1.663"/>
+ </component>
+
+ <type name="monitor1" is="monitor">
+ <!-- Shape specified at least big enough to cover the beam which
+ is 10mm high and 40mm wide. Note it is described as tube, hence
+ the choice of a cylinder shape.
+ -->
+ <percent-transparency val="95" />
+ <cylinder id="shape">
+ <centre-of-bottom-base x="-0.02" y="0.0" z="0.0" />
+ <axis x="1.0" y="0.0" z="0.0" />
+ <radius val="0.01" />
+ <height val="0.04" />
+ </cylinder>
+ <algebra val="shape" />
+ </type>
+<!-- ================MONITOR 1 END=========================================== -->
+
+<!-- ================MONITOR 2 START========================================= -->
+ <component type="monitor2" idlist="monitor2">
+ <location z="-0.149" />
+ </component>
+
+ <type name="monitor2" is="monitor">
+ <!-- Original shape included a Sphere attached to the cuboid
+ but that was cosmetic only as it is not in the beam,
+ and was causing problems with opencascade on windows 8.
+ Therefore it has been removed. -->
+ <percent-transparency val="95" />
+ <cuboid id="base">
+ <left-front-bottom-point x="0.02" y="-0.005" z="0.0" />
+ <left-front-top-point x="0.02" y="0.005" z="0.0" />
+ <left-back-bottom-point x="0.02" y="-0.005" z="-0.01" />
+ <right-front-bottom-point x="-0.02" y="-0.005" z="0.0" />
+ </cuboid>
+ </type>
+<!-- ================MONITOR 2 END=========================================== -->
+
+<!-- ================POINT DETECTOR START==================================== -->
+ <component type="point-detector" idlist="point-detector">
+ <location z="2.561" />
+ <parameter name="y">
+ <logfile id="THETA" eq="2.561*sin(2*value*0.0174533)" extract-single-value-as="last_value"/>
+ </parameter>
+
+ </component>
+
+ <type name="point-detector" is="detector">
+ <!-- Not exactly sure about the dimensions of this one. But pretty sure
+ it at least covers the beam. Also, just in front of it is a slit which
+ at the end of day will determine which neutrons get through to this
+ detector I believe.
+ -->
+ <cuboid id="shape">
+ <left-front-bottom-point x="0.02" y="-0.005" z="0.0" />
+ <left-front-top-point x="0.02" y="0.005" z="0.0" />
+ <left-back-bottom-point x="0.02" y="-0.005" z="-0.01" />
+ <right-front-bottom-point x="-0.02" y="-0.005" z="0.0" />
+ </cuboid>
+ <algebra val="shape" />
+ </type>
+<!-- ================POINT DETECTOR END====================================== -->
+
+<!-- ================AREA DETECTOR START=================================== -->
+ <component type="panel" idstart="10001" idfillbyfirst="y" idstep="1" idstepbyrow="64">
+ <location z="3.061" name="multi-detector"/>
+ </component>
+
+ <type name="panel" is="rectangular_detector" type="multi-detector-pixel"
+ xpixels="40" xstart="-0.044" xstep="+0.0022"
+ ypixels="46" ystart="0.0" ystep="+0.0022" >
+ <properties/>
+ </type>
+
+ <type name="multi-detector-pixel" is="detector">
+ <cuboid id="shape">
+ <left-front-bottom-point x="0.01" y="-0.0011" z="-0.0011" />
+ <left-front-top-point x="0.01" y="-0.0011" z="0.0011" />
+ <left-back-bottom-point x="-0.01" y="-0.0011" z="-0.0011" />
+ <right-front-bottom-point x="0.01" y="0.0011" z="-0.0011" />
+ </cuboid>
+ <algebra val="shape" />
+ </type>
+
+
+ <!-- other components -->
+
+ <component type="slit" name="slit1">
+ <location z="-1.873"/>
+ <!-- This log file stores the vertical opening of slit -->
+ <parameter name="vertical gap">
+ <logfile id="S1VG" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <component type="slit" name="slit2">
+ <location z="-0.254"/>
+ <!-- This log file stores the vertical opening of this. Note this
+ slit can also be translated in the z. However this info not stored
+ in log file since it is not used in the data analysis process. -->
+ <parameter name="vertical gap">
+ <logfile id="S2VG" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <component type="slit" name="slit3">
+ <location z="0.298"/>
+ <!-- This log file stores the vertical opening of slit -->
+ <parameter name="vertical gap">
+ <logfile id="S3VG" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <component type="slit" name="slit4">
+ <location z="2.431"/>
+ <!-- This log file stores the vertical opening of slit. Note this slit
+ is fixed to the point detector. -->
+ <parameter name="vertical gap">
+ <logfile id="S4VG" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <type name="slit">
+ <percent-transparency val="50" />
+ <cuboid id="bottom">
+ <left-front-bottom-point z="0.0005" x="-0.025" y="-0.03" />
+ <left-front-top-point z="0.0005" x="-0.025" y="0.0" />
+ <left-back-bottom-point z="-0.0005" x="-0.025" y="-0.03" />
+ <right-front-bottom-point z="0.0005" x="0.025" y="-0.03" />
+ </cuboid>
+ </type>
+
+
+
+
+ <component type="supermirror">
+ <!-- Worry about linking relevant logfiles for z,theta up later -->
+ <location z="-1.103"/>
+ </component>
+
+ <type name="supermirror" />
+
+
+ <!-- DETECTOR and MONITOR ID LISTS -->
+
+ <idlist idname="monitor1">
+ <id val="20001" />
+ </idlist>
+
+ <idlist idname="monitor2">
+ <id val="20002" />
+ </idlist>
+
+ <idlist idname="point-detector">
+ <id val="30001" />
+ </idlist>
+
+</instrument>
diff --git a/scripts/Reflectometry/isis_reflectometry/l2q.py b/scripts/Reflectometry/isis_reflectometry/l2q.py
index b192b4ef490ef2907ce414746d4e6e5245884126..79aba311d21bcd29a93cdcc6339062287f1310ed 100644
--- a/scripts/Reflectometry/isis_reflectometry/l2q.py
+++ b/scripts/Reflectometry/isis_reflectometry/l2q.py
@@ -1,11 +1,11 @@
-#pylint: disable=invalid-name
+# pylint: disable=invalid-name
from __future__ import (absolute_import, division, print_function)
import math
from mantid.simpleapi import * # New API
-def l2q(ws,whichDet,theta, sample_component_name):
+def l2q(ws, whichDet, theta, sample_component_name):
'''
call signature::call signature::
@@ -33,30 +33,41 @@ def l2q(ws,whichDet,theta, sample_component_name):
else:
inst = ws.getInstrument()
- sampleLocation=inst.getComponentByName(sample_component_name).getPos()
- detLocation=inst.getComponentByName(whichDet).getPos()
- sample2detector=detLocation-sampleLocation # meters
+ sampleLocation = inst.getComponentByName(sample_component_name).getPos()
+ detLocation = inst.getComponentByName(whichDet).getPos()
+ sample2detector = detLocation - sampleLocation # meters
- theta=theta*math.pi/180.0 # convert to radians
+ theta = theta * math.pi / 180.0 # convert to radians
# Fetch the reference frame to determine the instrument orientation.
reference_frame = inst.getReferenceFrame()
- sample_to_detector_along_beam = sample2detector.scalar_prod( reference_frame.vecPointingAlongBeam() )
+ sample_to_detector_along_beam = sample2detector.scalar_prod(
+ reference_frame.vecPointingAlongBeam())
# calculate new detector position based on angle theta in degrees:
- across_offset = 0.0 # Across the beam (side to side)
- up_offset = sample_to_detector_along_beam * math.sin(2.0 * theta) # Normal to the beam (up)
- beam_offset = detLocation.scalar_prod( reference_frame.vecPointingAlongBeam() )
+ # Across the beam (side to side)
+ across_offset = 0.0
+ up_offset = sample_to_detector_along_beam * \
+ math.sin(2.0 * theta) # Normal to the beam (up)
+ beam_offset = detLocation.scalar_prod(
+ reference_frame.vecPointingAlongBeam())
coord_args = dict()
- coord_args[ reference_frame.pointingAlongBeamAxis() ] = beam_offset
- coord_args[ reference_frame.pointingUpAxis() ] = up_offset
- coord_args[ reference_frame.pointingHorizontalAxis() ] = across_offset
+ coord_args[reference_frame.pointingAlongBeamAxis()] = beam_offset
+ coord_args[reference_frame.pointingUpAxis()] = up_offset
+ coord_args[reference_frame.pointingHorizontalAxis()] = across_offset
logger.information('Correcting detector location')
- MoveInstrumentComponent(ws, ComponentName=whichDet, RelativePosition=False, **coord_args )
+ MoveInstrumentComponent(
+ ws,
+ ComponentName=whichDet,
+ RelativePosition=False,
+ **coord_args)
# Now convert to momentum transfer
- IvsQ = ConvertUnits(InputWorkspace=ws,OutputWorkspace="IvsQ",Target="MomentumTransfer")
+ IvsQ = ConvertUnits(
+ InputWorkspace=ws,
+ OutputWorkspace="IvsQ",
+ Target="MomentumTransfer")
return IvsQ