diff --git a/Framework/Algorithms/CMakeLists.txt b/Framework/Algorithms/CMakeLists.txt
index 72d78ebd76b570975988b1b3a58dd0d0ec27b180..ed23aa701ce443bd437889f4df387b787a13dc6b 100644
--- a/Framework/Algorithms/CMakeLists.txt
+++ b/Framework/Algorithms/CMakeLists.txt
@@ -839,6 +839,7 @@ set ( TEST_FILES
HyspecScharpfCorrectionTest.h
IQTransformTest.h
IdentifyNoisyDetectorsTest.h
+ IndirectFitDataCreationHelperTest.h
IntegrateByComponentTest.h
IntegrateEPPTest.h
IntegrationTest.h
diff --git a/Framework/Algorithms/inc/MantidAlgorithms/EditInstrumentGeometry.h b/Framework/Algorithms/inc/MantidAlgorithms/EditInstrumentGeometry.h
index 2b69c8957b0db8e2581f27bbc16ecf893af07828..a177781a49dc75c075b5fb26165721423eb2862b 100644
--- a/Framework/Algorithms/inc/MantidAlgorithms/EditInstrumentGeometry.h
+++ b/Framework/Algorithms/inc/MantidAlgorithms/EditInstrumentGeometry.h
@@ -23,8 +23,8 @@ public:
const std::string name() const override;
/// Summary of algorithms purpose
const std::string summary() const override {
- return "The edit or added information will be attached to a Workspace. "
- "Currently it is in an overwrite mode only.";
+ return "Adds a new instrument or edits an existing one; "
+ "currently works in an overwrite mode only.";
}
/// Algorithm's category for identification overriding a virtual method
diff --git a/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOne2.h b/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOne2.h
index 1a4ce39b2a3b295c9a5a8ad349ff37dde60504b1..12959e262a19559a1ea5ddf070996d9f4b4ddac6 100644
--- a/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOne2.h
+++ b/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOne2.h
@@ -130,8 +130,7 @@ private:
const bool outerCorners = true);
// Check whether two spectrum maps match
void verifySpectrumMaps(API::MatrixWorkspace_const_sptr ws1,
- API::MatrixWorkspace_const_sptr ws2,
- const bool severe);
+ API::MatrixWorkspace_const_sptr ws2);
// Find and cache constants
void findDetectorGroups();
diff --git a/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOneAuto2.h b/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOneAuto2.h
index b56d7612a58da101c17d364a8e4a48cdb45b1c5c..7b59d63b16054bfb3592c4d3021341e0249d4fba 100644
--- a/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOneAuto2.h
+++ b/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryReductionOneAuto2.h
@@ -41,16 +41,13 @@ private:
void setDefaultOutputWorkspaceNames();
/// Get the name of the detectors of interest based on processing instructions
std::vector<std::string>
- getDetectorNames(const std::string &instructions,
- Mantid::API::MatrixWorkspace_sptr inputWS);
+ getDetectorNames(Mantid::API::MatrixWorkspace_sptr inputWS);
/// Correct detector positions vertically
Mantid::API::MatrixWorkspace_sptr
- correctDetectorPositions(const std::string &instructions,
- Mantid::API::MatrixWorkspace_sptr inputWS,
+ correctDetectorPositions(Mantid::API::MatrixWorkspace_sptr inputWS,
const double twoTheta);
/// Calculate theta
- double calculateTheta(const std::string &instructions,
- Mantid::API::MatrixWorkspace_sptr inputWS);
+ double calculateTheta(Mantid::API::MatrixWorkspace_sptr inputWS);
/// Rebin and scale a workspace in Q
Mantid::API::MatrixWorkspace_sptr
rebinAndScale(Mantid::API::MatrixWorkspace_sptr inputWS, double theta,
diff --git a/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryWorkflowBase2.h b/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryWorkflowBase2.h
index b387a69f80e57d5ee78964be9b2e7b18c9244ffa..db477696fabddb1ee0c6027bb9537aee657517c1 100644
--- a/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryWorkflowBase2.h
+++ b/Framework/Algorithms/inc/MantidAlgorithms/ReflectometryWorkflowBase2.h
@@ -11,6 +11,9 @@
#include "MantidAPI/MatrixWorkspace_fwd.h"
#include "MantidGeometry/Instrument_fwd.h"
+using namespace Mantid::API;
+using namespace Mantid::Kernel;
+using namespace Mantid::Geometry;
namespace Mantid {
namespace Algorithms {
@@ -69,10 +72,9 @@ protected:
populateMonitorProperties(Mantid::API::IAlgorithm_sptr alg,
Mantid::Geometry::Instrument_const_sptr instrument);
/// Populate processing instructions
- std::string populateProcessingInstructions(
- Mantid::API::IAlgorithm_sptr alg,
- Mantid::Geometry::Instrument_const_sptr instrument,
- Mantid::API::MatrixWorkspace_sptr inputWS) const;
+ std::string
+ findProcessingInstructions(Mantid::Geometry::Instrument_const_sptr instrument,
+ Mantid::API::MatrixWorkspace_sptr inputWS) const;
/// Populate transmission properties
bool populateTransmissionProperties(Mantid::API::IAlgorithm_sptr alg) const;
/// Find theta from a named log value
@@ -80,6 +82,28 @@ protected:
const std::string &logName);
// Retrieve the run number from the logs of the input workspace.
std::string getRunNumber(Mantid::API::MatrixWorkspace const &ws) const;
+
+ void convertProcessingInstructions(Instrument_const_sptr instrument,
+ MatrixWorkspace_sptr inputWS);
+ void convertProcessingInstructions(MatrixWorkspace_sptr inputWS);
+ std::string m_processingInstructionsWorkspaceIndex;
+ std::string m_processingInstructions;
+
+protected:
+ std::string
+ convertToSpectrumNumber(const std::string &workspaceIndex,
+ Mantid::API::MatrixWorkspace_const_sptr ws) const;
+
+ std::string convertProcessingInstructionsToWorkspaceIndices(
+ const std::string &instructions,
+ Mantid::API::MatrixWorkspace_const_sptr ws) const;
+
+ std::string convertToWorkspaceIndex(const std::string &spectrumNumber,
+ MatrixWorkspace_const_sptr ws) const;
+
+ std::string convertProcessingInstructionsToSpectrumNumbers(
+ const std::string &instructions,
+ Mantid::API::MatrixWorkspace_const_sptr ws) const;
};
} // namespace Algorithms
} // namespace Mantid
diff --git a/Framework/Algorithms/inc/MantidAlgorithms/SpecularReflectionPositionCorrect2.h b/Framework/Algorithms/inc/MantidAlgorithms/SpecularReflectionPositionCorrect2.h
index e2e1c34902c9b28efc390a8f0c9a3fe8ee179cbf..865d22051185e7fbbe2cec54ff9a06ae68cb6e8a 100644
--- a/Framework/Algorithms/inc/MantidAlgorithms/SpecularReflectionPositionCorrect2.h
+++ b/Framework/Algorithms/inc/MantidAlgorithms/SpecularReflectionPositionCorrect2.h
@@ -9,13 +9,23 @@
#include "MantidAPI/Algorithm.h"
+#include "MantidGeometry/IDTypes.h"
+
namespace Mantid {
+namespace Geometry {
+class Instrument;
+class ReferenceFrame;
+} // namespace Geometry
+namespace Kernel {
+class V3D;
+}
namespace Algorithms {
-/** SpecularReflectionPositionCorrect : Algorithm to perform vertical position
+/** SpecularReflectionPositionCorrect : Algorithm to perform position
corrections based on the specular reflection condition. Version 2.
*/
-class DLLExport SpecularReflectionPositionCorrect2 : public API::Algorithm {
+class DLLExport SpecularReflectionPositionCorrect2 final
+ : public API::Algorithm {
public:
/// Name of this algorithm
const std::string name() const override;
@@ -24,14 +34,35 @@ public:
/// Version
int version() const override;
const std::vector<std::string> seeAlso() const override {
- return {"SpecularReflectionCalculateTheta"};
+ return {"SpecularReflectionCalculateTheta, FindReflectometryLines"};
}
/// Category
const std::string category() const override;
private:
void init() override;
+ std::map<std::string, std::string> validateInputs() override;
void exec() override;
+ void correctDetectorPosition(API::MatrixWorkspace_sptr &outWS,
+ const std::string &detectorName,
+ const detid_t detectorID,
+ const double twoThetaInRad,
+ const std::string &correctionType,
+ const Geometry::ReferenceFrame &referenceFrame,
+ const Kernel::V3D &samplePosition,
+ const Kernel::V3D &sampleToDetector,
+ const double beamOffsetOld);
+ static Kernel::V3D declareDetectorPosition(const Geometry::Instrument &inst,
+ const std::string &detectorName,
+ const detid_t detectorID);
+ Kernel::V3D declareSamplePosition(const API::MatrixWorkspace &ws);
+ double twoThetaFromProperties(const API::MatrixWorkspace &inWS,
+ const double l2);
+ double twoThetaFromDirectLine(const std::string &detectorName,
+ const detid_t detectorID,
+ const Kernel::V3D &samplePosition,
+ const double l2, const Kernel::V3D &alongDir,
+ const double beamOffset);
};
} // namespace Algorithms
diff --git a/Framework/Algorithms/src/CreateTransmissionWorkspace2.cpp b/Framework/Algorithms/src/CreateTransmissionWorkspace2.cpp
index 20ee1aeb340ab4a13cc6a2aef10b6015ae315e7a..4195607677d2657749daca59e7139003a7c9f886 100644
--- a/Framework/Algorithms/src/CreateTransmissionWorkspace2.cpp
+++ b/Framework/Algorithms/src/CreateTransmissionWorkspace2.cpp
@@ -11,8 +11,9 @@
#include "MantidAPI/WorkspaceUnitValidator.h"
#include "MantidKernel/MandatoryValidator.h"
-using namespace Mantid::Kernel;
using namespace Mantid::API;
+using namespace Mantid::Kernel;
+using namespace Mantid::Geometry;
namespace Mantid {
namespace Algorithms {
@@ -69,7 +70,7 @@ void CreateTransmissionWorkspace2::init() {
"ProcessingInstructions", "",
boost::make_shared<MandatoryValidator<std::string>>(),
Direction::Input),
- "Grouping pattern on workspace indexes to yield only "
+ "Grouping pattern on spectrum numbers to yield only "
"the detectors of interest. See GroupDetectors for details.");
declareProperty(make_unique<PropertyWithValue<double>>(
@@ -123,6 +124,8 @@ void CreateTransmissionWorkspace2::exec() {
MatrixWorkspace_sptr outWS;
MatrixWorkspace_sptr firstTransWS = getProperty("FirstTransmissionRun");
+ convertProcessingInstructions(firstTransWS);
+
firstTransWS = normalizeDetectorsByMonitors(firstTransWS);
firstTransWS = cropWavelength(firstTransWS);
@@ -130,6 +133,8 @@ void CreateTransmissionWorkspace2::exec() {
if (secondTransWS) {
storeTransitionRun(1, firstTransWS);
+ convertProcessingInstructions(secondTransWS);
+
secondTransWS = normalizeDetectorsByMonitors(secondTransWS);
secondTransWS = cropWavelength(secondTransWS);
storeTransitionRun(2, secondTransWS);
diff --git a/Framework/Algorithms/src/CreateTransmissionWorkspaceAuto2.cpp b/Framework/Algorithms/src/CreateTransmissionWorkspaceAuto2.cpp
index 2fe876914bf5d857b22402ecd2d87f8674c3df96..c5260582705f37b05899859998a2fac208fdcd8e 100644
--- a/Framework/Algorithms/src/CreateTransmissionWorkspaceAuto2.cpp
+++ b/Framework/Algorithms/src/CreateTransmissionWorkspaceAuto2.cpp
@@ -7,6 +7,7 @@
#include "MantidAlgorithms/CreateTransmissionWorkspaceAuto2.h"
#include "MantidAPI/WorkspaceUnitValidator.h"
#include "MantidAlgorithms/BoostOptionalToAlgorithmProperty.h"
+#include "MantidAlgorithms/ReflectometryWorkflowBase2.h"
#include "MantidKernel/ListValidator.h"
using namespace Mantid::Kernel;
@@ -53,7 +54,7 @@ void CreateTransmissionWorkspaceAuto2::init() {
// Processing instructions
declareProperty(make_unique<PropertyWithValue<std::string>>(
"ProcessingInstructions", "", Direction::Input),
- "Grouping pattern of workspace indices to yield only the"
+ "Grouping pattern of spectrum numbers to yield only the"
" detectors of interest. See GroupDetectors for syntax.");
// Wavelength range
@@ -102,7 +103,8 @@ void CreateTransmissionWorkspaceAuto2::exec() {
populateMonitorProperties(alg, instrument);
// Processing instructions
- populateProcessingInstructions(alg, instrument, firstWS);
+ convertProcessingInstructions(instrument, firstWS);
+ alg->setProperty("ProcessingInstructions", m_processingInstructions);
alg->execute();
MatrixWorkspace_sptr outWS = alg->getProperty("OutputWorkspace");
diff --git a/Framework/Algorithms/src/ReflectometryReductionOne2.cpp b/Framework/Algorithms/src/ReflectometryReductionOne2.cpp
index f95ec2d82e557c105707e46dc139314b22698c1f..318b04456088057f29202af9a2ab134b70792e93 100644
--- a/Framework/Algorithms/src/ReflectometryReductionOne2.cpp
+++ b/Framework/Algorithms/src/ReflectometryReductionOne2.cpp
@@ -86,131 +86,6 @@ double getLambda(const HistogramX &xValues, const int xIdx) {
return xValues[xIdx] + getLambdaRange(xValues, xIdx) / 2.0;
}
-/**
- * Map a spectrum index from the given map to the given workspace
- * @param originWS : the original workspace
- * @param mapIdx : the index in the original workspace
- * @param destWS : the destination workspace
- * @return : the index in the destination workspace
- */
-size_t mapSpectrumIndexToWorkspace(MatrixWorkspace_const_sptr originWS,
- const size_t originIdx,
- MatrixWorkspace_const_sptr destWS) {
-
- SpectrumNumber specId = originWS->indexInfo().spectrumNumber(originIdx);
- size_t wsIdx =
- destWS->getIndexFromSpectrumNumber(static_cast<specnum_t>(specId));
- return wsIdx;
-}
-
-/**
- * @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
- * @throws :: If the specId are not found to exist on the host end-point
- *workspace.
- * @return :: Remapped workspace indexes applicable for the host workspace,
- *as a vector of groups of vectors of spectrum indices
- */
-std::vector<std::vector<size_t>> mapSpectrumIndicesToWorkspace(
- MatrixWorkspace_const_sptr originWS, MatrixWorkspace_const_sptr hostWS,
- const std::vector<std::vector<size_t>> &detectorGroups) {
-
- std::vector<std::vector<size_t>> hostGroups;
-
- for (auto group : detectorGroups) {
- std::vector<size_t> hostDetectors;
- for (auto i : group) {
- const size_t hostIdx = mapSpectrumIndexToWorkspace(originWS, i, hostWS);
- hostDetectors.push_back(hostIdx);
- }
- hostGroups.push_back(hostDetectors);
- }
-
- return hostGroups;
-}
-
-/**
- * Translate 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.
- *
- * @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
- * @throws :: If the specId are not found to exist on the host end-point
- *workspace.
- * @return :: Remapped workspace indexes applicable for the host workspace,
- *as comma separated string.
- */
-std::string createProcessingCommandsFromDetectorWS(
- MatrixWorkspace_const_sptr originWS, MatrixWorkspace_const_sptr hostWS,
- const std::vector<std::vector<size_t>> &detectorGroups) {
-
- std::string result;
-
- // Map the original indices to the host workspace
- std::vector<std::vector<size_t>> hostGroups =
- mapSpectrumIndicesToWorkspace(originWS, hostWS, detectorGroups);
-
- // Add each group to the output, separated by ','
-
- /// @todo Low priority: Add support to separate contiguous groups by ':' to
- /// avoid having long lists of spectrum indices in the processing
- /// instructions. This would not make any functional difference but would be
- /// a cosmetic improvement when you view the history.
- for (auto groupIt = hostGroups.begin(); groupIt != hostGroups.end();
- ++groupIt) {
- const auto &hostDetectors = *groupIt;
-
- // Add each detector index to the output string separated by '+' to indicate
- // that all detectors in this group will be summed. We also check for
- // contiguous ranges so we output e.g. 3-5 instead of 3+4+5
- bool contiguous = false;
- size_t contiguousStart = 0;
-
- for (auto it = hostDetectors.begin(); it != hostDetectors.end(); ++it) {
- // Check if the next iterator is a contiguous increment from this one
- auto nextIt = it + 1;
- if (nextIt != hostDetectors.end() && *nextIt == *it + 1) {
- // If this is a start of a new contiguous region, remember the start
- // index
- if (!contiguous) {
- contiguousStart = *it;
- contiguous = true;
- }
- // Continue to find the end of the contiguous region
- continue;
- }
-
- if (contiguous) {
- // Output the contiguous range, then reset the flag
- result.append(std::to_string(contiguousStart))
- .append("-")
- .append(std::to_string(*it));
- contiguousStart = 0;
- contiguous = false;
- } else {
- // Just output the value
- result.append(std::to_string(*it));
- }
-
- // Add a separator ready for the next value/range
- if (nextIt != hostDetectors.end()) {
- result.append("+");
- }
- }
-
- if (groupIt + 1 != hostGroups.end()) {
- result.append(",");
- }
- }
-
- return result;
-}
-
/**
* Get the topbottom extent of a detector for the given axis
*
@@ -265,7 +140,7 @@ void ReflectometryReductionOne2::init() {
"ProcessingInstructions", "",
boost::make_shared<MandatoryValidator<std::string>>(),
Direction::Input),
- "Grouping pattern on workspace indexes to yield only "
+ "Grouping pattern on spectrum numbers to yield only "
"the detectors of interest. See GroupDetectors for details.");
// Minimum wavelength
@@ -351,6 +226,10 @@ void ReflectometryReductionOne2::exec() {
m_runWS = getProperty("InputWorkspace");
const auto xUnitID = m_runWS->getAxis(0)->unit()->unitID();
+ // Handle processing instructions conversion from spectra number to workspace
+ // indexes
+ convertProcessingInstructions(m_runWS);
+
// Neither TOF or Lambda? Abort.
if ((xUnitID != "Wavelength") && (xUnitID != "TOF"))
throw std::invalid_argument(
@@ -617,7 +496,6 @@ MatrixWorkspace_sptr ReflectometryReductionOne2::transOrAlgCorrection(
MatrixWorkspace_sptr ReflectometryReductionOne2::transmissionCorrection(
MatrixWorkspace_sptr detectorWS, const bool detectorWSReduced) {
- const bool strictSpectrumChecking = getProperty("StrictSpectrumChecking");
MatrixWorkspace_sptr transmissionWS = getProperty("FirstTransmissionRun");
// Reduce the transmission workspace, if not already done (assume that if
@@ -625,20 +503,15 @@ MatrixWorkspace_sptr ReflectometryReductionOne2::transmissionCorrection(
Unit_const_sptr xUnit = transmissionWS->getAxis(0)->unit();
if (xUnit->unitID() == "TOF") {
- // Processing instructions for transmission workspace. If strict spectrum
- // checking is not enabled then just use the same processing instructions
- // that were passed in.
- std::string transmissionCommands = getProperty("ProcessingInstructions");
- if (strictSpectrumChecking) {
- // If we have strict spectrum checking, we should have the same
- // spectrum numbers in both workspaces, but not necessarily with the
- // same workspace indices. Therefore, map the processing instructions
- // from the original workspace to the correct indices in the
- // transmission workspace. Note that we use the run workspace here
- // because the detectorWS may already have been reduced and may not
- // contain the original spectra.
- transmissionCommands = createProcessingCommandsFromDetectorWS(
- m_runWS, transmissionWS, detectorGroups());
+ // If TransmissionProcessingInstructions are not passed then use
+ // passed processing instrucions
+ std::string transmissionCommands = "";
+ if (getPointerToProperty("TransmissionProcessingInstructions")
+ ->isDefault()) {
+ transmissionCommands = m_processingInstructions;
+ } else {
+ transmissionCommands =
+ getPropertyValue("TransmissionProcessingInstructions");
}
MatrixWorkspace_sptr secondTransmissionWS =
@@ -678,7 +551,7 @@ MatrixWorkspace_sptr ReflectometryReductionOne2::transmissionCorrection(
// If the detector workspace has been reduced then the spectrum maps
// should match AFTER reducing the transmission workspace
if (detectorWSReduced) {
- verifySpectrumMaps(detectorWS, transmissionWS, strictSpectrumChecking);
+ verifySpectrumMaps(detectorWS, transmissionWS);
}
MatrixWorkspace_sptr normalized = divide(detectorWS, transmissionWS);
@@ -779,7 +652,7 @@ bool ReflectometryReductionOne2::summingInQ() {
* Find and cache the indicies of the detectors of interest
*/
void ReflectometryReductionOne2::findDetectorGroups() {
- std::string instructions = getPropertyValue("ProcessingInstructions");
+ std::string instructions = m_processingInstructionsWorkspaceIndex;
m_detectorGroups = Kernel::Strings::parseGroups<size_t>(instructions);
@@ -795,16 +668,17 @@ void ReflectometryReductionOne2::findDetectorGroups() {
}
for (const auto &group : m_detectorGroups) {
- for (const auto &spIdx : group) {
- if (m_spectrumInfo->isMonitor(spIdx)) {
- throw std::invalid_argument("A detector is expected at spectrum " +
- std::to_string(spIdx) +
- ", found a monitor");
+ for (const auto &wsIdx : group) {
+ if (m_spectrumInfo->isMonitor(wsIdx)) {
+ throw std::invalid_argument(
+ "A detector is expected at workspace index " +
+ std::to_string(wsIdx) +
+ " (Was converted from specnum), found a monitor");
}
- if (spIdx > m_spectrumInfo->size() - 1) {
+ if (wsIdx > m_spectrumInfo->size() - 1) {
throw std::runtime_error(
"ProcessingInstructions contains an out-of-range index: " +
- std::to_string(spIdx));
+ std::to_string(wsIdx));
}
}
}
@@ -1312,12 +1186,10 @@ Check whether the spectra for the given workspaces are the same.
@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 ReflectometryReductionOne2::verifySpectrumMaps(
- MatrixWorkspace_const_sptr ws1, MatrixWorkspace_const_sptr ws2,
- const bool severe) {
+ MatrixWorkspace_const_sptr ws1, MatrixWorkspace_const_sptr ws2) {
bool mismatch = false;
// Check that the number of histograms is the same
@@ -1338,13 +1210,8 @@ void ReflectometryReductionOne2::verifySpectrumMaps(
if (mismatch) {
const std::string message =
"Spectrum maps between workspaces do NOT match up.";
- if (severe) {
- throw std::invalid_argument(message);
- } else {
- g_log.warning(message);
- }
+ g_log.warning(message);
}
}
-
} // namespace Algorithms
} // namespace Mantid
diff --git a/Framework/Algorithms/src/ReflectometryReductionOneAuto2.cpp b/Framework/Algorithms/src/ReflectometryReductionOneAuto2.cpp
index ca20b555ba60323d0953229e82ace2fb7a60647a..9a0ad2ed831489bab315be4ea9c99b7c5b673972 100644
--- a/Framework/Algorithms/src/ReflectometryReductionOneAuto2.cpp
+++ b/Framework/Algorithms/src/ReflectometryReductionOneAuto2.cpp
@@ -217,7 +217,7 @@ void ReflectometryReductionOneAuto2::init() {
// Processing instructions
declareProperty(make_unique<PropertyWithValue<std::string>>(
"ProcessingInstructions", "", Direction::Input),
- "Grouping pattern of workspace indices to yield only the"
+ "Grouping pattern of spectrum numbers to yield only the"
" detectors of interest. See GroupDetectors for syntax.");
// Theta
@@ -365,12 +365,11 @@ void ReflectometryReductionOneAuto2::exec() {
this, "WavelengthMax", instrument, "LambdaMax");
alg->setProperty("WavelengthMax", wavMax);
- const auto instructions =
- populateProcessingInstructions(alg, instrument, inputWS);
-
- // Now that we know the detectors of interest, we can move them if necessary
- // (i.e. if theta is given). If not, we calculate theta from the current
- // detector positions
+ convertProcessingInstructions(instrument, inputWS);
+ alg->setProperty("ProcessingInstructions", m_processingInstructions);
+ // Now that we know the detectors of interest, we can move them if
+ // necessary (i.e. if theta is given). If not, we calculate theta from the
+ // current detector positions
bool correctDetectors = getProperty("CorrectDetectors");
double theta;
if (!getPointerToProperty("ThetaIn")->isDefault()) {
@@ -379,7 +378,7 @@ void ReflectometryReductionOneAuto2::exec() {
theta = getThetaFromLogs(inputWS, getPropertyValue("ThetaLogName"));
} else {
// Calculate theta from detector positions
- theta = calculateTheta(instructions, inputWS);
+ theta = calculateTheta(inputWS);
// Never correct detector positions if ThetaIn or ThetaLogName is not
// specified
correctDetectors = false;
@@ -389,19 +388,18 @@ void ReflectometryReductionOneAuto2::exec() {
alg->setProperty("ThetaIn", theta);
if (correctDetectors) {
- inputWS = correctDetectorPositions(instructions, inputWS, 2 * theta);
+ inputWS = correctDetectorPositions(inputWS, 2 * theta);
}
// Optional properties
+ alg->setPropertyValue("TransmissionProcessingInstructions",
+ getPropertyValue("TransmissionProcessingInstructions"));
populateMonitorProperties(alg, instrument);
alg->setPropertyValue("NormalizeByIntegratedMonitors",
getPropertyValue("NormalizeByIntegratedMonitors"));
bool transRunsFound = populateTransmissionProperties(alg);
- if (transRunsFound)
- alg->setProperty("StrictSpectrumChecking",
- getPropertyValue("StrictSpectrumChecking"));
- else
+ if (!transRunsFound)
populateAlgorithmicCorrectionProperties(alg, instrument);
alg->setProperty("InputWorkspace", inputWS);
@@ -437,15 +435,15 @@ void ReflectometryReductionOneAuto2::exec() {
* last spectrum indices in the processing instructions. It is assumed that all
* the interim detectors have the same parent.
*
- * @param instructions :: processing instructions defining detectors of interest
* @param inputWS :: the input workspace
* @return :: the names of the detectors of interest
*/
-std::vector<std::string> ReflectometryReductionOneAuto2::getDetectorNames(
- const std::string &instructions, MatrixWorkspace_sptr inputWS) {
+std::vector<std::string>
+ReflectometryReductionOneAuto2::getDetectorNames(MatrixWorkspace_sptr inputWS) {
std::vector<std::string> wsIndices;
- boost::split(wsIndices, instructions, boost::is_any_of(":,-+"));
+ boost::split(wsIndices, m_processingInstructionsWorkspaceIndex,
+ boost::is_any_of(":,-+"));
// vector of comopnents
std::vector<std::string> detectors;
@@ -466,7 +464,7 @@ std::vector<std::string> ReflectometryReductionOneAuto2::getDetectorNames(
}
} catch (boost::bad_lexical_cast &) {
throw std::runtime_error("Invalid processing instructions: " +
- instructions);
+ m_processingInstructionsWorkspaceIndex);
}
return detectors;
@@ -475,17 +473,14 @@ std::vector<std::string> ReflectometryReductionOneAuto2::getDetectorNames(
/** Correct an instrument component by shifting it vertically or
* rotating it around the sample.
*
- * @param instructions :: processing instructions defining the detectors of
- * interest
* @param inputWS :: the input workspace
* @param twoTheta :: the angle to move detectors to
* @return :: the corrected workspace
*/
MatrixWorkspace_sptr ReflectometryReductionOneAuto2::correctDetectorPositions(
- const std::string &instructions, MatrixWorkspace_sptr inputWS,
- const double twoTheta) {
+ MatrixWorkspace_sptr inputWS, const double twoTheta) {
- auto detectorsOfInterest = getDetectorNames(instructions, inputWS);
+ auto detectorsOfInterest = getDetectorNames(inputWS);
// Detectors of interest may be empty. This happens for instance when we input
// a workspace that was previously reduced using this algorithm. In this case,
@@ -517,16 +512,13 @@ MatrixWorkspace_sptr ReflectometryReductionOneAuto2::correctDetectorPositions(
/** Calculate the theta value of the detector of interest specified via
* processing instructions
*
- * @param instructions :: processing instructions defining the detectors of
- * interest
* @param inputWS :: the input workspace
* @return :: the angle of the detector (only the first detector is considered)
*/
double
-ReflectometryReductionOneAuto2::calculateTheta(const std::string &instructions,
- MatrixWorkspace_sptr inputWS) {
+ReflectometryReductionOneAuto2::calculateTheta(MatrixWorkspace_sptr inputWS) {
- const auto detectorsOfInterest = getDetectorNames(instructions, inputWS);
+ const auto detectorsOfInterest = getDetectorNames(inputWS);
// Detectors of interest may be empty. This happens for instance when we input
// a workspace that was previously reduced using this algorithm. In this case,
@@ -804,6 +796,8 @@ bool ReflectometryReductionOneAuto2::processGroups() {
if (!firstTransG) {
alg->setProperty("FirstTransmissionRun", firstTrans);
} else {
+ g_log.information("A group has been passed as the first transmission run "
+ "so the first run only is being used");
alg->setProperty("FirstTransmissionRun", firstTransG->getItem(0));
}
}
@@ -817,6 +811,8 @@ bool ReflectometryReductionOneAuto2::processGroups() {
if (!secondTransG) {
alg->setProperty("SecondTransmissionRun", secondTrans);
} else {
+ g_log.information("A group has been passed as the second transmission "
+ "run so the first run only is being used");
alg->setProperty("secondTransmissionRun", secondTransG->getItem(0));
}
}
@@ -896,13 +892,19 @@ bool ReflectometryReductionOneAuto2::processGroups() {
alg->setProperty("FirstTransmissionRun", "");
alg->setProperty("SecondTransmissionRun", "");
alg->setProperty("CorrectionAlgorithm", "None");
- alg->setProperty("ProcessingInstructions", "0");
+
auto outputIvsLamNames = workspaceNamesInGroup(outputIvsLam);
for (size_t i = 0; i < outputIvsLamNames.size(); ++i) {
const std::string IvsQName = outputIvsQ + "_" + std::to_string(i + 1);
const std::string IvsQBinnedName =
outputIvsQBinned + "_" + std::to_string(i + 1);
const std::string IvsLamName = outputIvsLamNames[i];
+
+ // Find the spectrum processing instructions for ws index 0
+ auto currentWorkspace = boost::dynamic_pointer_cast<MatrixWorkspace>(
+ AnalysisDataService::Instance().retrieve(outputIvsLamNames[i]));
+ auto newProcInst = convertToSpectrumNumber("0", currentWorkspace);
+ alg->setProperty("ProcessingInstructions", newProcInst);
alg->setProperty("InputWorkspace", IvsLamName);
alg->setProperty("OutputWorkspace", IvsQName);
alg->setProperty("OutputWorkspaceBinned", IvsQBinnedName);
diff --git a/Framework/Algorithms/src/ReflectometryWorkflowBase2.cpp b/Framework/Algorithms/src/ReflectometryWorkflowBase2.cpp
index 36bd251e2e11baa47fa78270092f1954e2a0ac6e..4c9374a205e35e7793f11648e6134c43e97ce89a 100644
--- a/Framework/Algorithms/src/ReflectometryWorkflowBase2.cpp
+++ b/Framework/Algorithms/src/ReflectometryWorkflowBase2.cpp
@@ -6,10 +6,12 @@
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidAlgorithms/ReflectometryWorkflowBase2.h"
#include "MantidAPI/Axis.h"
+#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/Run.h"
#include "MantidAPI/WorkspaceUnitValidator.h"
#include "MantidAlgorithms/BoostOptionalToAlgorithmProperty.h"
#include "MantidGeometry/Instrument.h"
+#include "MantidIndexing/IndexInfo.h"
#include "MantidKernel/ArrayProperty.h"
#include "MantidKernel/CompositeValidator.h"
#include "MantidKernel/EnabledWhenProperty.h"
@@ -23,6 +25,20 @@ using namespace Mantid::API;
using namespace Mantid::Kernel;
using namespace Mantid::Geometry;
+namespace {
+int convertStringNumToInt(const std::string &string) {
+ try {
+ auto returnValue = std::stoi(string.c_str());
+ return returnValue;
+ } catch (std::invalid_argument &) {
+ throw std::runtime_error("Invalid argument for processing instructions");
+ } catch (std::out_of_range &) {
+ throw std::runtime_error(
+ "Out of range value given for processing instructions");
+ }
+}
+} // namespace
+
namespace Mantid {
namespace Algorithms {
@@ -121,18 +137,17 @@ void ReflectometryWorkflowBase2::initTransmissionProperties() {
initStitchProperties();
- declareProperty(make_unique<PropertyWithValue<bool>>("StrictSpectrumChecking",
- true, Direction::Input),
- "Enforces spectrum number checking prior to normalization by "
- "transmission workspace. Applies to input workspace and "
- "transmission workspace.");
+ declareProperty(
+ make_unique<PropertyWithValue<std::string>>(
+ "TransmissionProcessingInstructions", "", Direction::Input),
+ "These processing instructions will be passed to the transmission "
+ "workspace algorithm");
setPropertyGroup("FirstTransmissionRun", "Transmission");
setPropertyGroup("SecondTransmissionRun", "Transmission");
setPropertyGroup("Params", "Transmission");
setPropertyGroup("StartOverlap", "Transmission");
setPropertyGroup("EndOverlap", "Transmission");
- setPropertyGroup("StrictSpectrumChecking", "Transmission");
}
/** Initialize properties used for stitching transmission runs
@@ -399,17 +414,22 @@ MatrixWorkspace_sptr ReflectometryWorkflowBase2::cropWavelength(
wavelengthMin = getProperty("WavelengthMin");
wavelengthMax = getProperty("WavelengthMax");
}
-
- auto cropWorkspaceAlg = createChildAlgorithm("CropWorkspace");
- cropWorkspaceAlg->initialize();
- cropWorkspaceAlg->setProperty("InputWorkspace", inputWS);
- cropWorkspaceAlg->setProperty("XMin", wavelengthMin);
- cropWorkspaceAlg->setProperty("XMax", wavelengthMax);
- cropWorkspaceAlg->execute();
- MatrixWorkspace_sptr outputWS =
- cropWorkspaceAlg->getProperty("OutputWorkspace");
-
- return outputWS;
+ try {
+ auto cropWorkspaceAlg = createChildAlgorithm("CropWorkspace");
+ cropWorkspaceAlg->initialize();
+ cropWorkspaceAlg->setProperty("InputWorkspace", inputWS);
+ cropWorkspaceAlg->setProperty("XMin", wavelengthMin);
+ cropWorkspaceAlg->setProperty("XMax", wavelengthMax);
+ cropWorkspaceAlg->execute();
+ MatrixWorkspace_sptr outputWS =
+ cropWorkspaceAlg->getProperty("OutputWorkspace");
+
+ return outputWS;
+ } catch (std::out_of_range &e) {
+ throw std::runtime_error("The processing instruction(s) are likely out of "
+ "bounds on the workspace, actual error: " +
+ std::string(e.what()));
+ }
}
/** Process an input workspace in TOF according to specified processing commands
@@ -421,12 +441,10 @@ MatrixWorkspace_sptr ReflectometryWorkflowBase2::cropWavelength(
MatrixWorkspace_sptr
ReflectometryWorkflowBase2::makeDetectorWS(MatrixWorkspace_sptr inputWS,
const bool convert) {
-
- const std::string processingCommands =
- getPropertyValue("ProcessingInstructions");
auto groupAlg = createChildAlgorithm("GroupDetectors");
groupAlg->initialize();
- groupAlg->setProperty("GroupingPattern", processingCommands);
+ groupAlg->setProperty("GroupingPattern",
+ m_processingInstructionsWorkspaceIndex);
groupAlg->setProperty("InputWorkspace", inputWS);
groupAlg->execute();
MatrixWorkspace_sptr detectorWS = groupAlg->getProperty("OutputWorkspace");
@@ -564,22 +582,13 @@ void ReflectometryWorkflowBase2::populateMonitorProperties(
alg->setProperty("MonitorIntegrationWavelengthMax", integrationMax.get());
}
-/** Set processing instructions
- *
- * @param alg :: ReflectometryReductionOne algorithm
+/** Finding processing instructions from the parameters file
* @param instrument :: the instrument attached to the workspace
* @param inputWS :: the input workspace
* @return :: processing instructions as a string
*/
-std::string ReflectometryWorkflowBase2::populateProcessingInstructions(
- IAlgorithm_sptr alg, Instrument_const_sptr instrument,
- MatrixWorkspace_sptr inputWS) const {
-
- if (!getPointerToProperty("ProcessingInstructions")->isDefault()) {
- const std::string instructions = getProperty("ProcessingInstructions");
- alg->setProperty("ProcessingInstructions", instructions);
- return instructions;
- }
+std::string ReflectometryWorkflowBase2::findProcessingInstructions(
+ Instrument_const_sptr instrument, MatrixWorkspace_sptr inputWS) const {
const std::string analysisMode = getProperty("AnalysisMode");
@@ -601,7 +610,6 @@ std::string ReflectometryWorkflowBase2::populateProcessingInstructions(
auto instructions = std::to_string(detStart);
if (detStart != detStop)
instructions += ":" + std::to_string(detStop);
- alg->setProperty("ProcessingInstructions", instructions);
return instructions;
}
@@ -616,7 +624,6 @@ std::string ReflectometryWorkflowBase2::populateProcessingInstructions(
auto instructions = std::to_string(static_cast<int>(multiStart[0])) + ":" +
std::to_string(inputWS->getNumberHistograms() - 1);
- alg->setProperty("ProcessingInstructions", instructions);
return instructions;
}
}
@@ -691,5 +698,88 @@ ReflectometryWorkflowBase2::getRunNumber(MatrixWorkspace const &ws) const {
return "";
}
+std::string
+ReflectometryWorkflowBase2::convertProcessingInstructionsToWorkspaceIndices(
+ const std::string &instructions, MatrixWorkspace_const_sptr ws) const {
+ std::string converted = "";
+ std::string currentNumber = "";
+ std::string ignoreThese = "-,:+";
+ for (auto i = 0u; i < instructions.size(); ++i) {
+ if (std::find(ignoreThese.begin(), ignoreThese.end(), instructions[i]) !=
+ ignoreThese.end()) {
+ // Found a spacer so add currentNumber to converted followed by separator
+ converted.append(convertToWorkspaceIndex(currentNumber, ws));
+ converted.push_back(instructions[i]);
+ currentNumber = "";
+ } else {
+ currentNumber.push_back(instructions[i]);
+ }
+ }
+ // Add currentNumber onto converted
+ converted.append(convertToWorkspaceIndex(currentNumber, ws));
+ return converted;
+}
+
+std::string ReflectometryWorkflowBase2::convertToWorkspaceIndex(
+ const std::string &spectrumNumber, MatrixWorkspace_const_sptr ws) const {
+ auto specNum = convertStringNumToInt(spectrumNumber);
+ std::string wsIdx = std::to_string(
+ ws->getIndexFromSpectrumNumber(static_cast<specnum_t>(specNum)));
+ return wsIdx;
+}
+
+std::string
+ReflectometryWorkflowBase2::convertProcessingInstructionsToSpectrumNumbers(
+ const std::string &instructions,
+ Mantid::API::MatrixWorkspace_const_sptr ws) const {
+ std::string converted = "";
+ std::string currentNumber = "";
+ std::string ignoreThese = "-,:+";
+ for (auto i = 0u; i < instructions.size(); ++i) {
+ if (std::find(ignoreThese.begin(), ignoreThese.end(), instructions[i]) !=
+ ignoreThese.end()) {
+ // Found a spacer so add currentNumber to converted after seperator
+ converted.append(convertToSpectrumNumber(currentNumber, ws));
+ converted.push_back(instructions[i]);
+ currentNumber = "";
+ } else {
+ currentNumber.push_back(instructions[i]);
+ }
+ }
+ // Add currentNumber onto converted
+ converted.append(convertToSpectrumNumber(currentNumber, ws));
+ return converted;
+}
+std::string ReflectometryWorkflowBase2::convertToSpectrumNumber(
+ const std::string &workspaceIndex,
+ Mantid::API::MatrixWorkspace_const_sptr ws) const {
+ auto wsIndx = convertStringNumToInt(workspaceIndex);
+ std::string specId = std::to_string(
+ static_cast<int32_t>(ws->indexInfo().spectrumNumber(wsIndx)));
+ return specId;
+}
+
+void ReflectometryWorkflowBase2::convertProcessingInstructions(
+ Instrument_const_sptr instrument, MatrixWorkspace_sptr inputWS) {
+ m_processingInstructions = getPropertyValue("ProcessingInstructions");
+ if (!getPointerToProperty("ProcessingInstructions")->isDefault()) {
+ m_processingInstructionsWorkspaceIndex =
+ convertProcessingInstructionsToWorkspaceIndices(
+ m_processingInstructions, inputWS);
+ } else {
+ m_processingInstructionsWorkspaceIndex =
+ findProcessingInstructions(instrument, inputWS);
+ m_processingInstructions = convertProcessingInstructionsToSpectrumNumbers(
+ m_processingInstructionsWorkspaceIndex, inputWS);
+ }
+}
+
+void ReflectometryWorkflowBase2::convertProcessingInstructions(
+ MatrixWorkspace_sptr inputWS) {
+ m_processingInstructions = getPropertyValue("ProcessingInstructions");
+ m_processingInstructionsWorkspaceIndex =
+ convertProcessingInstructionsToWorkspaceIndices(m_processingInstructions,
+ inputWS);
+}
} // namespace Algorithms
} // namespace Mantid
diff --git a/Framework/Algorithms/src/SpecularReflectionPositionCorrect2.cpp b/Framework/Algorithms/src/SpecularReflectionPositionCorrect2.cpp
index 80f13db0e4af5395dd03c2ba825db02cc1c5103b..2e0a983c66d9b6031e6dd00348c6cab577c06f6e 100644
--- a/Framework/Algorithms/src/SpecularReflectionPositionCorrect2.cpp
+++ b/Framework/Algorithms/src/SpecularReflectionPositionCorrect2.cpp
@@ -6,17 +6,54 @@
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidAlgorithms/SpecularReflectionPositionCorrect2.h"
#include "MantidAPI/MatrixWorkspace.h"
+#include "MantidAPI/SpectrumInfo.h"
#include "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/ReferenceFrame.h"
#include "MantidKernel/BoundedValidator.h"
-#include "MantidKernel/CompositeValidator.h"
#include "MantidKernel/ListValidator.h"
-#include "MantidKernel/MandatoryValidator.h"
using namespace Mantid::API;
using namespace Mantid::Geometry;
using namespace Mantid::Kernel;
+namespace {
+/// Enumerations to define the rotation plane of the detector.
+enum class Plane { horizontal, vertical };
+
+/** Return true if twoTheta increases with workspace index.
+ * @param spectrumInfo a spectrum info
+ * @return true if twoTheta increases with workspace index
+ */
+bool isAngleIncreasingWithIndex(const Mantid::API::SpectrumInfo &spectrumInfo) {
+ const auto first = spectrumInfo.signedTwoTheta(0);
+ const auto last = spectrumInfo.signedTwoTheta(spectrumInfo.size() - 1);
+ return first < last;
+}
+
+/** Calculate a pixel's offset angle from detector centre.
+ * @param ws a workspace
+ * @param l2 sample to detector distance
+ * @param linePosition pixel's workspace index
+ * @return the offset angle, in radians
+ */
+double offsetAngleFromCentre(const MatrixWorkspace &ws, const double l2,
+ const double linePosition,
+ const double pixelSize) {
+ const auto &spectrumInfo = ws.spectrumInfo();
+ const size_t nSpec = spectrumInfo.size();
+ if (linePosition + 1. > static_cast<double>(nSpec)) {
+ std::ostringstream msg;
+ msg << "LinePosition is greater than the maximum workspace index "
+ << spectrumInfo.size() - 1;
+ throw std::runtime_error(msg.str());
+ }
+ auto const centreIndex = static_cast<double>(nSpec - 1) / 2.;
+ auto const sign = isAngleIncreasingWithIndex(spectrumInfo) ? -1. : 1.;
+ double const offsetWidth = (centreIndex - linePosition) * pixelSize;
+ return sign * std::atan2(offsetWidth, l2);
+}
+} // namespace
+
namespace Mantid {
namespace Algorithms {
@@ -31,7 +68,7 @@ const std::string SpecularReflectionPositionCorrect2::name() const {
/// Algorithm's summary. @see Algorithm::summary
const std::string SpecularReflectionPositionCorrect2::summary() const {
- return "Corrects a detector component's position based on TwoTheta.";
+ return "Corrects a reflectometer's detector component's position.";
}
/// Algorithm's version for identification. @see Algorithm::version
@@ -53,22 +90,14 @@ void SpecularReflectionPositionCorrect2::init() {
"InputWorkspace", "", Direction::Input),
"An input workspace to correct.");
- auto thetaValidator = boost::make_shared<CompositeValidator>();
- thetaValidator->add(boost::make_shared<MandatoryValidator<double>>());
- thetaValidator->add(
- boost::make_shared<BoundedValidator<double>>(0, 90, true));
- declareProperty(
- make_unique<PropertyWithValue<double>>("TwoTheta", Mantid::EMPTY_DBL(),
- thetaValidator, Direction::Input),
- "Angle used to correct the detector component.");
+ declareProperty(make_unique<PropertyWithValue<double>>(
+ "TwoTheta", Mantid::EMPTY_DBL(), Direction::Input),
+ "Angle used to correct the detector component [degrees].");
const std::vector<std::string> correctionType{"VerticalShift",
"RotateAroundSample"};
- auto correctionTypeValidator = boost::make_shared<CompositeValidator>();
- correctionTypeValidator->add(
- boost::make_shared<MandatoryValidator<std::string>>());
- correctionTypeValidator->add(
- boost::make_shared<StringListValidator>(correctionType));
+ auto correctionTypeValidator =
+ boost::make_shared<StringListValidator>(correctionType);
declareProperty(
"DetectorCorrectionType", correctionType[0], correctionTypeValidator,
"Whether detectors should be shifted vertically or rotated around the "
@@ -78,80 +107,140 @@ void SpecularReflectionPositionCorrect2::init() {
declareProperty(
Mantid::Kernel::make_unique<PropertyWithValue<std::string>>(
"DetectorComponentName", "", Direction::Input),
- "Name of the detector component to correct, i.e. point-detector");
-
- declareProperty("DetectorID", -1,
- "The ID of the detector to correct. If both "
+ "Name of the detector component to correct, for example point-detector");
+ auto nonNegativeInt = boost::make_shared<Kernel::BoundedValidator<int>>();
+ nonNegativeInt->setLower(0);
+ declareProperty("DetectorID", EMPTY_INT(), nonNegativeInt,
+ "The ID of the detector to correct; if both "
"the component name and the detector ID "
"are set the latter will be used.");
declareProperty(
Mantid::Kernel::make_unique<PropertyWithValue<std::string>>(
"SampleComponentName", "some-surface-holder", Direction::Input),
- "Name of the sample component, i.e. some-surface-holder");
+ "Name of the sample component; if the given name is not found in the "
+ "instrument, the default sample is used.");
declareProperty(
Mantid::Kernel::make_unique<WorkspaceProperty<MatrixWorkspace>>(
"OutputWorkspace", "", Direction::Output),
- "An output workspace.");
+ "A workspace with corrected detector position.");
+ declareProperty("DetectorFacesSample", false,
+ "If true, a normal vector at the centre of the detector "
+ "always points towards the sample.");
+ auto nonNegativeDouble =
+ boost::make_shared<Kernel::BoundedValidator<double>>();
+ nonNegativeDouble->setLower(0.);
+ declareProperty("LinePosition", EMPTY_DBL(), nonNegativeDouble,
+ "A fractional workspace index for the specular line centre.");
+ declareProperty("DirectLinePosition", EMPTY_DBL(), nonNegativeDouble,
+ "A fractional workspace index for the direct line centre.");
+ auto positiveDouble = boost::make_shared<Kernel::BoundedValidator<double>>();
+ nonNegativeDouble->setLowerExclusive(0.);
+ declareProperty("PixelSize", EMPTY_DBL(), positiveDouble,
+ "Size of a detector pixel, in metres.");
+ declareProperty(
+ make_unique<WorkspaceProperty<MatrixWorkspace>>(
+ "DirectLineWorkspace", "", Direction::Input, PropertyMode::Optional),
+ "A direct beam workspace for reference.");
+}
+
+/// Validate the algorithm's inputs.
+std::map<std::string, std::string>
+SpecularReflectionPositionCorrect2::validateInputs() {
+ std::map<std::string, std::string> issues;
+ if (isDefault("DetectorID") && isDefault("DetectorComponentName")) {
+ issues["DetectorID"] =
+ "DetectorID or DetectorComponentName has to be specified.";
+ }
+ if (!isDefault("TwoTheta")) {
+ if (!isDefault("LinePosition") && isDefault("PixelSize")) {
+ issues["PixelSize"] = "Pixel size required.";
+ }
+ } else {
+ if (isDefault("DirectLinePosition")) {
+ issues["DirectLinePosition"] =
+ "Direct line position required when no TwoTheta supplied.";
+ }
+ if (isDefault("DirectLineWorkspace")) {
+ issues["DirectLineWorkspace"] =
+ "Direct beam workspace required when no TwoTheta supplied.";
+ }
+ if (isDefault("PixelSize")) {
+ issues["PixelSize"] = "Pixel size required for direct beam calibration.";
+ }
+ }
+ return issues;
}
-//----------------------------------------------------------------------------------------------
/** Execute the algorithm.
*/
void SpecularReflectionPositionCorrect2::exec() {
MatrixWorkspace_sptr inWS = this->getProperty("InputWorkspace");
-
- auto cloneWS = createChildAlgorithm("CloneWorkspace");
- cloneWS->initialize();
- cloneWS->setProperty("InputWorkspace", inWS);
- cloneWS->execute();
- Workspace_sptr tmp = cloneWS->getProperty("OutputWorkspace");
- MatrixWorkspace_sptr outWS =
- boost::dynamic_pointer_cast<MatrixWorkspace>(tmp);
-
- const double twoThetaIn = getProperty("TwoTheta");
- const double twoThetaInRad = twoThetaIn * (M_PI / 180.0);
-
- auto inst = outWS->getInstrument();
-
- // Detector
- const int detectorID = getProperty("DetectorID");
- const std::string detectorName = getProperty("DetectorComponentName");
-
- IComponent_const_sptr detector;
- if (detectorID > 0) {
- detector = inst->getDetector(detectorID);
- } else {
- if (!inst->getComponentByName(detectorName))
- throw std::runtime_error("Detector component not found.");
- detector = inst->getComponentByName(detectorName);
+ MatrixWorkspace_sptr outWS = getProperty("OutputWorkspace");
+ if (outWS != inWS) {
+ outWS = inWS->clone();
}
- const V3D detectorPosition = detector->getPos();
-
// Sample
- const std::string sampleName = getProperty("SampleComponentName");
- if (!inst->getComponentByName(sampleName))
- throw std::runtime_error("Sample component not found.");
- IComponent_const_sptr sample = inst->getComponentByName(sampleName);
- const V3D samplePosition = sample->getPos();
+ const V3D samplePosition = declareSamplePosition(*inWS);
// Type of movement (vertical shift or rotation around the sample)
const std::string correctionType = getProperty("DetectorCorrectionType");
+ // Detector
+ auto inst = inWS->getInstrument();
+ const detid_t detectorID = static_cast<int>(getProperty("DetectorID"));
+ const std::string detectorName = getProperty("DetectorComponentName");
+ const V3D detectorPosition =
+ declareDetectorPosition(*inst, detectorName, detectorID);
// Sample-to-detector
const V3D sampleToDetector = detectorPosition - samplePosition;
- // Reference frame
+ const double l2 = sampleToDetector.norm();
auto referenceFrame = inst->getReferenceFrame();
- auto beamAxis = referenceFrame->pointingAlongBeamAxis();
- auto horizontalAxis = referenceFrame->pointingHorizontalAxis();
- auto upAxis = referenceFrame->pointingUpAxis();
+ const auto alongDir = referenceFrame->vecPointingAlongBeam();
+ const double beamOffsetOld = sampleToDetector.scalar_prod(alongDir);
+
+ const double twoThetaInRad =
+ isDefault("TwoTheta")
+ ? twoThetaFromDirectLine(detectorName, detectorID, samplePosition, l2,
+ alongDir, beamOffsetOld)
+ : twoThetaFromProperties(*inWS, l2);
+
+ correctDetectorPosition(outWS, detectorName, detectorID, twoThetaInRad,
+ correctionType, *referenceFrame, samplePosition,
+ sampleToDetector, beamOffsetOld);
+ setProperty("OutputWorkspace", outWS);
+}
+
+/**
+ * Move and rotate the detector to its correct position
+ * @param outWS the workspace to modify
+ * @param detectorName name of the detector component
+ * @param detectorID detector component's id
+ * @param twoThetaInRad beam-detector angle in radians
+ * @param correctionType type of correction
+ * @param referenceFrame instrument's reference frame
+ * @param samplePosition sample position
+ * @param sampleToDetector a vector from sample to detector
+ * @param beamOffsetOld sample detector distance on the beam axis
+ */
+void SpecularReflectionPositionCorrect2::correctDetectorPosition(
+ MatrixWorkspace_sptr &outWS, const std::string &detectorName,
+ const detid_t detectorID, const double twoThetaInRad,
+ const std::string &correctionType, const ReferenceFrame &referenceFrame,
+ const V3D &samplePosition, const V3D &sampleToDetector,
+ const double beamOffsetOld) {
+ const auto beamAxis = referenceFrame.pointingAlongBeamAxis();
+ const auto horizontalAxis = referenceFrame.pointingHorizontalAxis();
+ const auto upAxis = referenceFrame.pointingUpAxis();
+ const auto thetaSignDir = referenceFrame.vecThetaSign();
+ const auto upDir = referenceFrame.vecPointingUp();
+ const auto plane = thetaSignDir.scalar_prod(upDir) == 1. ? Plane::vertical
+ : Plane::horizontal;
// Get the offset from the sample in the beam direction
double beamOffset = 0.0;
- const double beamOffsetOld =
- sampleToDetector.scalar_prod(referenceFrame->vecPointingAlongBeam());
if (correctionType == "VerticalShift") {
// Only shifting vertically, so the beam offset remains the same
@@ -159,27 +248,25 @@ void SpecularReflectionPositionCorrect2::exec() {
} else if (correctionType == "RotateAroundSample") {
// The radius for the rotation is the distance from the sample to
// the detector in the Beam-Vertical plane
- const double upOffsetOld =
- sampleToDetector.scalar_prod(referenceFrame->vecPointingUp());
- const double radius =
- std::sqrt(beamOffsetOld * beamOffsetOld + upOffsetOld * upOffsetOld);
+ const double perpendicularOffsetOld =
+ sampleToDetector.scalar_prod(thetaSignDir);
+ const double radius = std::hypot(beamOffsetOld, perpendicularOffsetOld);
beamOffset = radius * std::cos(twoThetaInRad);
} else {
// Shouldn't get here unless there's been a coding error
std::ostringstream message;
- message << "Invalid correction type '" << correctionType;
+ message << "Invalid correction type '" << correctionType << "'";
throw std::runtime_error(message.str());
}
// Calculate the offset in the vertical direction, and the total
// offset in the beam direction
- const double upOffset = (beamOffset * std::tan(twoThetaInRad));
+ const double perpendicularOffset = beamOffset * std::tan(twoThetaInRad);
const double beamOffsetFromOrigin =
beamOffset +
- samplePosition.scalar_prod(referenceFrame->vecPointingAlongBeam());
+ samplePosition.scalar_prod(referenceFrame.vecPointingAlongBeam());
auto moveAlg = createChildAlgorithm("MoveInstrumentComponent");
- moveAlg->initialize();
moveAlg->setProperty("Workspace", outWS);
if (!detectorName.empty()) {
moveAlg->setProperty("ComponentName", detectorName);
@@ -188,11 +275,130 @@ void SpecularReflectionPositionCorrect2::exec() {
}
moveAlg->setProperty("RelativePosition", false);
moveAlg->setProperty(beamAxis, beamOffsetFromOrigin);
- moveAlg->setProperty(horizontalAxis, 0.0);
- moveAlg->setProperty(upAxis, upOffset);
+ if (plane == Plane::vertical) {
+ moveAlg->setProperty(horizontalAxis, 0.0);
+ moveAlg->setProperty(upAxis, perpendicularOffset);
+ } else {
+ moveAlg->setProperty(horizontalAxis, perpendicularOffset);
+ moveAlg->setProperty(upAxis, 0.0);
+ }
moveAlg->execute();
- setProperty("OutputWorkspace", outWS);
+ const bool rotateFace = getProperty("DetectorFacesSample");
+ if (rotateFace) {
+ auto rotate = createChildAlgorithm("RotateInstrumentComponent");
+ rotate->setProperty("Workspace", outWS);
+ if (!detectorName.empty())
+ rotate->setProperty("ComponentName", detectorName);
+ else
+ rotate->setProperty("DetectorID", detectorID);
+ if (plane == Plane::horizontal) {
+ rotate->setProperty("X", upDir.X());
+ rotate->setProperty("Y", upDir.Y());
+ rotate->setProperty("Z", upDir.Z());
+ } else {
+ const V3D horizontalDir = -referenceFrame.vecPointingHorizontal();
+ rotate->setProperty("X", horizontalDir.X());
+ rotate->setProperty("Y", horizontalDir.Y());
+ rotate->setProperty("Z", horizontalDir.Z());
+ }
+ rotate->setProperty("RelativeRotation", false);
+ rotate->setProperty("Angle", twoThetaInRad * 180. / M_PI);
+ rotate->execute();
+ }
+}
+
+/**
+ * Return the detector's position
+ * @param inst an instrument
+ * @param detectorName detector component's name
+ * @param detectorID detector's id
+ * @return a position
+ */
+Kernel::V3D SpecularReflectionPositionCorrect2::declareDetectorPosition(
+ const Geometry::Instrument &inst, const std::string &detectorName,
+ const detid_t detectorID) {
+ // Detector
+ IComponent_const_sptr detector;
+ if (detectorName.empty()) {
+ detector = inst.getDetector(detectorID);
+ } else {
+ detector = inst.getComponentByName(detectorName);
+ if (!detector)
+ throw Exception::NotFoundError("Detector component not found",
+ detectorName);
+ }
+ return detector->getPos();
+}
+
+/**
+ * Return the sample position
+ * @param ws a workspace
+ * @return a position
+ */
+V3D SpecularReflectionPositionCorrect2::declareSamplePosition(
+ const MatrixWorkspace &ws) {
+ V3D position;
+ const std::string sampleName = getProperty("SampleComponentName");
+ auto inst = ws.getInstrument();
+ IComponent_const_sptr sample = inst->getComponentByName(sampleName);
+ if (sample)
+ position = sample->getPos();
+ else
+ position = ws.spectrumInfo().samplePosition();
+ return position;
+}
+
+/**
+ * Return the user-given TwoTheta, augmented by LinePosition if needed
+ * @param inWS the input workspace
+ * @param l2 sample-to-detector distance
+ * @return TwoTheta, in radians
+ */
+double SpecularReflectionPositionCorrect2::twoThetaFromProperties(
+ const MatrixWorkspace &inWS, const double l2) {
+ double twoThetaInRad =
+ static_cast<double>(getProperty("TwoTheta")) * M_PI / 180.0;
+ if (!isDefault("LinePosition")) {
+ const double linePosition = getProperty("LinePosition");
+ const double pixelSize = getProperty("PixelSize");
+ const double offset =
+ offsetAngleFromCentre(inWS, l2, linePosition, pixelSize);
+ twoThetaInRad -= offset;
+ }
+ return twoThetaInRad;
+}
+
+/**
+ * Return a direct beam calibrated TwoTheta
+ * @param detectorName name of the detector component
+ * @param detectorID detector's id
+ * @param samplePosition sample position
+ * @param l2 sample-to-detector distance
+ * @param alongDir a unit vector pointing along the beam
+ * @param beamOffset sample-to-detector distance on the beam axis
+ * @return TwoTheta, in radians
+ */
+double SpecularReflectionPositionCorrect2::twoThetaFromDirectLine(
+ const std::string &detectorName, const detid_t detectorID,
+ const V3D &samplePosition, const double l2, const V3D &alongDir,
+ const double beamOffset) {
+ double twoThetaInRad;
+ MatrixWorkspace_sptr directWS = getProperty("DirectLineWorkspace");
+ const double directLinePosition = getProperty("DirectLinePosition");
+ const double pixelSize = getProperty("PixelSize");
+ const double directOffset =
+ offsetAngleFromCentre(*directWS, l2, directLinePosition, pixelSize);
+ const auto reflectedDetectorAngle = std::acos(beamOffset / l2);
+ auto directInst = directWS->getInstrument();
+ const auto directDetPos =
+ declareDetectorPosition(*directInst, detectorName, detectorID);
+ const auto directSampleToDet = directDetPos - samplePosition;
+ const double directBeamOffset = directSampleToDet.scalar_prod(alongDir);
+ const double directL2 = directSampleToDet.norm();
+ const auto directDetectorAngle = std::acos(directBeamOffset / directL2);
+ twoThetaInRad = reflectedDetectorAngle - directDetectorAngle - directOffset;
+ return twoThetaInRad;
}
} // namespace Algorithms
diff --git a/Framework/Algorithms/test/CMakeLists.txt b/Framework/Algorithms/test/CMakeLists.txt
index 0af518f5afc4981455c30108cbcbb47a10ec77f9..402e6f7a712604359f0ecb1519c57a38a7f832f3 100644
--- a/Framework/Algorithms/test/CMakeLists.txt
+++ b/Framework/Algorithms/test/CMakeLists.txt
@@ -32,9 +32,10 @@ if ( CXXTEST_FOUND )
# It will go out of scope at the end of this file so doesn't need un-setting
set ( TESTHELPER_SRCS ../../TestHelpers/src/ComponentCreationHelper.cpp
../../TestHelpers/src/FileComparisonHelper.cpp
+ ../../TestHelpers/src/IndirectFitDataCreationHelper.cpp
../../TestHelpers/src/InstrumentCreationHelper.cpp
../../TestHelpers/src/MDEventsTestHelper.cpp
- ../../TestHelpers/src/MuonWorkspaceCreationHelper.cpp
+ ../../TestHelpers/src/MuonWorkspaceCreationHelper.cpp
../../TestHelpers/src/SANSInstrumentCreationHelper.cpp
../../TestHelpers/src/ScopedFileHelper.cpp
../../TestHelpers/src/TearDownWorld.cpp
diff --git a/Framework/Algorithms/test/CreateTransmissionWorkspace2Test.h b/Framework/Algorithms/test/CreateTransmissionWorkspace2Test.h
index 7c3bdd9c12b7c51bebcb8f950ea0fb1499e9bdb3..48aac6f65539434fb6b71079ce8b47d4ff30604f 100644
--- a/Framework/Algorithms/test/CreateTransmissionWorkspace2Test.h
+++ b/Framework/Algorithms/test/CreateTransmissionWorkspace2Test.h
@@ -54,7 +54,7 @@ public:
alg.initialize();
alg.setChild(true);
alg.setProperty("FirstTransmissionRun", m_multiDetectorWS);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
alg.setPropertyValue("OutputWorkspace", "outWS");
@@ -78,7 +78,7 @@ public:
alg.initialize();
alg.setChild(true);
alg.setProperty("FirstTransmissionRun", m_multiDetectorWS);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("WavelengthMax", 15.0);
alg.setPropertyValue("OutputWorkspace", "outWS");
TS_ASSERT_THROWS_ANYTHING(alg.execute());
@@ -90,7 +90,7 @@ public:
alg.initialize();
alg.setChild(true);
alg.setProperty("FirstTransmissionRun", m_multiDetectorWS);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("WavelengthMin", 1.5);
alg.setPropertyValue("OutputWorkspace", "outWS");
TS_ASSERT_THROWS_ANYTHING(alg.execute());
@@ -114,7 +114,7 @@ public:
alg.initialize();
alg.setChild(true);
alg.setProperty("FirstTransmissionRun", m_multiDetectorWS);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("WavelengthMin", 15.0);
alg.setProperty("WavelengthMax", 1.5);
alg.setPropertyValue("OutputWorkspace", "outWS");
@@ -127,7 +127,7 @@ public:
alg.initialize();
alg.setChild(true);
alg.setProperty("FirstTransmissionRun", m_multiDetectorWS);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("MonitorBackgroundWavelengthMin", 15.0);
@@ -142,7 +142,7 @@ public:
alg.initialize();
alg.setChild(true);
alg.setProperty("FirstTransmissionRun", m_multiDetectorWS);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("MonitorIntegrationWavelengthMin", 1.0);
@@ -159,7 +159,7 @@ public:
alg.setProperty("FirstTransmissionRun", m_multiDetectorWS);
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
- alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("ProcessingInstructions", "2");
alg.setPropertyValue("OutputWorkspace", "outWS");
alg.execute();
MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspace");
@@ -182,7 +182,7 @@ public:
alg.setProperty("FirstTransmissionRun", m_multiDetectorWS);
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
- alg.setPropertyValue("ProcessingInstructions", "1+2");
+ alg.setPropertyValue("ProcessingInstructions", "2+3");
alg.setPropertyValue("OutputWorkspace", "outWS");
alg.execute();
MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspace");
@@ -219,7 +219,7 @@ public:
alg.setProperty("I0MonitorIndex", "0");
alg.setProperty("MonitorBackgroundWavelengthMin", 0.5);
alg.setProperty("MonitorBackgroundWavelengthMax", 3.0);
- alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("ProcessingInstructions", "2");
alg.setPropertyValue("OutputWorkspace", "outWS");
alg.execute();
MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspace");
@@ -257,7 +257,7 @@ public:
alg.setProperty("MonitorBackgroundWavelengthMax", 3.0);
alg.setProperty("MonitorIntegrationWavelengthMin", 1.5);
alg.setProperty("MonitorIntegrationWavelengthMax", 15.0);
- alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("ProcessingInstructions", "2");
alg.setPropertyValue("OutputWorkspace", "outWS");
alg.execute();
MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspace");
@@ -280,7 +280,7 @@ public:
alg.setProperty("SecondTransmissionRun", m_multiDetectorWS);
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
- alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("ProcessingInstructions", "2");
alg.setPropertyValue("OutputWorkspace", "outWS");
alg.execute();
MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspace");
@@ -303,7 +303,7 @@ public:
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("Params", "0.1");
- alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("ProcessingInstructions", "2");
alg.setPropertyValue("OutputWorkspace", "outWS");
alg.execute();
MatrixWorkspace_sptr outLam = alg.getProperty("OutputWorkspace");
@@ -328,7 +328,7 @@ public:
alg.setProperty("FirstTransmissionRun", inputWS);
alg.setProperty("WavelengthMin", 3.0);
alg.setProperty("WavelengthMax", 12.0);
- alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("ProcessingInstructions", "2");
alg.setPropertyValue("OutputWorkspace", "outWS");
alg.execute();
@@ -354,7 +354,7 @@ public:
alg.setProperty("FirstTransmissionRun", inputWS);
alg.setProperty("WavelengthMin", 3.0);
alg.setProperty("WavelengthMax", 12.0);
- alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("ProcessingInstructions", "2");
alg.execute();
TS_ASSERT(AnalysisDataService::Instance().doesExist("TRANS_LAM_1234"));
@@ -382,7 +382,7 @@ public:
alg.setProperty("SecondTransmissionRun", inputWS2);
alg.setProperty("WavelengthMin", 3.0);
alg.setProperty("WavelengthMax", 12.0);
- alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("ProcessingInstructions", "2");
alg.setPropertyValue("OutputWorkspace", "outWS");
alg.execute();
MatrixWorkspace_sptr firstLam =
@@ -422,7 +422,7 @@ public:
alg.setProperty("SecondTransmissionRun", inputWS2);
alg.setProperty("WavelengthMin", 3.0);
alg.setProperty("WavelengthMax", 12.0);
- alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("ProcessingInstructions", "2");
alg.execute();
MatrixWorkspace_sptr firstLam =
AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
@@ -460,7 +460,7 @@ public:
alg.setProperty("SecondTransmissionRun", inputWS2);
alg.setProperty("WavelengthMin", 3.0);
alg.setProperty("WavelengthMax", 12.0);
- alg.setPropertyValue("ProcessingInstructions", "1");
+ alg.setPropertyValue("ProcessingInstructions", "2");
alg.execute();
MatrixWorkspace_sptr outWS = alg.getProperty("OutputWorkspace");
TS_ASSERT(outWS);
diff --git a/Framework/Algorithms/test/CreateTransmissionWorkspaceAuto2Test.h b/Framework/Algorithms/test/CreateTransmissionWorkspaceAuto2Test.h
index 56dcf8cb997d62a7f3ba834992b30f8d8728c296..a7267121f66215ac8f207fd1ba93f61fad6c97ba 100644
--- a/Framework/Algorithms/test/CreateTransmissionWorkspaceAuto2Test.h
+++ b/Framework/Algorithms/test/CreateTransmissionWorkspaceAuto2Test.h
@@ -89,7 +89,7 @@ public:
alg->setProperty("FirstTransmissionRun", m_dataWS);
alg->setPropertyValue("OutputWorkspace", "outWS");
- alg->execute();
+ TS_ASSERT_THROWS_NOTHING(alg->execute());
TS_ASSERT(alg->isExecuted());
MatrixWorkspace_sptr outWS =
@@ -118,10 +118,14 @@ public:
vecPropertyHistories, "MonitorIntegrationWavelengthMax");
const int i0MonitorIndex =
findPropertyValue<int>(vecPropertyHistories, "I0MonitorIndex");
- const std::string processingInstructions = findPropertyValue<std::string>(
- vecPropertyHistories, "ProcessingInstructions");
- std::vector<std::string> pointDetectorStartStop;
- boost::split(pointDetectorStartStop, processingInstructions,
+ const std::string processingInstructionsString =
+ findPropertyValue<std::string>(vecPropertyHistories,
+ "ProcessingInstructions");
+ // In workspace indices form the processing instructions should be the same
+ // However this has been changed to specNum and that is +1 of the instrument
+ // Parameter files value for PointDetectorStart
+ std::vector<std::string> processingInstructionsList;
+ boost::split(processingInstructionsList, processingInstructionsString,
boost::is_any_of(":"));
auto inst = m_dataWS->getInstrument();
@@ -143,9 +147,10 @@ public:
monitorIntegrationWavelengthMax);
TS_ASSERT_EQUALS(inst->getNumberParameter("I0MonitorIndex").at(0),
i0MonitorIndex);
- TS_ASSERT_EQUALS(inst->getNumberParameter("PointDetectorStart").at(0),
- boost::lexical_cast<double>(pointDetectorStartStop.at(0)));
- TS_ASSERT_EQUALS(pointDetectorStartStop.size(), 1);
+ TS_ASSERT_EQUALS(
+ inst->getNumberParameter("PointDetectorStart").at(0),
+ boost::lexical_cast<double>(processingInstructionsList.at(0)) - 1);
+ TS_ASSERT_EQUALS(processingInstructionsList.size(), 1);
AnalysisDataService::Instance().remove("outWS");
}
diff --git a/Framework/Algorithms/test/IndirectFitDataCreationHelperTest.h b/Framework/Algorithms/test/IndirectFitDataCreationHelperTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..d110ed764ef2b88f621fe0a397ba83f9936f73c2
--- /dev/null
+++ b/Framework/Algorithms/test/IndirectFitDataCreationHelperTest.h
@@ -0,0 +1,186 @@
+#ifndef MANTID_INDIRECTFITDATACREATIONHELPERTEST_H_
+#define MANTID_INDIRECTFITDATACREATIONHELPERTEST_H_
+
+#include <cxxtest/TestSuite.h>
+
+#include "MantidAPI/AnalysisDataService.h"
+#include "MantidAPI/MatrixWorkspace.h"
+#include "MantidTestHelpers/IndirectFitDataCreationHelper.h"
+
+using namespace Mantid::API;
+using namespace Mantid::IndirectFitDataCreationHelper;
+
+namespace {
+
+void storeWorkspaceInADS(std::string const &workspaceName,
+ MatrixWorkspace_sptr workspace) {
+ SetUpADSWithWorkspace ads(workspaceName, workspace);
+}
+
+/// The classes TypeOne and TypeTwo are used to test AreSpectraEquals which
+/// compares the values of boost::variant types
+class TypeOne {
+public:
+ explicit TypeOne(const std::string &value) : m_value(value) {}
+
+ const std::string &getValue() const { return m_value; }
+
+ bool operator==(TypeOne const &value) const {
+ return this->getValue() == value.getValue();
+ }
+
+private:
+ std::string m_value;
+};
+
+class TypeTwo {
+public:
+ explicit TypeTwo(const std::size_t &value) : m_value(value) {}
+
+ const std::size_t &getValue() const { return m_value; }
+
+ bool operator==(TypeTwo const &value) const {
+ return this->getValue() == value.getValue();
+ }
+
+private:
+ std::size_t m_value;
+};
+
+using Types = boost::variant<TypeOne, TypeTwo>;
+
+} // namespace
+
+class IndirectFitDataCreationHelperTest : public CxxTest::TestSuite {
+public:
+ static IndirectFitDataCreationHelperTest *createSuite() {
+ return new IndirectFitDataCreationHelperTest();
+ }
+
+ static void destroySuite(IndirectFitDataCreationHelperTest *suite) {
+ delete suite;
+ }
+
+ void tearDown() override { AnalysisDataService::Instance().clear(); }
+
+ void
+ test_that_createWorkspace_returns_a_workspace_with_the_number_of_spectra_specified() {
+ auto const workspace = createWorkspace(10);
+ TS_ASSERT(workspace);
+ TS_ASSERT_EQUALS(workspace->getNumberHistograms(), 10);
+ }
+
+ void
+ test_that_createInstrumentWorkspace_returns_a_workspace_with_the_number_of_spectra_specified() {
+ auto const workspace = createInstrumentWorkspace(6, 5);
+ TS_ASSERT(workspace);
+ TS_ASSERT_EQUALS(workspace->getNumberHistograms(), 6);
+ }
+
+ void
+ test_that_setWorkspaceEFixed_does_not_throw_when_setting_EFixed_values() {
+ auto workspace = createInstrumentWorkspace(6, 5);
+ TS_ASSERT_THROWS_NOTHING(setWorkspaceEFixed(workspace, 6));
+ }
+
+ void test_that_setWorkspaceBinEdges_returns_a_workspace_with_binEdges_set() {
+ auto const workspace =
+ setWorkspaceBinEdges(createInstrumentWorkspace(6, 5), 6, 5);
+ for (std::size_t i = 0; i < workspace->getNumberHistograms(); ++i)
+ TS_ASSERT(workspace->binEdges(i));
+ }
+
+ void
+ test_that_setWorkspaceBinEdges_throws_when_provided_an_out_of_range_number_of_spectra() {
+ auto workspace = createInstrumentWorkspace(6, 5);
+ TS_ASSERT_THROWS_ANYTHING(setWorkspaceBinEdges(workspace, 8, 5));
+ }
+
+ void
+ test_that_SetUpADSWithWorkspace_returns_true_when_a_workspace_exists_in_the_ads() {
+ auto const workspace = createWorkspace(10);
+
+ SetUpADSWithWorkspace ads("WorkspaceName", workspace);
+
+ TS_ASSERT(ads.doesExist("WorkspaceName"));
+ }
+
+ void
+ test_that_SetUpADSWithWorkspace_returns_false_when_a_workspace_does_not_exists_in_the_ads() {
+ auto const workspace = createWorkspace(10);
+
+ SetUpADSWithWorkspace ads("WorkspaceName", workspace);
+
+ TS_ASSERT(!ads.doesExist("WorkspaceWrongName"));
+ }
+
+ void
+ test_that_SetUpADSWithWorkspace_retrieves_the_given_workspace_as_expected() {
+ auto const workspace = createWorkspace(10);
+
+ SetUpADSWithWorkspace ads("WorkspaceName", workspace);
+
+ TS_ASSERT(ads.doesExist("WorkspaceName"));
+ auto const storedWorkspace = ads.retrieveWorkspace("WorkspaceName");
+ TS_ASSERT(storedWorkspace)
+ TS_ASSERT_EQUALS(storedWorkspace->getNumberHistograms(), 10);
+ }
+
+ void
+ test_that_SetUpADSWithWorkspace_is_instantiated_with_the_given_workspace_as_expected() {
+ auto const workspace = createWorkspace(10);
+
+ SetUpADSWithWorkspace ads("WorkspaceName", workspace);
+
+ auto const storedWorkspace = ads.retrieveWorkspace("WorkspaceName");
+ TS_ASSERT_EQUALS(storedWorkspace, workspace);
+ TS_ASSERT_EQUALS(storedWorkspace->getNumberHistograms(), 10);
+ }
+
+ void
+ test_that_SetUpADSWithWorkspace_adds_a_given_workspace_to_the_ads_as_expected() {
+ auto const workspace = createWorkspace(10);
+
+ SetUpADSWithWorkspace ads("WorkspaceName1", workspace);
+ ads.addOrReplace("WorkspaceName2", workspace);
+
+ TS_ASSERT(ads.doesExist("WorkspaceName1"));
+ TS_ASSERT(ads.doesExist("WorkspaceName2"));
+ auto const storedWorkspace = ads.retrieveWorkspace("WorkspaceName2");
+ TS_ASSERT_EQUALS(storedWorkspace->getNumberHistograms(), 10);
+ }
+
+ void
+ test_that_the_ads_instance_is_not_destructed_when_it_goes_out_of_scope() {
+ auto const workspace = createWorkspace(10);
+
+ storeWorkspaceInADS("WorkspaceName", workspace);
+
+ TS_ASSERT(AnalysisDataService::Instance().doesExist("WorkspaceName"));
+ }
+
+ void
+ test_that_AreSpectraEqual_returns_true_when_given_two_identical_values_of_same_type() {
+ Types const value1 = TypeOne("SameValue");
+ Types const value2 = TypeOne("SameValue");
+ TS_ASSERT(boost::apply_visitor(AreSpectraEqual(), value1, value2));
+ }
+
+ void
+ test_that_AreSpectraEqual_returns_false_when_given_two_different_values_of_the_same_type() {
+ Types const value1 = TypeOne("Value");
+ Types const value2 = TypeOne("DifferentValue");
+
+ TS_ASSERT(!boost::apply_visitor(AreSpectraEqual(), value1, value2));
+ }
+
+ void
+ test_that_AreSpectraEqual_returns_false_when_given_two_different_values_with_different_types() {
+ Types const value1 = TypeOne("Value");
+ Types const value2 = TypeTwo(2);
+
+ TS_ASSERT(!boost::apply_visitor(AreSpectraEqual(), value1, value2));
+ }
+};
+
+#endif // MANTID_INDIRECTFITDATACREATIONHELPER_TEST
diff --git a/Framework/Algorithms/test/ReflectometryReductionOne2Test.h b/Framework/Algorithms/test/ReflectometryReductionOne2Test.h
index 13dbbb5314f7c2b390a41ea091aa83f2cbe47003..02d462b4f227bb5a7d8606a1f4e17b9f256ee057 100644
--- a/Framework/Algorithms/test/ReflectometryReductionOne2Test.h
+++ b/Framework/Algorithms/test/ReflectometryReductionOne2Test.h
@@ -70,7 +70,7 @@ public:
// No direct beam normalization
// No transmission correction
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "1");
+ setupAlgorithm(alg, 1.5, 15.0, "2");
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
TS_ASSERT(outLam->x(0)[0] >= 1.5);
@@ -84,10 +84,10 @@ public:
// No monitor normalization
// No direct beam normalization
// No transmission correction
- // Processing instructions : 1+2
+ // Processing instructions : 2+3
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "1+2");
+ setupAlgorithm(alg, 1.5, 15.0, "2+3");
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
TS_ASSERT(outLam->x(0)[0] >= 1.5);
@@ -102,10 +102,10 @@ public:
// No monitor normalization
// No direct beam normalization
// No transmission correction
- // Processing instructions : 1-3
+ // Processing instructions : 2-4 spectra is (1-3 workspace indices)
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "1-3");
+ setupAlgorithm(alg, 1.5, 15.0, "2-4");
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
TS_ASSERT(outLam->x(0)[0] >= 1.5);
@@ -120,10 +120,10 @@ public:
// No monitor normalization
// No direct beam normalization
// No transmission correction
- // Processing instructions : 2,1+3 (two separate groups)
+ // Processing instructions : 3,2+4 (two separate groups)
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "2,1+3");
+ setupAlgorithm(alg, 1.5, 15.0, "3,2+4");
// Run the algorithm. There should be 2 output histograms, one for each
// input group. Note that the group order is swapped from the input order
// because they are sorted by the first spectrum number in the group,
@@ -142,10 +142,10 @@ public:
}
void test_bad_processing_instructions() {
- // Processing instructions : 5+6
+ // Processing instructions : 6+7
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "5+6");
+ setupAlgorithm(alg, 1.5, 15.0, "6+7");
// Must throw as spectrum 2 is not defined
TS_ASSERT_THROWS_ANYTHING(alg.execute());
}
@@ -158,7 +158,7 @@ public:
// SummationType : SumInLambda (same as default)
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "1");
+ setupAlgorithm(alg, 1.5, 15.0, "2");
alg.setProperty("SummationType", "SumInLambda");
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
@@ -177,7 +177,7 @@ public:
// ReductionType : DivergentBeam (invalid)
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "1");
+ setupAlgorithm(alg, 1.5, 15.0, "2");
alg.setProperty("SummationType", "SumInLambda");
alg.setProperty("ReductionType", "DivergentBeam");
TS_ASSERT_THROWS_ANYTHING(alg.execute());
@@ -195,7 +195,7 @@ public:
// MonitorBackgroundWavelengthMax : Not given
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "1");
+ setupAlgorithm(alg, 1.5, 15.0, "2");
alg.setProperty("I0MonitorIndex", "0");
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
@@ -213,7 +213,7 @@ public:
// Monitor normalization
// No direct beam normalization
// No transmission correction
- // Processing instructions : 2
+ // Processing instructions : 3
// I0MonitorIndex: 0
// MonitorBackgroundWavelengthMin : 0.5
@@ -227,7 +227,7 @@ public:
std::fill(Y.begin(), Y.begin() + 2, 1.0);
ReflectometryReductionOne2 alg;
- setupAlgorithmMonitorCorrection(alg, 0.0, 15.0, "2", inputWS, false);
+ setupAlgorithmMonitorCorrection(alg, 0.0, 15.0, "3", inputWS, false);
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg, 10);
TS_ASSERT(outLam->x(0)[0] >= 0.0);
@@ -243,7 +243,7 @@ public:
// Monitor normalization
// No direct beam normalization
// No transmission correction
- // Processing instructions : 1
+ // Processing instructions : 2
// I0MonitorIndex: 0
// MonitorBackgroundWavelengthMin : 0.5
@@ -257,7 +257,7 @@ public:
std::fill(Y.begin(), Y.begin() + 2, 1.0);
ReflectometryReductionOne2 alg;
- setupAlgorithmMonitorCorrection(alg, 0.0, 15.0, "1", inputWS, true);
+ setupAlgorithmMonitorCorrection(alg, 0.0, 15.0, "2", inputWS, true);
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg, 16);
TS_ASSERT(outLam->x(0)[0] >= 0.0);
@@ -271,7 +271,7 @@ public:
// Transmission run is the same as input run
ReflectometryReductionOne2 alg;
- setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "1", m_multiDetectorWS,
+ setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "2", m_multiDetectorWS,
false);
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
@@ -284,7 +284,7 @@ public:
// Transmission run is the same as input run
ReflectometryReductionOne2 alg;
- setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "1", m_multiDetectorWS,
+ setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "2", m_multiDetectorWS,
true);
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
@@ -296,11 +296,10 @@ public:
void test_transmission_correction_with_mapped_spectra() {
// Run workspace spectrum numbers are 1,2,3,4.
// Transmission workspace has spectrum numbers 2,3,4,5.
- // Processing instructions 2-3 in the run workspace map to
- // spectra 3-4, which map to indices 1-2 in the transmission
- // workspace.
+ // Processing instructions 3-4 in the run workspace map to
+ // spectra 3-4.
ReflectometryReductionOne2 alg;
- setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "2-3",
+ setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "3-4",
m_transmissionWS, true);
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
@@ -311,35 +310,61 @@ public:
void test_transmission_correction_with_bad_mapped_spectra() {
// Run workspace spectrum numbers are 1,2,3,4.
// Transmission workspace has spectrum numbers 2,3,4,5.
- // Processing instructions 0 in the run workspace maps to
+ // Processing instructions 1 in the run workspace maps to
// spectrum 1, which doesn't exist in the transmission
// workspace.
ReflectometryReductionOne2 alg;
- setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "0", m_transmissionWS,
+ setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "1", m_transmissionWS,
true);
TS_ASSERT_THROWS_ANYTHING(alg.execute());
}
- void test_transmission_correction_with_different_spectra() {
- // Run workspace spectrum numbers are 1,2,3,4. Transmission workspace has
- // spectrum numbers 2,3,4,5. Processing instructions 2,3 are used in the
- // run and transmission workspaces without any mapping i.e. spectra 3-4 in
- // the run and spectra 4-5 in the transmission workspace are used.
+ void test_transmission_processing_instructions() {
ReflectometryReductionOne2 alg;
- setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "2-3",
- m_transmissionWS, true);
- alg.setProperty("StrictSpectrumChecking", "0");
+ setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "3-4",
+ m_transmissionWS, false);
+ alg.setPropertyValue("TransmissionProcessingInstructions", "3-4");
+ MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
+
+ TS_ASSERT_DELTA(outLam->y(0)[0], 0.0807, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 0.0802, 0.0001);
+ }
+
+ void test_transmission_processing_instructions_with_bad_instructions() {
+ ReflectometryReductionOne2 alg;
+ setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "1-2",
+ m_transmissionWS, false);
+ alg.setPropertyValue("TransmissionProcessingInstructions", "1");
+ TS_ASSERT_THROWS_ANYTHING(alg.execute());
+ }
+
+ void test_transmission_processing_instructions_that_are_different() {
+ ReflectometryReductionOne2 alg;
+ setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "3-4",
+ m_transmissionWS, false);
+ alg.setPropertyValue("TransmissionProcessingInstructions", "3");
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
- TS_ASSERT_DELTA(outLam->y(0)[0], 0.0571, 0.0001);
- TS_ASSERT_DELTA(outLam->y(0)[7], 0.0571, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[0], 0.2029, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 0.2009, 0.0001);
+ }
+
+ void test_transmission_processing_instructions_two_runs() {
+ ReflectometryReductionOne2 alg;
+ setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "3", m_transmissionWS,
+ true);
+ alg.setPropertyValue("TransmissionProcessingInstructions", "3");
+ MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
+
+ TS_ASSERT_DELTA(outLam->y(0)[0], 0.1009, 0.0001);
+ TS_ASSERT_DELTA(outLam->y(0)[7], 0.1003, 0.0001);
}
void test_exponential_correction() {
// CorrectionAlgorithm: ExponentialCorrection
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "2");
+ setupAlgorithm(alg, 1.5, 15.0, "3");
alg.setProperty("CorrectionAlgorithm", "ExponentialCorrection");
alg.setProperty("C0", 0.2);
alg.setProperty("C1", 0.1);
@@ -353,7 +378,7 @@ public:
// CorrectionAlgorithm: PolynomialCorrection
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "2");
+ setupAlgorithm(alg, 1.5, 15.0, "3");
alg.setProperty("CorrectionAlgorithm", "PolynomialCorrection");
alg.setProperty("Polynomial", "0.1,0.3,0.5");
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg);
@@ -370,7 +395,7 @@ public:
// Processing instructions : 2
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "2");
+ setupAlgorithm(alg, 1.5, 15.0, "3");
MatrixWorkspace_sptr outQ = runAlgorithmQ(alg);
// X range in outQ
@@ -386,10 +411,10 @@ public:
// No monitor normalization
// No direct beam normalization
// No transmission correction
- // Processing instructions : 2,1+3 (two separate groups)
+ // Processing instructions : 3,2+4 (two separate groups)
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "2,1+3");
+ setupAlgorithm(alg, 1.5, 15.0, "3,2+4");
// Run the algorithm. There should be 2 output histograms, one for each
// input group. Note that the group order is swapped from the input order
// because they are sorted by the first spectrum number in the group,
@@ -417,7 +442,7 @@ public:
// ReductionType : not set (invalid)
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "1");
+ setupAlgorithm(alg, 1.5, 15.0, "2");
alg.setProperty("SummationType", "SumInQ");
TS_ASSERT_THROWS_ANYTHING(alg.execute());
}
@@ -430,7 +455,7 @@ public:
// SummationType : SumInQ
// ReductionType : DivergentBeam
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "1");
+ setupAlgorithm(alg, 1.5, 15.0, "2");
alg.setProperty("SummationType", "SumInQ");
alg.setProperty("ReductionType", "DivergentBeam");
alg.setProperty("ThetaIn", 25.0);
@@ -453,7 +478,7 @@ public:
// ReductionType : NonFlatSample
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "1");
+ setupAlgorithm(alg, 1.5, 15.0, "2");
alg.setProperty("SummationType", "SumInQ");
alg.setProperty("ReductionType", "NonFlatSample");
MatrixWorkspace_sptr outLam = runAlgorithmLam(alg, 10);
@@ -471,7 +496,7 @@ public:
// Monitor normalization
// No direct beam normalization
// No transmission correction
- // Processing instructions : 2
+ // Processing instructions : 3
// SummationType : SumInQ
// ReductionType : DivergentBeam
@@ -487,7 +512,7 @@ public:
std::fill(Y.begin(), Y.begin() + 2, 1.0);
ReflectometryReductionOne2 alg;
- setupAlgorithmMonitorCorrection(alg, 0.0, 15.0, "2", inputWS, false);
+ setupAlgorithmMonitorCorrection(alg, 0.0, 15.0, "3", inputWS, false);
alg.setProperty("SummationType", "SumInQ");
alg.setProperty("ReductionType", "DivergentBeam");
alg.setProperty("ThetaIn", 25.0);
@@ -505,7 +530,7 @@ public:
// Transmission run is the same as input run
ReflectometryReductionOne2 alg;
- setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "1", m_multiDetectorWS,
+ setupAlgorithmTransmissionCorrection(alg, 1.5, 15.0, "2", m_multiDetectorWS,
false);
alg.setProperty("SummationType", "SumInQ");
alg.setProperty("ReductionType", "DivergentBeam");
@@ -524,7 +549,7 @@ public:
// CorrectionAlgorithm: ExponentialCorrection
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "2");
+ setupAlgorithm(alg, 1.5, 15.0, "3");
alg.setProperty("SummationType", "SumInQ");
alg.setProperty("ReductionType", "DivergentBeam");
alg.setProperty("ThetaIn", 25.0);
@@ -546,10 +571,10 @@ public:
// No monitor normalization
// No direct beam normalization
// No transmission correction
- // Processing instructions : 2
+ // Processing instructions : 3
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "2");
+ setupAlgorithm(alg, 1.5, 15.0, "3");
alg.setProperty("SummationType", "SumInQ");
alg.setProperty("ReductionType", "DivergentBeam");
alg.setProperty("ThetaIn", 25.0);
@@ -570,10 +595,10 @@ public:
// No monitor normalization
// No direct beam normalization
// No transmission correction
- // Processing instructions : 0
+ // Processing instructions : 1
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "0");
+ setupAlgorithm(alg, 1.5, 15.0, "1");
alg.setProperty("InputWorkspace", m_singleDetectorWS);
alg.setProperty("SummationType", "SumInQ");
alg.setProperty("ReductionType", "DivergentBeam");
@@ -593,7 +618,7 @@ public:
void test_sum_in_q_exclude_partial_bins() {
// Sum in Q, single detector
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "1");
+ setupAlgorithm(alg, 1.5, 15.0, "2");
alg.setProperty("SummationType", "SumInQ");
alg.setProperty("ReductionType", "DivergentBeam");
alg.setProperty("ThetaIn", 25.0);
@@ -611,7 +636,7 @@ public:
void test_sum_in_q_exclude_partial_bins_multiple_detectors() {
// Sum in Q, multiple detectors in group
ReflectometryReductionOne2 alg;
- setupAlgorithm(alg, 1.5, 15.0, "1-3");
+ setupAlgorithm(alg, 1.5, 15.0, "2-4");
alg.setProperty("SummationType", "SumInQ");
alg.setProperty("ReductionType", "DivergentBeam");
alg.setProperty("ThetaIn", 25.0);
@@ -638,7 +663,7 @@ public:
alg.setProperty("InputWorkspace", inputWS);
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
- alg.setPropertyValue("ProcessingInstructions", "1+2");
+ alg.setPropertyValue("ProcessingInstructions", "2+3");
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
@@ -682,7 +707,7 @@ public:
alg.setProperty("InputWorkspace", inputWS);
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
- alg.setPropertyValue("ProcessingInstructions", "2");
+ alg.setPropertyValue("ProcessingInstructions", "3");
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
@@ -721,7 +746,7 @@ public:
alg.setProperty("InputWorkspace", m_multiDetectorWS);
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
- alg.setPropertyValue("ProcessingInstructions", "1+2, 3");
+ alg.setPropertyValue("ProcessingInstructions", "2+3, 4");
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
alg.setProperty("ThetaIn", 22.0);
@@ -738,7 +763,7 @@ public:
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("Debug", false);
- alg.setPropertyValue("ProcessingInstructions", "1+2");
+ alg.setPropertyValue("ProcessingInstructions", "2+3");
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.execute();
@@ -759,7 +784,7 @@ public:
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("Debug", false);
- alg.setPropertyValue("ProcessingInstructions", "1+2");
+ alg.setPropertyValue("ProcessingInstructions", "2+3");
alg.execute();
TS_ASSERT(AnalysisDataService::Instance().doesExist("IvsQ"));
@@ -779,7 +804,7 @@ public:
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("Debug", true);
- alg.setPropertyValue("ProcessingInstructions", "1+2");
+ alg.setPropertyValue("ProcessingInstructions", "2+3");
alg.execute();
TS_ASSERT(AnalysisDataService::Instance().doesExist("IvsQ"));
@@ -800,7 +825,7 @@ public:
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("Debug", true);
- alg.setPropertyValue("ProcessingInstructions", "1+2");
+ alg.setPropertyValue("ProcessingInstructions", "2+3");
alg.execute();
TS_ASSERT(AnalysisDataService::Instance().doesExist("IvsQ_1234"));
diff --git a/Framework/Algorithms/test/ReflectometryReductionOneAuto2Test.h b/Framework/Algorithms/test/ReflectometryReductionOneAuto2Test.h
index 1283a17d122f4c0136070947d39011ce054de290..df6eb8e43654e6d6a90a318e935f7aab8d6e541b 100644
--- a/Framework/Algorithms/test/ReflectometryReductionOneAuto2Test.h
+++ b/Framework/Algorithms/test/ReflectometryReductionOneAuto2Test.h
@@ -70,7 +70,7 @@ private:
alg.setProperty("InputWorkspace", inter);
alg.setProperty("ThetaIn", theta);
alg.setProperty("CorrectionAlgorithm", "None");
- alg.setProperty("ProcessingInstructions", "3");
+ alg.setProperty("ProcessingInstructions", "4");
alg.setProperty("Debug", false);
}
@@ -109,7 +109,7 @@ public:
alg.setProperty("InputWorkspace", m_notTOF);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "0");
+ alg.setProperty("ProcessingInstructions", "1");
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceBinned", "IvsQ_binned");
alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
@@ -123,7 +123,7 @@ public:
alg.setProperty("InputWorkspace", m_TOF);
alg.setProperty("WavelengthMin", 15.0);
alg.setProperty("WavelengthMax", 1.0);
- alg.setProperty("ProcessingInstructions", "0");
+ alg.setProperty("ProcessingInstructions", "1");
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceBinned", "IvsQ_binned");
alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
@@ -137,7 +137,7 @@ public:
alg.setProperty("InputWorkspace", m_TOF);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "0");
+ alg.setProperty("ProcessingInstructions", "1");
alg.setProperty("MonitorBackgroundWavelengthMin", 3.0);
alg.setProperty("MonitorBackgroundWavelengthMax", 0.5);
alg.setPropertyValue("OutputWorkspace", "IvsQ");
@@ -153,7 +153,7 @@ public:
alg.setProperty("InputWorkspace", m_TOF);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "0");
+ alg.setProperty("ProcessingInstructions", "1");
alg.setProperty("MonitorIntegrationWavelengthMin", 15.0);
alg.setProperty("MonitorIntegrationWavelengthMax", 1.5);
alg.setPropertyValue("OutputWorkspace", "IvsQ");
@@ -170,7 +170,7 @@ public:
alg.setProperty("FirstTransmissionRun", m_notTOF);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "0");
+ alg.setProperty("ProcessingInstructions", "1");
alg.setProperty("MonitorIntegrationWavelengthMin", 1.0);
alg.setProperty("MonitorIntegrationWavelengthMax", 15.0);
alg.setPropertyValue("OutputWorkspace", "IvsQ");
@@ -272,7 +272,7 @@ public:
alg.setProperty("OutputWorkspace", "IvsQ");
alg.setProperty("OutputWorkspaceBinned", "IvsQ_binned");
alg.setProperty("OutputWorkspaceWavelength", "IvsLam");
- alg.setProperty("ProcessingInstructions", "3");
+ alg.setProperty("ProcessingInstructions", "4");
alg.execute();
MatrixWorkspace_sptr out = alg.getProperty("OutputWorkspaceBinned");
@@ -418,7 +418,7 @@ public:
alg.setProperty("OutputWorkspace", "IvsQ");
alg.setProperty("OutputWorkspaceBinned", "IvsQ_binned");
alg.setProperty("OutputWorkspaceWavelength", "IvsLam");
- alg.setProperty("ProcessingInstructions", "3");
+ alg.setProperty("ProcessingInstructions", "4");
alg.execute();
MatrixWorkspace_sptr corrected = alg.getProperty("OutputWorkspace");
@@ -463,7 +463,7 @@ public:
alg.setProperty("OutputWorkspace", "IvsQ");
alg.setProperty("OutputWorkspaceBinned", "IvsQ_binned");
alg.setProperty("OutputWorkspaceWavelength", "IvsLam");
- alg.setProperty("ProcessingInstructions", "3");
+ alg.setProperty("ProcessingInstructions", "4");
alg.execute();
MatrixWorkspace_sptr corrected = alg.getProperty("OutputWorkspace");
@@ -487,7 +487,7 @@ public:
alg.setProperty("InputWorkspace", m_TOF);
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferMin", 1.0);
alg.setProperty("MomentumTransferMax", 10.0);
alg.setProperty("MomentumTransferStep", -0.04);
@@ -520,7 +520,7 @@ public:
alg.setProperty("InputWorkspace", m_TOF);
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferMin", 1.0);
alg.setProperty("MomentumTransferMax", 10.0);
alg.setProperty("MomentumTransferStep", 0.04);
@@ -544,7 +544,7 @@ public:
alg.setProperty("InputWorkspace", m_TOF);
alg.setProperty("WavelengthMin", 1.5);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "2");
+ alg.setProperty("ProcessingInstructions", "3");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceBinned", "IvsQ_binned");
@@ -573,7 +573,7 @@ public:
alg.setProperty("InputWorkspace", inter);
alg.setProperty("ThetaIn", theta);
alg.setProperty("CorrectionAlgorithm", "None");
- alg.setProperty("ProcessingInstructions", "3");
+ alg.setProperty("ProcessingInstructions", "4");
alg.execute();
TS_ASSERT(AnalysisDataService::Instance().doesExist("IvsQ_binned_13460"));
@@ -593,7 +593,7 @@ public:
alg.setProperty("InputWorkspace", inter);
alg.setProperty("ThetaIn", theta);
alg.setProperty("CorrectionAlgorithm", "None");
- alg.setProperty("ProcessingInstructions", "3");
+ alg.setProperty("ProcessingInstructions", "4");
alg.setProperty("OutputWorkspaceBinned", "IvsQ_binned");
alg.execute();
@@ -615,7 +615,7 @@ public:
alg.setProperty("InputWorkspace", inter);
alg.setProperty("ThetaIn", theta);
alg.setProperty("CorrectionAlgorithm", "None");
- alg.setProperty("ProcessingInstructions", "3");
+ alg.setProperty("ProcessingInstructions", "4");
alg.setProperty("OutputWorkspaceBinned", "IvsQ_binned");
alg.setProperty("OutputWorkspace", "IvsQ");
alg.setProperty("OutputWorkspaceWavelength", "IvsLam");
@@ -638,7 +638,7 @@ public:
alg.setProperty("InputWorkspace", inter);
alg.setProperty("ThetaIn", theta);
alg.setProperty("CorrectionAlgorithm", "None");
- alg.setProperty("ProcessingInstructions", "3");
+ alg.setProperty("ProcessingInstructions", "4");
alg.setProperty("Debug", true);
alg.execute();
@@ -659,7 +659,7 @@ public:
alg.setProperty("InputWorkspace", inter);
alg.setProperty("ThetaIn", theta);
alg.setProperty("CorrectionAlgorithm", "None");
- alg.setProperty("ProcessingInstructions", "3");
+ alg.setProperty("ProcessingInstructions", "4");
alg.setProperty("Debug", false);
alg.execute();
@@ -681,7 +681,7 @@ public:
alg.setProperty("InputWorkspace", inter);
alg.setProperty("ThetaIn", theta);
alg.setProperty("CorrectionAlgorithm", "None");
- alg.setProperty("ProcessingInstructions", "3");
+ alg.setProperty("ProcessingInstructions", "4");
alg.setProperty("Debug", true);
alg.execute();
@@ -703,7 +703,7 @@ public:
alg.setProperty("InputWorkspace", inter);
alg.setProperty("ThetaIn", theta);
alg.setProperty("CorrectionAlgorithm", "None");
- alg.setProperty("ProcessingInstructions", "3");
+ alg.setProperty("ProcessingInstructions", "4");
alg.setProperty("Debug", false);
alg.execute();
@@ -725,7 +725,7 @@ public:
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("ThetaIn", 10.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setProperty("PolarizationAnalysis", "PA");
alg.setProperty("Pp", "0.9,0,0");
@@ -773,7 +773,7 @@ public:
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("ThetaIn", 10.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setProperty("PolarizationAnalysis", "PNR");
alg.setProperty("Pp", "1,1,2");
@@ -798,7 +798,7 @@ public:
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("ThetaIn", 10.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setProperty("PolarizationAnalysis", "PNR");
alg.setProperty("Pp", "1,1,2");
@@ -841,7 +841,7 @@ public:
alg.setProperty("ThetaIn", 10.0);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setProperty("PolarizationAnalysis", "ParameterFile");
alg.setPropertyValue("OutputWorkspace", "IvsQ");
@@ -909,7 +909,7 @@ public:
alg.setProperty("WavelengthMin", 0.0000000001);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("ThetaIn", 10.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceBinned", "IvsQ_binned");
@@ -973,7 +973,7 @@ public:
alg.setProperty("WavelengthMin", 0.0000000001);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("ThetaIn", 10.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setProperty("PolarizationAnalysis", "PNR");
alg.setProperty("Pp", "1");
@@ -1047,7 +1047,7 @@ public:
alg.setProperty("WavelengthMin", 0.0000000001);
alg.setProperty("WavelengthMax", 15.0);
alg.setProperty("ThetaIn", 10.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceBinned", "IvsQ_binned");
@@ -1086,7 +1086,7 @@ public:
alg.setProperty("ThetaIn", 10.0);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setProperty("PolarizationAnalysis", "ParameterFile");
alg.setPropertyValue("OutputWorkspace", "IvsQ");
@@ -1130,15 +1130,16 @@ public:
alg.setPropertyValue("InputWorkspace", name);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 5.0);
- alg.setProperty("ProcessingInstructions", "0");
+ alg.setProperty("ProcessingInstructions", "1");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setProperty("PolarizationAnalysis", "ParameterFile");
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceBinned", "IvsQ_binned");
alg.setPropertyValue("OutputWorkspaceWavelength", "IvsLam");
- TS_ASSERT_THROWS_EQUALS(
- alg.execute(), std::invalid_argument & e, std::string(e.what()),
- "A detector is expected at spectrum 0, found a monitor");
+ TS_ASSERT_THROWS_EQUALS(alg.execute(), std::invalid_argument & e,
+ std::string(e.what()),
+ "A detector is expected at workspace index 0 (Was "
+ "converted from specnum), found a monitor");
}
void test_I0MonitorIndex_is_detector() {
@@ -1154,7 +1155,7 @@ public:
alg.setProperty("MonitorBackgroundWavelengthMin", 1.0);
alg.setProperty("MonitorBackgroundWavelengthMax", 5.0);
alg.setPropertyValue("I0MonitorIndex", "1");
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceBinned", "IvsQ_binned");
@@ -1360,7 +1361,7 @@ public:
alg.setProperty("MomentumTransferStep", 0.01);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "1+2");
+ alg.setProperty("ProcessingInstructions", "2+3");
alg.execute();
MatrixWorkspace_sptr out = alg.getProperty("OutputWorkspace");
TS_ASSERT_DELTA(out->y(0)[0], 4.5, 0.000001);
@@ -1390,7 +1391,7 @@ public:
alg.setProperty("MomentumTransferStep", 0.01);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "1+2");
+ alg.setProperty("ProcessingInstructions", "2+3");
alg.setProperty("FirstTransmissionRun", transWS);
alg.execute();
MatrixWorkspace_sptr out = alg.getProperty("OutputWorkspace");
@@ -1422,7 +1423,7 @@ public:
alg.setProperty("MomentumTransferStep", 0.01);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "1+2");
+ alg.setProperty("ProcessingInstructions", "2+3");
alg.setProperty("OutputWorkspaceWavelength", "IvsLam");
alg.setProperty("OutputWorkspace", "IvsQ");
alg.setProperty("OutputWorkspaceBinned", "IvsQb");
@@ -1450,7 +1451,7 @@ public:
alg.setProperty("ThetaIn", 10.0);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setProperty("PolarizationAnalysis", "ParameterFile");
alg.setPropertyValue("OutputWorkspace", "IvsQ");
@@ -1485,7 +1486,7 @@ public:
alg.setProperty("ThetaIn", 10.0);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceBinned", "IvsQ_binned");
@@ -1520,7 +1521,7 @@ public:
alg.setProperty("ThetaIn", 10.0);
alg.setProperty("WavelengthMin", 1.0);
alg.setProperty("WavelengthMax", 15.0);
- alg.setProperty("ProcessingInstructions", "1");
+ alg.setProperty("ProcessingInstructions", "2");
alg.setProperty("MomentumTransferStep", 0.04);
alg.setPropertyValue("OutputWorkspace", "IvsQ");
alg.setPropertyValue("OutputWorkspaceBinned", "IvsQ_binned");
diff --git a/Framework/Algorithms/test/SpecularReflectionPositionCorrect2Test.h b/Framework/Algorithms/test/SpecularReflectionPositionCorrect2Test.h
index 4c34c2108e8b2f13583da07298baaa579c95472e..4b69ef0bec0f13f13e80a74d08ebf62e3d16a883 100644
--- a/Framework/Algorithms/test/SpecularReflectionPositionCorrect2Test.h
+++ b/Framework/Algorithms/test/SpecularReflectionPositionCorrect2Test.h
@@ -9,8 +9,10 @@
#include "MantidAPI/AlgorithmManager.h"
#include "MantidAPI/FrameworkManager.h"
+#include "MantidAPI/SpectrumInfo.h"
#include "MantidAlgorithms/SpecularReflectionPositionCorrect2.h"
#include "MantidGeometry/Instrument.h"
+#include "MantidGeometry/Instrument/ReferenceFrame.h"
#include "MantidTestHelpers/WorkspaceCreationHelper.h"
#include <cxxtest/TestSuite.h>
@@ -21,16 +23,21 @@ using namespace Mantid::Geometry;
class SpecularReflectionPositionCorrect2Test : public CxxTest::TestSuite {
private:
+ MatrixWorkspace_sptr m_d17WS;
+ MatrixWorkspace_sptr m_figaroWS;
MatrixWorkspace_sptr m_interWS;
// Initialise the algorithm and set the properties
- void setupAlgorithm(SpecularReflectionPositionCorrect2 &alg,
- const double twoTheta, const std::string &correctionType,
- const std::string &detectorName, int detectorID = 0) {
+ static void setupAlgorithm(SpecularReflectionPositionCorrect2 &alg,
+ MatrixWorkspace_sptr &inWS, const double twoTheta,
+ const std::string &correctionType,
+ const std::string &detectorName,
+ int detectorID = 0) {
if (!alg.isInitialized())
alg.initialize();
alg.setChild(true);
- alg.setProperty("InputWorkspace", m_interWS);
+ alg.setRethrows(true);
+ alg.setProperty("InputWorkspace", inWS);
alg.setProperty("TwoTheta", twoTheta);
if (!correctionType.empty())
alg.setProperty("DetectorCorrectionType", correctionType);
@@ -42,7 +49,7 @@ private:
}
// Run the algorithm and do some basic checks. Returns the output workspace.
- MatrixWorkspace_const_sptr
+ static MatrixWorkspace_const_sptr
runAlgorithm(SpecularReflectionPositionCorrect2 &alg) {
TS_ASSERT_THROWS_NOTHING(alg.execute());
MatrixWorkspace_sptr outWS = alg.getProperty("OutputWorkspace");
@@ -50,6 +57,61 @@ private:
return outWS;
}
+ static void linearDetectorRotationWithFacing(MatrixWorkspace_sptr &inWS,
+ const double twoTheta) {
+ SpecularReflectionPositionCorrect2 alg;
+ setupAlgorithm(alg, inWS, twoTheta, "RotateAroundSample", "detector");
+ alg.setProperty("DetectorFacesSample", true);
+ auto outWS = runAlgorithm(alg);
+ const auto &spectrumInfoOut = outWS->spectrumInfo();
+ const auto nHisto = spectrumInfoOut.size();
+ TS_ASSERT_DELTA(spectrumInfoOut.l2(0), spectrumInfoOut.l2(nHisto - 1),
+ 1e-10)
+ auto instrIn = inWS->getInstrument();
+ auto detIn = instrIn->getComponentByName("detector");
+ const auto posIn = detIn->getPos();
+ const auto l2 = posIn.norm();
+ auto instrOut = outWS->getInstrument();
+ auto detOut = instrOut->getComponentByName("detector");
+ const auto posOut = detOut->getPos();
+ TS_ASSERT_DELTA(posOut.norm(), l2, 1e-10)
+ const auto thetaSignDir = instrIn->getReferenceFrame()->vecThetaSign();
+ const auto horizontal = thetaSignDir.X() != 0. ? true : false;
+ const auto a = l2 * std::sin(twoTheta * M_PI / 180);
+ const auto x = horizontal ? a : 0.;
+ const auto y = horizontal ? 0. : a;
+ const auto z = l2 * std::cos(twoTheta * M_PI / 180);
+ TS_ASSERT_DELTA(posOut.X(), x, 1e-10)
+ TS_ASSERT_DELTA(posOut.Y(), y, 1e-10)
+ TS_ASSERT_DELTA(posOut.Z(), z, 1e-10)
+ }
+
+ static void linearDetectorRotationWithFacingAndLinePosition(
+ MatrixWorkspace_sptr &inWS, const double twoTheta, const double linePos,
+ const double pixelSize) {
+ SpecularReflectionPositionCorrect2 alg;
+ setupAlgorithm(alg, inWS, twoTheta, "RotateAroundSample", "detector");
+ alg.setProperty("DetectorFacesSample", true);
+ alg.setProperty("LinePosition", linePos);
+ alg.setProperty("PixelSize", pixelSize);
+ auto outWS = runAlgorithm(alg);
+ const auto &spectrumInfoOut = outWS->spectrumInfo();
+ const auto nHisto = spectrumInfoOut.size();
+ TS_ASSERT_DELTA(spectrumInfoOut.l2(0), spectrumInfoOut.l2(nHisto - 1),
+ 1e-10)
+ auto instrIn = inWS->getInstrument();
+ auto detIn = instrIn->getComponentByName("detector");
+ const auto posIn = detIn->getPos();
+ const auto l2 = posIn.norm();
+ auto instrOut = outWS->getInstrument();
+ auto detOut = instrOut->getComponentByName("detector");
+ const auto posOut = detOut->getPos();
+ TS_ASSERT_DELTA(posOut.norm(), l2, 1e-10)
+ const auto lineTwoTheta =
+ spectrumInfoOut.twoTheta(static_cast<size_t>(linePos));
+ TS_ASSERT_DELTA(lineTwoTheta * 180. / M_PI, twoTheta, 1e-10)
+ }
+
public:
// This pair of boilerplate methods prevent the suite being created statically
// This means the constructor isn't called when running other tests
@@ -66,8 +128,27 @@ public:
auto load = AlgorithmManager::Instance().create("LoadEmptyInstrument");
load->initialize();
load->setChild(true);
+ load->setProperty("InstrumentName", "D17");
+ load->setPropertyValue("OutputWorkspace", "out");
+ load->execute();
+ m_d17WS = load->getProperty("OutputWorkspace");
+ // Crop monitors.
+ auto crop = AlgorithmManager::Instance().create("CropWorkspace");
+ crop->setChild(true);
+ crop->setProperty("InputWorkspace", m_d17WS);
+ crop->setPropertyValue("OutputWorkspace", "out");
+ crop->setProperty("StartWorkspaceIndex", 0);
+ crop->setProperty("EndWorkspaceIndex", 255);
+ crop->execute();
+ m_d17WS = crop->getProperty("OutputWorkspace");
+ load->setProperty("InstrumentName", "Figaro");
+ load->execute();
+ m_figaroWS = load->getProperty("OutputWorkspace");
+ crop->setProperty("InputWorkspace", m_figaroWS);
+ crop->setPropertyValue("OutputWorkspace", "out");
+ crop->execute();
+ m_figaroWS = crop->getProperty("OutputWorkspace");
load->setProperty("InstrumentName", "INTER");
- load->setPropertyValue("OutputWorkspace", "inter");
load->execute();
m_interWS = load->getProperty("OutputWorkspace");
}
@@ -78,28 +159,6 @@ public:
TS_ASSERT(alg.isInitialized())
}
- void test_theta_is_mandatory() {
- SpecularReflectionPositionCorrect2 alg;
- alg.initialize();
- alg.setChild(true);
- alg.setProperty("InputWorkspace", m_interWS);
- alg.setProperty("DetectorComponentName", "point-detector");
- alg.setPropertyValue("OutputWorkspace", "test_out");
- TS_ASSERT_THROWS(alg.execute(), std::runtime_error &);
- }
-
- void test_theta_bad_value() {
- SpecularReflectionPositionCorrect2 alg;
- alg.initialize();
- alg.setChild(true);
- alg.setProperty("InputWorkspace", m_interWS);
- alg.setProperty("DetectorComponentName", "point-detector");
- alg.setPropertyValue("OutputWorkspace", "test_out");
- TS_ASSERT_THROWS(alg.setProperty("TwoTheta", 0.0), std::invalid_argument &);
- TS_ASSERT_THROWS(alg.setProperty("TwoTheta", 90.0),
- std::invalid_argument &);
- }
-
void test_detector_component_is_mandatory() {
SpecularReflectionPositionCorrect2 alg;
alg.initialize();
@@ -110,7 +169,7 @@ public:
TS_ASSERT_THROWS_ANYTHING(alg.execute());
}
- void test_detector_component_is_valid() {
+ void test_detector_id_is_valid() {
SpecularReflectionPositionCorrect2 alg;
alg.initialize();
alg.setChild(true);
@@ -121,7 +180,7 @@ public:
TS_ASSERT_THROWS_ANYTHING(alg.execute());
}
- void test_detector_id_is_valid() {
+ void test_detector_name_is_valid() {
SpecularReflectionPositionCorrect2 alg;
alg.initialize();
alg.setChild(true);
@@ -132,23 +191,11 @@ public:
TS_ASSERT_THROWS_ANYTHING(alg.execute());
}
- void test_sample_component_is_valid() {
- SpecularReflectionPositionCorrect2 alg;
- alg.initialize();
- alg.setChild(true);
- alg.setProperty("InputWorkspace", m_interWS);
- alg.setProperty("DetectorComponentName", "point-detector");
- alg.setProperty("SampleComponentName", "invalid-sample-name");
- alg.setProperty("TwoTheta", 1.4);
- alg.setPropertyValue("OutputWorkspace", "test_out");
- TS_ASSERT_THROWS_ANYTHING(alg.execute());
- }
-
void test_correct_point_detector_vertical_shift_default() {
// Omit the DetectorCorrectionType property to check that a vertical shift
// is done by default
SpecularReflectionPositionCorrect2 alg;
- setupAlgorithm(alg, 1.4, "", "point-detector");
+ setupAlgorithm(alg, m_interWS, 1.4, "", "point-detector");
MatrixWorkspace_const_sptr outWS = runAlgorithm(alg);
auto instrIn = m_interWS->getInstrument();
@@ -170,7 +217,7 @@ public:
// Omit the DetectorCorrectionType property to check that a vertical shift
// is done by default
SpecularReflectionPositionCorrect2 alg;
- setupAlgorithm(alg, 1.4, "", "", 4);
+ setupAlgorithm(alg, m_interWS, 1.4, "", "", 4);
MatrixWorkspace_const_sptr outWS = runAlgorithm(alg);
auto instrIn = m_interWS->getInstrument();
@@ -190,7 +237,7 @@ public:
void test_correct_point_detector_rotation() {
SpecularReflectionPositionCorrect2 alg;
- setupAlgorithm(alg, 1.4, "RotateAroundSample", "point-detector");
+ setupAlgorithm(alg, m_interWS, 1.4, "RotateAroundSample", "point-detector");
MatrixWorkspace_const_sptr outWS = runAlgorithm(alg);
auto instrIn = m_interWS->getInstrument();
@@ -211,7 +258,7 @@ public:
void test_correct_point_detector_by_detid_rotation() {
SpecularReflectionPositionCorrect2 alg;
- setupAlgorithm(alg, 1.4, "RotateAroundSample", "", 4);
+ setupAlgorithm(alg, m_interWS, 1.4, "RotateAroundSample", "", 4);
MatrixWorkspace_const_sptr outWS = runAlgorithm(alg);
auto instrIn = m_interWS->getInstrument();
@@ -232,7 +279,7 @@ public:
void test_correct_linear_detector_vertical_shift() {
SpecularReflectionPositionCorrect2 alg;
- setupAlgorithm(alg, 1.4, "VerticalShift", "linear-detector");
+ setupAlgorithm(alg, m_interWS, 1.4, "VerticalShift", "linear-detector");
MatrixWorkspace_const_sptr outWS = runAlgorithm(alg);
auto instrIn = m_interWS->getInstrument();
@@ -252,7 +299,8 @@ public:
void test_correct_linear_detector_rotation() {
SpecularReflectionPositionCorrect2 alg;
- setupAlgorithm(alg, 1.4, "RotateAroundSample", "linear-detector");
+ setupAlgorithm(alg, m_interWS, 1.4, "RotateAroundSample",
+ "linear-detector");
MatrixWorkspace_const_sptr outWS = runAlgorithm(alg);
auto instrIn = m_interWS->getInstrument();
@@ -270,6 +318,67 @@ public:
TS_ASSERT_DELTA(detOut.Z(), 3.162055, 1e-5);
TS_ASSERT_DELTA(detOut.Y(), 0.07728, 1e-5);
}
+
+ void test_correct_horizontal_linear_detector_rotation_with_facing() {
+ constexpr double twoTheta{1.4};
+ linearDetectorRotationWithFacing(m_d17WS, twoTheta);
+ linearDetectorRotationWithFacing(m_d17WS, -twoTheta);
+ }
+
+ void test_correct_vertical_linear_detector_rotation_with_facing() {
+ constexpr double twoTheta{1.4};
+ linearDetectorRotationWithFacing(m_figaroWS, twoTheta);
+ linearDetectorRotationWithFacing(m_figaroWS, -twoTheta);
+ }
+
+ void test_correct_rotation_with_line_position() {
+ constexpr double twoTheta{1.4};
+ constexpr double linePos{13.};
+ constexpr double pixelSize{0.0012};
+ linearDetectorRotationWithFacingAndLinePosition(m_figaroWS, twoTheta,
+ linePos, pixelSize);
+ }
+
+ void test_correct_rotation_with_line_position_when_wsindices_run_like_d17() {
+ constexpr double twoTheta{1.4};
+ constexpr double linePos{189.};
+ constexpr double pixelSize{0.001195};
+ linearDetectorRotationWithFacingAndLinePosition(m_d17WS, twoTheta, linePos,
+ pixelSize);
+ }
+
+ void test_correct_direct_beam_calibration() {
+ constexpr double directLinePos{202};
+ SpecularReflectionPositionCorrect2 alg;
+ alg.initialize();
+ alg.setChild(true);
+ alg.setRethrows(true);
+ alg.setProperty("InputWorkspace", m_d17WS);
+ alg.setProperty("DetectorCorrectionType", "RotateAroundSample");
+ alg.setProperty("DetectorComponentName", "detector");
+ alg.setProperty("DetectorFacesSample", true);
+ alg.setProperty("DirectLinePosition", directLinePos);
+ alg.setProperty("PixelSize", 0.001195);
+ // Pretend the we have a separate direct beam workspace.
+ alg.setProperty("DirectLineWorkspace", m_d17WS);
+ alg.setPropertyValue("OutputWorkspace", "test_out");
+ TS_ASSERT_THROWS_NOTHING(alg.execute())
+ MatrixWorkspace_const_sptr outWS = alg.getProperty("OutputWorkspace");
+ TS_ASSERT(outWS);
+ const auto &spectrumInfoIn = m_d17WS->spectrumInfo();
+ const auto twoThetaIn =
+ spectrumInfoIn.twoTheta(static_cast<size_t>(directLinePos));
+ auto instrOut = outWS->getInstrument();
+ auto detOut = instrOut->getComponentByName("detector");
+ const auto posOut = detOut->getPos();
+ const auto l2 = posOut.norm();
+ const auto x = l2 * std::sin(twoThetaIn);
+ const auto y = 0.;
+ const auto z = l2 * std::cos(twoThetaIn);
+ TS_ASSERT_DELTA(posOut.X(), x, 1e-10)
+ TS_ASSERT_DELTA(posOut.Y(), y, 1e-10)
+ TS_ASSERT_DELTA(posOut.Z(), z, 1e-10)
+ }
};
#endif /* MANTID_ALGORITHMS_SPECULARREFLECTIONPOSITIONCORRECT2TEST_H_ */
diff --git a/Framework/DataHandling/src/MoveInstrumentComponent.cpp b/Framework/DataHandling/src/MoveInstrumentComponent.cpp
index 7ef36b5102b9775c04b7cd70a7c7fc82f577b5f6..66403a9c97eab4b856f5dca7fad0ecac105fd76c 100644
--- a/Framework/DataHandling/src/MoveInstrumentComponent.cpp
+++ b/Framework/DataHandling/src/MoveInstrumentComponent.cpp
@@ -8,6 +8,7 @@
#include "MantidDataObjects/PeaksWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
+#include "MantidGeometry/Instrument/ComponentInfoBankHelpers.h"
#include "MantidGeometry/Instrument/GridDetectorPixel.h"
#include "MantidKernel/Exception.h"
@@ -115,15 +116,10 @@ void MoveInstrumentComponent::exec() {
const auto &componentInfo =
inputW ? inputW->componentInfo() : inputP->componentInfo();
auto compIndex = componentInfo.indexOf(comp->getComponentID());
- auto parent = componentInfo.parent(compIndex);
- auto grandParent = componentInfo.parent(parent);
- auto grandParentType = componentInfo.componentType(grandParent);
- if (componentInfo.isDetector(compIndex) &&
- (grandParentType == Mantid::Beamline::ComponentType::Grid ||
- grandParentType == Mantid::Beamline::ComponentType::Rectangular ||
- grandParentType == Mantid::Beamline::ComponentType::Structured)) {
+ if (ComponentInfoBankHelpers::isDetectorFixedInBank(componentInfo,
+ compIndex)) {
// DetectorInfo makes changing positions possible but we keep the old
- // behavior of ignoring position changes for GridDetectorPixel.
+ // behavior of ignoring position changes for Structured banks.
g_log.warning("Component is fixed within a structured bank, moving is not "
"possible, doing nothing.");
return;
diff --git a/Framework/Geometry/CMakeLists.txt b/Framework/Geometry/CMakeLists.txt
index bb790d8264050377c082ac300fe88bbd1cbfefc6..df23d6fff779ad4bb640631186735bae866f2ee3 100644
--- a/Framework/Geometry/CMakeLists.txt
+++ b/Framework/Geometry/CMakeLists.txt
@@ -48,6 +48,7 @@ set ( SRC_FILES
src/Instrument/Component.cpp
src/Instrument/ComponentHelper.cpp
src/Instrument/ComponentInfo.cpp
+ src/Instrument/ComponentInfoBankHelpers.cpp
src/Instrument/Container.cpp
src/Instrument/Detector.cpp
src/Instrument/DetectorGroup.cpp
@@ -105,8 +106,9 @@ set ( SRC_FILES
src/Objects/BoundingBox.cpp
src/Objects/CSGObject.cpp
src/Objects/InstrumentRayTracer.cpp
- src/Objects/MeshObject2D.cpp
+ src/Objects/MeshObject2D.cpp
src/Objects/MeshObject.cpp
+ src/Objects/MeshObjectCommon.cpp
src/Objects/RuleItems.cpp
src/Objects/Rules.cpp
src/Objects/ShapeFactory.cpp
@@ -195,11 +197,14 @@ set ( INC_FILES
inc/MantidGeometry/Instrument/Component.h
inc/MantidGeometry/Instrument/ComponentHelper.h
inc/MantidGeometry/Instrument/ComponentInfo.h
+ inc/MantidGeometry/Instrument/ComponentInfoBankHelpers.h
inc/MantidGeometry/Instrument/ComponentVisitor.h
inc/MantidGeometry/Instrument/Container.h
inc/MantidGeometry/Instrument/Detector.h
inc/MantidGeometry/Instrument/DetectorGroup.h
inc/MantidGeometry/Instrument/DetectorInfo.h
+ inc/MantidGeometry/Instrument/DetectorInfoItem.h
+ inc/MantidGeometry/Instrument/DetectorInfoIterator.h
inc/MantidGeometry/Instrument/FitParameter.h
inc/MantidGeometry/Instrument/Goniometer.h
inc/MantidGeometry/Instrument/GridDetector.h
@@ -222,8 +227,6 @@ set ( INC_FILES
inc/MantidGeometry/Instrument/StructuredDetector.h
inc/MantidGeometry/Instrument/XMLInstrumentParameter.h
inc/MantidGeometry/Instrument_fwd.h
- inc/MantidGeometry/Instrument/DetectorInfoIterator.h
- inc/MantidGeometry/Instrument/DetectorInfoItem.h
inc/MantidGeometry/MDGeometry/CompositeImplicitFunction.h
inc/MantidGeometry/MDGeometry/GeneralFrame.h
inc/MantidGeometry/MDGeometry/HKL.h
@@ -265,6 +268,7 @@ set ( INC_FILES
inc/MantidGeometry/Objects/InstrumentRayTracer.h
inc/MantidGeometry/Objects/MeshObject.h
inc/MantidGeometry/Objects/MeshObject2D.h
+ inc/MantidGeometry/Objects/MeshObjectCommon.h
inc/MantidGeometry/Objects/Rules.h
inc/MantidGeometry/Objects/ShapeFactory.h
inc/MantidGeometry/Objects/Track.h
@@ -302,6 +306,7 @@ set ( TEST_FILES
CSGObjectTest.h
CenteringGroupTest.h
CompAssemblyTest.h
+ ComponentInfoBankHelpersTest.h
ComponentInfoTest.h
ComponentParserTest.h
ComponentTest.h
@@ -316,6 +321,7 @@ set ( TEST_FILES
CyclicGroupTest.h
CylinderTest.h
DetectorGroupTest.h
+ DetectorInfoIteratorTest.h
DetectorTest.h
FitParameterTest.h
GeneralFrameTest.h
@@ -352,7 +358,8 @@ set ( TEST_FILES
MathSupportTest.h
MatrixVectorPairParserTest.h
MatrixVectorPairTest.h
- MeshObject2DTest.h
+ MeshObject2DTest.h
+ MeshObjectCommonTest.h
MeshObjectTest.h
NiggliCellTest.h
NullImplicitFunctionTest.h
@@ -420,7 +427,6 @@ set ( TEST_FILES
UnitCellTest.h
V3RTest.h
XMLInstrumentParameterTest.h
- DetectorInfoIteratorTest.h
)
set ( GMOCK_TEST_FILES
diff --git a/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfoBankHelpers.h b/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfoBankHelpers.h
new file mode 100644
index 0000000000000000000000000000000000000000..49f6698bae8d0a227e4003539565c649cd847f89
--- /dev/null
+++ b/Framework/Geometry/inc/MantidGeometry/Instrument/ComponentInfoBankHelpers.h
@@ -0,0 +1,19 @@
+#ifndef MANTID_GEOMETRY_COMPONENTINFOBANKHELPERS_H_
+#define MANTID_GEOMETRY_COMPONENTINFOBANKHELPERS_H_
+
+#include "MantidGeometry/DllConfig.h"
+
+namespace Mantid {
+namespace Geometry {
+
+class ComponentInfo;
+namespace ComponentInfoBankHelpers {
+
+MANTID_GEOMETRY_DLL bool isDetectorFixedInBank(const ComponentInfo &compInfo,
+ const size_t detIndex);
+} // namespace ComponentInfoBankHelpers
+
+} // namespace Geometry
+} // namespace Mantid
+
+#endif /* MANTID_GEOMETRY_COMPONENTINFOBANKHELPERS_H_ */
\ No newline at end of file
diff --git a/Framework/Geometry/inc/MantidGeometry/Instrument/ReferenceFrame.h b/Framework/Geometry/inc/MantidGeometry/Instrument/ReferenceFrame.h
index 542887a18ef622f974dfaae96218b0295e323503..bedf6f495d0a7c7223a1617462ff686044ed90af 100644
--- a/Framework/Geometry/inc/MantidGeometry/Instrument/ReferenceFrame.h
+++ b/Framework/Geometry/inc/MantidGeometry/Instrument/ReferenceFrame.h
@@ -49,11 +49,13 @@ public:
/// Destructor
virtual ~ReferenceFrame() = default;
/// Convert up axis into a 3D direction
- const Mantid::Kernel::V3D vecPointingUp() const;
+ Mantid::Kernel::V3D vecPointingUp() const;
/// Convert along beam axis into a 3D direction
- const Mantid::Kernel::V3D vecPointingAlongBeam() const;
+ Mantid::Kernel::V3D vecPointingAlongBeam() const;
+ /// Convert along horizontal axis into a 3D direction
+ Mantid::Kernel::V3D vecPointingHorizontal() const;
/// Convert along the axis defining the 2theta sign
- const Mantid::Kernel::V3D vecThetaSign() const;
+ Mantid::Kernel::V3D vecThetaSign() const;
/// Pointing up axis as a string
std::string pointingUpAxis() const;
/// Pointing along beam axis as a string
diff --git a/Framework/Geometry/inc/MantidGeometry/Objects/MeshObject.h b/Framework/Geometry/inc/MantidGeometry/Objects/MeshObject.h
index c3d6155311019a7736e6a53cb0417e51810cf4b1..e57513c99a6b416cb0b54d95c7f3918de92c122e 100644
--- a/Framework/Geometry/inc/MantidGeometry/Objects/MeshObject.h
+++ b/Framework/Geometry/inc/MantidGeometry/Objects/MeshObject.h
@@ -50,11 +50,10 @@ class MANTID_GEOMETRY_DLL MeshObject : public IObject {
public:
/// Constructor
MeshObject(const std::vector<uint16_t> &faces,
- const std::vector<Mantid::Kernel::V3D> &vertices,
+ const std::vector<Kernel::V3D> &vertices,
const Kernel::Material &material);
/// Constructor
- MeshObject(std::vector<uint16_t> &&faces,
- std::vector<Mantid::Kernel::V3D> &&vertices,
+ MeshObject(std::vector<uint16_t> &&faces, std::vector<Kernel::V3D> &&vertices,
const Kernel::Material &&material);
/// Copy constructor
@@ -142,12 +141,7 @@ private:
void getIntersections(const Kernel::V3D &start, const Kernel::V3D &direction,
std::vector<Kernel::V3D> &intersectionPoints,
std::vector<int> &entryExitFlags) const;
- /// Determine intersection between ray and an one triangle
- bool rayIntersectsTriangle(const Kernel::V3D &start,
- const Kernel::V3D &direction,
- const Kernel::V3D &v1, const Kernel::V3D &v2,
- const Kernel::V3D &v3, Kernel::V3D &intersection,
- int &entryExit) const;
+
/// Get triangle
bool getTriangle(const size_t index, Kernel::V3D &v1, Kernel::V3D &v2,
Kernel::V3D &v3) const;
diff --git a/Framework/Geometry/inc/MantidGeometry/Objects/MeshObject2D.h b/Framework/Geometry/inc/MantidGeometry/Objects/MeshObject2D.h
index eb65399c85c561e50aa7cb8bc059519f254bb744..e1374a0994ef078cf2cd89ffd6b57955104d92fc 100644
--- a/Framework/Geometry/inc/MantidGeometry/Objects/MeshObject2D.h
+++ b/Framework/Geometry/inc/MantidGeometry/Objects/MeshObject2D.h
@@ -32,18 +32,16 @@ class MANTID_GEOMETRY_DLL MeshObject2D : public IObject {
public:
/// Constructor
MeshObject2D(const std::vector<uint16_t> &faces,
- const std::vector<Mantid::Kernel::V3D> &vertices,
+ const std::vector<Kernel::V3D> &vertices,
const Kernel::Material &material);
/// Constructor
MeshObject2D(std::vector<uint16_t> &&faces,
- std::vector<Mantid::Kernel::V3D> &&vertices,
+ std::vector<Kernel::V3D> &&vertices,
const Kernel::Material &&material);
double volume() const override;
- static bool isOnTriangle(const Kernel::V3D &point, const Kernel::V3D &a,
- const Kernel::V3D &b, const Kernel::V3D &c);
- static bool pointsCoplanar(const std::vector<Mantid::Kernel::V3D> &vertices);
+ static bool pointsCoplanar(const std::vector<Kernel::V3D> &vertices);
bool hasValidShape() const override;
double distanceToPlane(const Kernel::V3D &point) const;
diff --git a/Framework/Geometry/inc/MantidGeometry/Objects/MeshObjectCommon.h b/Framework/Geometry/inc/MantidGeometry/Objects/MeshObjectCommon.h
new file mode 100644
index 0000000000000000000000000000000000000000..f0d61427f5005cd2238f1f61de82f1d933c40544
--- /dev/null
+++ b/Framework/Geometry/inc/MantidGeometry/Objects/MeshObjectCommon.h
@@ -0,0 +1,67 @@
+#ifndef MANTID_GEOMETRY_MESHOBJECTCOMMON_H_
+#define MANTID_GEOMETRY_MESHOBJECTCOMMON_H_
+
+#include "MantidGeometry/DllConfig.h"
+#include "MantidKernel/V3D.h"
+#include <vector>
+
+namespace Mantid {
+namespace Geometry {
+class BoundingBox;
+/** MeshObjectCommon : Performs functions common to 3D and 2D closed meshes
+
+ Copyright © 2018 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>
+*/
+namespace MeshObjectCommon {
+
+MANTID_GEOMETRY_DLL std::vector<double>
+getVertices(const std::vector<Kernel::V3D> &vertices);
+
+MANTID_GEOMETRY_DLL bool isOnTriangle(const Kernel::V3D &point,
+ const Kernel::V3D &v1,
+ const Kernel::V3D &v2,
+ const Kernel::V3D &v3);
+MANTID_GEOMETRY_DLL bool
+rayIntersectsTriangle(const Kernel::V3D &start, const Kernel::V3D &direction,
+ const Kernel::V3D &v1, const Kernel::V3D &v2,
+ const Kernel::V3D &v3, Kernel::V3D &intersection,
+ int &entryExit);
+
+MANTID_GEOMETRY_DLL void checkVertexLimit(size_t nVertices);
+MANTID_GEOMETRY_DLL std::vector<uint32_t>
+getTriangles_uint32(const std::vector<uint16_t> &input);
+MANTID_GEOMETRY_DLL const BoundingBox &
+getBoundingBox(const std::vector<Kernel::V3D> &vertices, BoundingBox &cacheBB);
+MANTID_GEOMETRY_DLL void
+getBoundingBox(const std::vector<Kernel::V3D> &vertices, BoundingBox &cacheBB,
+ double &xmax, double &ymax, double &zmax, double &xmin,
+ double &ymin, double &zmin);
+MANTID_GEOMETRY_DLL double getTriangleSolidAngle(const Kernel::V3D &a,
+ const Kernel::V3D &b,
+ const Kernel::V3D &c,
+ const Kernel::V3D &observer);
+} // namespace MeshObjectCommon
+
+} // namespace Geometry
+} // namespace Mantid
+
+#endif /* MANTID_GEOMETRY_MESHOBJECTCOMMON_H_ */
diff --git a/Framework/Geometry/src/Instrument.cpp b/Framework/Geometry/src/Instrument.cpp
index 742c9ff9ad110f379ca36c57f768e120a8602d7c..f180211d3b4b43e945c213a645485a03222371f6 100644
--- a/Framework/Geometry/src/Instrument.cpp
+++ b/Framework/Geometry/src/Instrument.cpp
@@ -8,6 +8,7 @@
#include "MantidBeamline/ComponentInfo.h"
#include "MantidBeamline/DetectorInfo.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
+#include "MantidGeometry/Instrument/ComponentInfoBankHelpers.h"
#include "MantidGeometry/Instrument/DetectorGroup.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidGeometry/Instrument/GridDetectorPixel.h"
@@ -1295,7 +1296,7 @@ boost::shared_ptr<ParameterMap> Instrument::makeLegacyParameterMap() const {
const int64_t parentIndex = componentInfo.parent(i);
const bool makeTransform = parentIndex != oldParentIndex;
- bool isGridDetectorPixel = false;
+ bool isDetFixedInBank = false;
if (makeTransform) {
oldParentIndex = parentIndex;
@@ -1312,15 +1313,15 @@ boost::shared_ptr<ParameterMap> Instrument::makeLegacyParameterMap() const {
const boost::shared_ptr<const IDetector> &baseDet =
std::get<1>(baseInstr.m_detectorCache[i]);
- isGridDetectorPixel =
- bool(boost::dynamic_pointer_cast<const GridDetectorPixel>(baseDet));
+ isDetFixedInBank =
+ ComponentInfoBankHelpers::isDetectorFixedInBank(componentInfo, i);
if (detectorInfo.isMasked(i)) {
pmap->forceUnsafeSetMasked(baseDet.get(), true);
}
if (makeTransform) {
// Special case: scaling for GridDetectorPixel.
- if (isGridDetectorPixel) {
+ if (isDetFixedInBank) {
size_t panelIndex = componentInfo.parent(parentIndex);
const auto panelID = componentInfo.componentID(panelIndex);
@@ -1354,7 +1355,7 @@ boost::shared_ptr<ParameterMap> Instrument::makeLegacyParameterMap() const {
// Tolerance 1e-9 m as in Beamline::DetectorInfo::isEquivalent.
if ((relPos - toVector3d(baseComponent->getRelativePos())).norm() >= 1e-9) {
- if (isGridDetectorPixel) {
+ if (isDetFixedInBank) {
throw std::runtime_error("Cannot create legacy ParameterMap: Position "
"parameters for GridDetectorPixel are "
"not supported");
diff --git a/Framework/Geometry/src/Instrument/ComponentInfoBankHelpers.cpp b/Framework/Geometry/src/Instrument/ComponentInfoBankHelpers.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..188fb2f06008b533f6f749f551cd28a1c37c2675
--- /dev/null
+++ b/Framework/Geometry/src/Instrument/ComponentInfoBankHelpers.cpp
@@ -0,0 +1,37 @@
+#include "MantidGeometry/Instrument/ComponentInfoBankHelpers.h"
+#include "MantidBeamline/ComponentType.h"
+#include "MantidGeometry/Instrument/ComponentInfo.h"
+
+using Mantid::Beamline::ComponentType;
+
+namespace Mantid {
+namespace Geometry {
+namespace ComponentInfoBankHelpers {
+/** Tests whether or not the detector is within a fixed bank. If detIndex does
+not point to a detector, this will return false. This method only returns true
+if the bank which houses the detector is rectangular, a grid or structured.
+@param compInfo ComponentInfo which defines instrument tree for testing
+@param detIndex Index of the detector to be tested
+@returns True if the detector is fixed in a bank, False otherwise.
+*/
+bool isDetectorFixedInBank(const ComponentInfo &compInfo,
+ const size_t detIndex) {
+ auto parent = compInfo.parent(detIndex);
+ auto grandParent = compInfo.parent(parent);
+ auto grandParentType = compInfo.componentType(grandParent);
+ auto greatGrandParent = compInfo.parent(parent); // bank
+ auto greatGrandParentType = compInfo.componentType(greatGrandParent);
+
+ if (compInfo.isDetector(detIndex) &&
+ (grandParentType == ComponentType::Rectangular ||
+ grandParentType == ComponentType::Structured ||
+ greatGrandParentType == ComponentType::Grid)) {
+ return true;
+ }
+
+ return false;
+}
+
+} // namespace ComponentInfoBankHelpers
+} // namespace Geometry
+} // namespace Mantid
diff --git a/Framework/Geometry/src/Instrument/ReferenceFrame.cpp b/Framework/Geometry/src/Instrument/ReferenceFrame.cpp
index 2be53f87bb73b595d9f9d4cf90f2298337f51677..ba3355c71b1f58345cb2433dd1e8ba841de97d9f 100644
--- a/Framework/Geometry/src/Instrument/ReferenceFrame.cpp
+++ b/Framework/Geometry/src/Instrument/ReferenceFrame.cpp
@@ -163,22 +163,30 @@ std::string ReferenceFrame::origin() const { return m_origin; }
Getter for the up instrument direction
@return up direction.
*/
-const V3D ReferenceFrame::vecPointingUp() const { return m_vecPointingUp; }
+V3D ReferenceFrame::vecPointingUp() const { return m_vecPointingUp; }
/**
Getter for the direction defining the theta sign
@return theta sign direction.
*/
-const V3D ReferenceFrame::vecThetaSign() const { return m_vecThetaSign; }
+V3D ReferenceFrame::vecThetaSign() const { return m_vecThetaSign; }
/**
Getter for the along beam vector.
@return along beam direction.
*/
-const V3D ReferenceFrame::vecPointingAlongBeam() const {
+V3D ReferenceFrame::vecPointingAlongBeam() const {
return m_vecPointingAlongBeam;
}
+/**
+Calculate the horizontal vector.
+@return horizontal direction.
+*/
+V3D ReferenceFrame::vecPointingHorizontal() const {
+ return directionToVector(pointingHorizontal());
+}
+
/**
Convenience method for checking whether or not a vector is aligned
with the along beam vector.
diff --git a/Framework/Geometry/src/Objects/CSGObject.cpp b/Framework/Geometry/src/Objects/CSGObject.cpp
index 31edc6327949bb70552a5cc8dfd423bcef36b23e..105260c456d0c47980338f32d09e8d4953f0b93f 100644
--- a/Framework/Geometry/src/Objects/CSGObject.cpp
+++ b/Framework/Geometry/src/Objects/CSGObject.cpp
@@ -1058,6 +1058,18 @@ double CSGObject::triangleSolidAngle(const V3D &observer) const {
sneg += sa;
}
}
+ /* We assume that objects are opaque to neutrons and that objects define
+ * closed surfaces which are convex. For such objects negative solid angle
+ * equals positive solid angle. This is true providing that the winding
+ * order is defined properly such that the contribution from each triangle
+ * w.r.t the observer gets counted to either the negative or positive
+ * contribution correctly. If that is done correctly then it would only be
+ * necessary to consider the positive contribution to the solid angle.
+ *
+ * The following provides a fix to situations where the winding order is
+ * incorrectly defined. It does not matter if the contribution is positive
+ * or negative since we take the average.
+ */
return 0.5 * (sangle - sneg);
}
}
diff --git a/Framework/Geometry/src/Objects/MeshObject.cpp b/Framework/Geometry/src/Objects/MeshObject.cpp
index 75ca88855f25c71396339079bd5166452c7d6912..138d52abb8586dce88200038361f645e188ed342 100644
--- a/Framework/Geometry/src/Objects/MeshObject.cpp
+++ b/Framework/Geometry/src/Objects/MeshObject.cpp
@@ -5,6 +5,7 @@
// & Institut Laue - Langevin
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidGeometry/Objects/MeshObject.h"
+#include "MantidGeometry/Objects/MeshObjectCommon.h"
#include "MantidGeometry/Objects/Track.h"
#include "MantidGeometry/Rendering/GeometryHandler.h"
#include "MantidGeometry/Rendering/vtkGeometryCacheReader.h"
@@ -19,11 +20,8 @@
namespace Mantid {
namespace Geometry {
-using Kernel::Material;
-using Kernel::V3D;
-
MeshObject::MeshObject(const std::vector<uint16_t> &faces,
- const std::vector<V3D> &vertices,
+ const std::vector<Kernel::V3D> &vertices,
const Kernel::Material &material)
: m_boundingBox(), m_id("MeshObject"), m_triangles(faces),
m_vertices(vertices), m_material(material) {
@@ -32,7 +30,7 @@ MeshObject::MeshObject(const std::vector<uint16_t> &faces,
}
MeshObject::MeshObject(std::vector<uint16_t> &&faces,
- std::vector<V3D> &&vertices,
+ std::vector<Kernel::V3D> &&vertices,
const Kernel::Material &&material)
: m_boundingBox(), m_id("MeshObject"), m_triangles(std::move(faces)),
m_vertices(std::move(vertices)), m_material(material) {
@@ -43,11 +41,7 @@ MeshObject::MeshObject(std::vector<uint16_t> &&faces,
// Do things that need to be done in constructor
void MeshObject::initialize() {
- if (m_vertices.size() > std::numeric_limits<uint16_t>::max()) {
- throw std::invalid_argument(
- "Too many vertices (" + std::to_string(m_vertices.size()) +
- "). MeshObject cannot have more than 65535 vertices.");
- }
+ MeshObjectCommon::checkVertexLimit(m_vertices.size());
m_handler = boost::make_shared<GeometryHandler>(*this);
}
@@ -79,8 +73,8 @@ bool MeshObject::isValid(const Kernel::V3D &point) const {
return false;
}
- V3D direction(0.0, 0.0, 1.0); // direction to look for intersections
- std::vector<V3D> intersectionPoints;
+ Kernel::V3D direction(0.0, 0.0, 1.0); // direction to look for intersections
+ std::vector<Kernel::V3D> intersectionPoints;
std::vector<int> entryExitFlags;
getIntersections(point, direction, intersectionPoints, entryExitFlags);
@@ -120,13 +114,13 @@ bool MeshObject::isOnSide(const Kernel::V3D &point) const {
return false;
}
- const std::vector<V3D> directions = {
- V3D{0, 0, 1}, V3D{0, 1, 0},
- V3D{1, 0, 0}}; // directions to look for intersections
+ const std::vector<Kernel::V3D> directions = {
+ Kernel::V3D{0, 0, 1}, Kernel::V3D{0, 1, 0},
+ Kernel::V3D{1, 0, 0}}; // directions to look for intersections
// We have to look in several directions in case a point is on a face
// or edge parallel to the first direction or also the second direction.
for (const auto &direction : directions) {
- std::vector<V3D> intersectionPoints;
+ std::vector<Kernel::V3D> intersectionPoints;
std::vector<int> entryExitFlags;
getIntersections(point, direction, intersectionPoints, entryExitFlags);
@@ -157,7 +151,7 @@ int MeshObject::interceptSurface(Geometry::Track &UT) const {
return 0;
}
- std::vector<V3D> intersectionPoints;
+ std::vector<Kernel::V3D> intersectionPoints;
std::vector<int> entryExitFlags;
getIntersections(UT.startPoint(), UT.direction(), intersectionPoints,
@@ -165,6 +159,7 @@ int MeshObject::interceptSurface(Geometry::Track &UT) const {
if (intersectionPoints.empty())
return 0; // Quit if no intersections found
+ // For a 3D mesh, a ray may intersect several segments
for (size_t i = 0; i < intersectionPoints.size(); ++i) {
UT.addPoint(entryExitFlags[i], intersectionPoints[i], *this);
}
@@ -185,11 +180,12 @@ void MeshObject::getIntersections(const Kernel::V3D &start,
std::vector<Kernel::V3D> &intersectionPoints,
std::vector<int> &entryExitFlags) const {
- V3D vertex1, vertex2, vertex3, intersection;
+ Kernel::V3D vertex1, vertex2, vertex3, intersection;
int entryExit;
for (size_t i = 0; getTriangle(i, vertex1, vertex2, vertex3); ++i) {
- if (rayIntersectsTriangle(start, direction, vertex1, vertex2, vertex3,
- intersection, entryExit)) {
+ if (MeshObjectCommon::rayIntersectsTriangle(start, direction, vertex1,
+ vertex2, vertex3, intersection,
+ entryExit)) {
intersectionPoints.push_back(intersection);
entryExitFlags.push_back(entryExit);
}
@@ -197,63 +193,6 @@ void MeshObject::getIntersections(const Kernel::V3D &start,
// still need to deal with edge cases
}
-/**
- * Get intersection points and their in out directions on the given ray
- * @param start :: Start point of ray
- * @param direction :: Direction of ray
- * @param v1 :: First vertex of triangle
- * @param v2 :: Second vertex of triangle
- * @param v3 :: Third vertex of triangle
- * @param intersection :: Intersection point
- * @param entryExit :: 1 if intersection is entry, -1 if exit
- * @returns true if there is an intersection
- */
-bool MeshObject::rayIntersectsTriangle(const Kernel::V3D &start,
- const Kernel::V3D &direction,
- const V3D &v1, const V3D &v2,
- const V3D &v3, V3D &intersection,
- int &entryExit) const {
- // Implements Möller–Trumbore intersection algorithm
- V3D edge1, edge2, h, s, q;
- double a, f, u, v;
- edge1 = v2 - v1;
- edge2 = v3 - v1;
- h = direction.cross_prod(edge2);
- a = edge1.scalar_prod(h);
-
- const double EPSILON = 0.0000001 * edge1.norm();
- if (a > -EPSILON && a < EPSILON)
- return false; // Ray in or parallel to plane of triangle
- f = 1 / a;
- s = start - v1;
- u = f * (s.scalar_prod(h));
- if (u < 0.0 || u > 1.0)
- return false; // Intersection with plane outside triangle
- q = s.cross_prod(edge1);
- v = f * direction.scalar_prod(q);
- if (v < 0.0 || u + v > 1.0)
- return false; // Intersection with plane outside triangle
-
- // At this stage we can compute t to find out where the intersection point is
- // on the line.
- double t = f * edge2.scalar_prod(q);
- if (t >= -EPSILON) // ray intersection
- {
- intersection = start + direction * t;
-
- // determine entry exit assuming anticlockwise triangle view from outside
- V3D normalDirection = edge1.cross_prod(edge2);
- if (normalDirection.scalar_prod(direction) > 0.0) {
- entryExit = -1; // exit
- } else {
- entryExit = 1; // entry
- }
- return true;
- }
- // Here the intersection occurs on the line of the ray behind the ray.
- return false;
-}
-
/*
* Get a triangle - useful for iterating over triangles
* @param index :: Index of triangle in MeshObject
@@ -262,8 +201,8 @@ bool MeshObject::rayIntersectsTriangle(const Kernel::V3D &start,
* @param v3 :: Third vertex of triangle
* @returns true if the specified triangle exists
*/
-bool MeshObject::getTriangle(const size_t index, V3D &vertex1, V3D &vertex2,
- V3D &vertex3) const {
+bool MeshObject::getTriangle(const size_t index, Kernel::V3D &vertex1,
+ Kernel::V3D &vertex2, Kernel::V3D &vertex3) const {
bool triangleExists = index < m_triangles.size() / 3;
if (triangleExists) {
vertex1 = m_vertices[m_triangles[3 * index]];
@@ -273,41 +212,6 @@ bool MeshObject::getTriangle(const size_t index, V3D &vertex1, V3D &vertex2,
return triangleExists;
}
-/**
- * Find the solid angle of a triangle defined by vectors a,b,c from point
- *"observer"
- *
- * formula (Oosterom) O=2atan([a,b,c]/(abc+(a.b)c+(a.c)b+(b.c)a))
- *
- * @param a :: first point of triangle
- * @param b :: second point of triangle
- * @param c :: third point of triangle
- * @param observer :: point from which solid angle is required
- * @return :: solid angle of triangle in Steradians.
- *
- * This duplicates code in CSGOjbect both need a place to be merged.
- * To aid this, this function has been defined as a non-member.
- */
-double getTriangleSolidAngle(const V3D &a, const V3D &b, const V3D &c,
- const V3D &observer) {
- const V3D ao = a - observer;
- const V3D bo = b - observer;
- const V3D co = c - observer;
- const double modao = ao.norm();
- const double modbo = bo.norm();
- const double modco = co.norm();
- const double aobo = ao.scalar_prod(bo);
- const double aoco = ao.scalar_prod(co);
- const double boco = bo.scalar_prod(co);
- const double scalTripProd = ao.scalar_prod(bo.cross_prod(co));
- const double denom =
- modao * modbo * modco + modco * aobo + modbo * aoco + modao * boco;
- if (denom != 0.0)
- return 2.0 * atan2(scalTripProd, denom);
- else
- return 0.0; // not certain this is correct
-}
-
/**
* Calculate if a point PT is a valid point on the track
* @param point :: Point to calculate from.
@@ -343,13 +247,8 @@ int MeshObject::calcValidType(const Kernel::V3D &point,
void MeshObject::getBoundingBox(double &xmax, double &ymax, double &zmax,
double &xmin, double &ymin,
double &zmin) const {
- BoundingBox bb = getBoundingBox();
- xmin = bb.xMin();
- xmax = bb.xMax();
- ymin = bb.yMin();
- ymax = bb.yMax();
- zmin = bb.zMin();
- zmax = bb.zMax();
+ return MeshObjectCommon::getBoundingBox(m_vertices, m_boundingBox, xmax, ymax,
+ zmax, xmin, ymin, zmin);
}
/**
@@ -358,17 +257,24 @@ void MeshObject::getBoundingBox(double &xmax, double &ymax, double &zmax,
* @return :: estimate of solid angle of object.
*/
double MeshObject::solidAngle(const Kernel::V3D &observer) const {
-
double solidAngleSum(0), solidAngleNegativeSum(0);
- V3D vertex1, vertex2, vertex3;
- for (size_t i = 0; getTriangle(i, vertex1, vertex2, vertex3); ++i) {
- double sa = getTriangleSolidAngle(vertex1, vertex2, vertex3, observer);
+ Kernel::V3D vertex1, vertex2, vertex3;
+ for (size_t i = 0; this->getTriangle(i, vertex1, vertex2, vertex3); ++i) {
+ double sa = MeshObjectCommon::getTriangleSolidAngle(vertex1, vertex2,
+ vertex3, observer);
if (sa > 0.0) {
solidAngleSum += sa;
} else {
solidAngleNegativeSum += sa;
}
}
+ /*
+ Same implementation as CSGObject. Assumes a convex closed mesh with
+ solidAngleSum == -solidAngleNegativeSum
+
+ Average is used to bypass issues with winding order. Surface normal
+ affects magnitude of solid angle. See CSGObject.
+ */
return 0.5 * (solidAngleSum - solidAngleNegativeSum);
}
@@ -376,22 +282,20 @@ double MeshObject::solidAngle(const Kernel::V3D &observer) const {
* Find solid angle of object wrt the observer with a scaleFactor for the
* object.
* @param observer :: point to measure solid angle from
- * @param scaleFactor :: V3D giving scaling of the object
+ * @param scaleFactor :: Kernel::V3D giving scaling of the object
* @return :: estimate of solid angle of object.
*/
double MeshObject::solidAngle(const Kernel::V3D &observer,
const Kernel::V3D &scaleFactor) const
{
- std::vector<V3D> scaledVertices;
+ std::vector<Kernel::V3D> scaledVertices;
scaledVertices.reserve(m_vertices.size());
for (const auto &vertex : m_vertices) {
- scaledVertices.emplace_back(scaleFactor.X() * vertex.X(),
- scaleFactor.Y() * vertex.Y(),
- scaleFactor.Z() * vertex.Z());
+ scaledVertices.emplace_back(scaleFactor * vertex);
}
- MeshObject scaledObject(m_triangles, scaledVertices, m_material);
- return scaledObject.solidAngle(observer);
+ MeshObject meshScaled(m_triangles, scaledVertices, m_material);
+ return meshScaled.solidAngle(observer);
}
/**
@@ -408,15 +312,15 @@ double MeshObject::volume() const {
double cX = 0.5 * (bb.xMax() + bb.xMin());
double cY = 0.5 * (bb.yMax() + bb.yMin());
double cZ = 0.5 * (bb.zMax() + bb.zMin());
- V3D centre(cX, cY, cZ);
+ Kernel::V3D centre(cX, cY, cZ);
double volumeTimesSix(0.0);
- V3D vertex1, vertex2, vertex3;
+ Kernel::V3D vertex1, vertex2, vertex3;
for (size_t i = 0; getTriangle(i, vertex1, vertex2, vertex3); ++i) {
- V3D a = vertex1 - centre;
- V3D b = vertex2 - centre;
- V3D c = vertex3 - centre;
+ Kernel::V3D a = vertex1 - centre;
+ Kernel::V3D b = vertex2 - centre;
+ Kernel::V3D c = vertex3 - centre;
volumeTimesSix += a.scalar_prod(b.cross_prod(c));
}
@@ -428,35 +332,7 @@ double MeshObject::volume() const {
* @returns A reference to a bounding box for this shape.
*/
const BoundingBox &MeshObject::getBoundingBox() const {
-
- if (m_boundingBox.isNull())
- // As the shape of MeshObject is immutable, we need only calculate
- // bounding box, if the cached bounding box is null.
- if (numberOfVertices() > 0) {
- // Initial extents to be overwritten by loop
- constexpr double huge = 1e10;
- double minX, maxX, minY, maxY, minZ, maxZ;
- minX = minY = minZ = huge;
- maxX = maxY = maxZ = -huge;
-
- // Loop over all vertices and determine minima and maxima on each axis
- for (const auto &vertex : m_vertices) {
- auto vx = vertex.X();
- auto vy = vertex.Y();
- auto vz = vertex.Z();
-
- minX = std::min(minX, vx);
- maxX = std::max(maxX, vx);
- minY = std::min(minY, vy);
- maxY = std::max(maxY, vy);
- minZ = std::min(minZ, vz);
- maxZ = std::max(maxZ, vz);
- }
- // Cache bounding box, so we do not need to repeat calculation
- m_boundingBox = BoundingBox(maxX, maxY, maxZ, minX, minY, minZ);
- }
-
- return m_boundingBox;
+ return MeshObjectCommon::getBoundingBox(m_vertices, m_boundingBox);
}
/**
@@ -489,8 +365,9 @@ int MeshObject::getPointInObject(Kernel::V3D &point) const {
* @param maxAttempts The maximum number of attempts at generating a point
* @return The generated point
*/
-V3D MeshObject::generatePointInObject(Kernel::PseudoRandomNumberGenerator &rng,
- const size_t maxAttempts) const {
+Kernel::V3D
+MeshObject::generatePointInObject(Kernel::PseudoRandomNumberGenerator &rng,
+ const size_t maxAttempts) const {
const auto &bbox = getBoundingBox();
if (bbox.isNull()) {
throw std::runtime_error("Object::generatePointInObject() - Invalid "
@@ -509,9 +386,10 @@ V3D MeshObject::generatePointInObject(Kernel::PseudoRandomNumberGenerator &rng,
* @param maxAttempts The maximum number of attempts at generating a point
* @return The newly generated point
*/
-V3D MeshObject::generatePointInObject(Kernel::PseudoRandomNumberGenerator &rng,
- const BoundingBox &activeRegion,
- const size_t maxAttempts) const {
+Kernel::V3D
+MeshObject::generatePointInObject(Kernel::PseudoRandomNumberGenerator &rng,
+ const BoundingBox &activeRegion,
+ const size_t maxAttempts) const {
size_t attempts(0);
while (attempts < maxAttempts) {
const double r1 = rng.nextValue();
@@ -540,9 +418,9 @@ bool MeshObject::searchForObject(Kernel::V3D &point) const {
//
if (isValid(point))
return true;
- for (const auto &dir :
- {V3D(1., 0., 0.), V3D(-1., 0., 0.), V3D(0., 1., 0.), V3D(0., -1., 0.),
- V3D(0., 0., 1.), V3D(0., 0., -1.)}) {
+ for (const auto &dir : {Kernel::V3D(1., 0., 0.), Kernel::V3D(-1., 0., 0.),
+ Kernel::V3D(0., 1., 0.), Kernel::V3D(0., -1., 0.),
+ Kernel::V3D(0., 0., 1.), Kernel::V3D(0., 0., -1.)}) {
Geometry::Track tr(point, dir);
if (this->interceptSurface(tr) > 0) {
point = tr.cbegin()->entryPoint;
@@ -611,13 +489,7 @@ size_t MeshObject::numberOfTriangles() const { return m_triangles.size() / 3; }
* get faces
*/
std::vector<uint32_t> MeshObject::getTriangles() const {
- std::vector<uint32_t> faces;
- size_t nFaceCorners = m_triangles.size();
- faces.resize(static_cast<std::size_t>(nFaceCorners));
- for (size_t i = 0; i < nFaceCorners; ++i) {
- faces[i] = static_cast<int>(m_triangles[i]);
- }
- return faces;
+ return MeshObjectCommon::getTriangles_uint32(m_triangles);
}
/**
@@ -631,18 +503,7 @@ size_t MeshObject::numberOfVertices() const {
* get vertices
*/
std::vector<double> MeshObject::getVertices() const {
- std::vector<double> points;
- size_t nPoints = m_vertices.size();
- if (nPoints > 0) {
- points.resize(static_cast<std::size_t>(nPoints) * 3);
- for (size_t i = 0; i < nPoints; ++i) {
- const auto &pnt = m_vertices[i];
- points[i * 3 + 0] = pnt.X();
- points[i * 3 + 1] = pnt.Y();
- points[i * 3 + 2] = pnt.Z();
- }
- }
- return points;
+ return MeshObjectCommon::getVertices(m_vertices);
}
/**
diff --git a/Framework/Geometry/src/Objects/MeshObject2D.cpp b/Framework/Geometry/src/Objects/MeshObject2D.cpp
index b3c41fadbc5722f2acd0d24a63a148a9c0213512..b0d255cd02812758c6388b53df919bfdd14fafc1 100644
--- a/Framework/Geometry/src/Objects/MeshObject2D.cpp
+++ b/Framework/Geometry/src/Objects/MeshObject2D.cpp
@@ -6,6 +6,7 @@
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidGeometry/Objects/MeshObject2D.h"
#include "MantidGeometry/Objects/IObject.h"
+#include "MantidGeometry/Objects/MeshObjectCommon.h"
#include "MantidGeometry/Objects/Track.h"
#include "MantidGeometry/Rendering/GeometryHandler.h"
#include "MantidKernel/Material.h"
@@ -18,12 +19,12 @@ namespace Mantid {
namespace Geometry {
namespace CoplanarChecks {
-bool sufficientPoints(const std::vector<Mantid::Kernel::V3D> &vertices) {
+bool sufficientPoints(const std::vector<Kernel::V3D> &vertices) {
return vertices.size() >= 3; // Not a plane with < 3 points
}
/**
- * Establish the first surface normal. Tries to establish normal fron
+ * Establish the first surface normal. Tries to establish normal from
* non-colinear points
* @param vertices : All vertices
* @return surface normal, or 0,0,0 if not found
@@ -79,8 +80,7 @@ bool allCoplanar(const std::vector<Kernel::V3D> &vertices,
* @param vertices : all vertices to consider
* @return : normal to surface formed by points
*/
-Kernel::V3D
-validatePointsCoplanar(const std::vector<Mantid::Kernel::V3D> &vertices) {
+Kernel::V3D validatePointsCoplanar(const std::vector<Kernel::V3D> &vertices) {
if (!sufficientPoints(vertices))
throw std::invalid_argument("Insufficient vertices to create a plane");
@@ -97,100 +97,43 @@ validatePointsCoplanar(const std::vector<Mantid::Kernel::V3D> &vertices) {
return normal;
}
} // namespace CoplanarChecks
-
namespace {
-using Mantid::Kernel::V3D;
-
/**
- * Find the solid angle of a triangle defined by vectors a,b,c from point
- *"observer"
- *
- * formula (Oosterom) O=2atan([a,b,c]/(abc+(a.b)c+(a.c)b+(b.c)a))
- *
- * @param a :: first point of triangle
- * @param b :: second point of triangle
- * @param c :: third point of triangle
- * @param observer :: point from which solid angle is required
- * @return :: solid angle of triangle in Steradians.
- *
- * This duplicates code in CSGOjbect both need a place to be merged.
- * To aid this, this function has been defined as a non-member.
+ * Get a triangle - For iterating over triangles
+ * @param index :: Index of triangle in MeshObject
+ * @param triangles :: indices into vertices 3 consecutive form triangle
+ * @param vertices :: Vertices to lookup
+ * @param vertex1 :: First vertex of triangle
+ * @param vertex2 :: Second vertex of triangle
+ * @param vertex3 :: Third vertex of triangle
+ * @returns true if the specified triangle exists
*/
-double getTriangleSolidAngle(const V3D &a, const V3D &b, const V3D &c,
- const V3D &observer) {
- const V3D ao = a - observer;
- const V3D bo = b - observer;
- const V3D co = c - observer;
- const double modao = ao.norm();
- const double modbo = bo.norm();
- const double modco = co.norm();
- const double aobo = ao.scalar_prod(bo);
- const double aoco = ao.scalar_prod(co);
- const double boco = bo.scalar_prod(co);
- const double scalTripProd = ao.scalar_prod(bo.cross_prod(co));
- const double denom =
- modao * modbo * modco + modco * aobo + modbo * aoco + modao * boco;
- if (denom != 0.0)
- return 2.0 * atan2(scalTripProd, denom);
- else
- return 0.0; // not certain this is correct
+bool getTriangle(const size_t index, const std::vector<uint16_t> &triangles,
+ const std::vector<Kernel::V3D> &vertices, Kernel::V3D &vertex1,
+ Kernel::V3D &vertex2, Kernel::V3D &vertex3) {
+ bool triangleExists = index < triangles.size() / 3;
+ if (triangleExists) {
+ vertex1 = vertices[triangles[3 * index]];
+ vertex2 = vertices[triangles[3 * index + 1]];
+ vertex3 = vertices[triangles[3 * index + 2]];
+ }
+ return triangleExists;
}
} // namespace
const double MeshObject2D::MinThickness = 0.001;
const std::string MeshObject2D::Id = "MeshObject2D";
-/**
- * @brief isOnTriangle
- * @param point : point to test
- * @param a : first vertex of triangle
- * @param b : second vertex of triangle
- * @param c : thrid vertex of triangle
- * @return True only point if is on triangle
- */
-bool MeshObject2D::isOnTriangle(const Kernel::V3D &point, const Kernel::V3D &a,
- const Kernel::V3D &b, const Kernel::V3D &c) {
-
- // in change of basis, barycentric coordinates p = A + u*v0 + v*v1. v0 and
- // v1 are basis vectors
- // rewrite as v0 = u*v0 + v*v1
- // i) v0.v0 = u*v0.v0 + v*v1.v0
- // ii) v0.v1 = u*v0.v1 + v*v1.v1
- // solve for u, v and check u and v >= 0 and u+v <=1
-
- // TODO see MeshObject::rayIntersectsTriangle and compare!
-
- auto v0 = c - a;
- auto v1 = b - a;
- auto v2 = point - a;
-
- // Compute dot products
- auto dot00 = v0.scalar_prod(v0);
- auto dot01 = v0.scalar_prod(v1);
- auto dot02 = v0.scalar_prod(v2);
- auto dot11 = v1.scalar_prod(v1);
- auto dot12 = v1.scalar_prod(v2);
-
- // Compute barycentric coordinates
- auto invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
- auto u = (dot11 * dot02 - dot01 * dot12) * invDenom;
- auto v = (dot00 * dot12 - dot01 * dot02) * invDenom;
-
- // Check if point is in or on triangle
- return (u >= 0) && (v >= 0) && (u + v <= 1);
-}
-
/**
* Estalish if points are coplanar.
* @param vertices : All vertices to consider
* @return : Return True only if all coplanar
*/
-bool MeshObject2D::pointsCoplanar(
- const std::vector<Mantid::Kernel::V3D> &vertices) {
+bool MeshObject2D::pointsCoplanar(const std::vector<Kernel::V3D> &vertices) {
if (!CoplanarChecks::sufficientPoints(vertices))
return false;
- Mantid::Kernel::V3D normal = CoplanarChecks::surfaceNormal(vertices);
+ Kernel::V3D normal = CoplanarChecks::surfaceNormal(vertices);
// Check that a valid normal was found amongst collection of vertices
if (normal.norm2() == 0) {
// If all points are colinear. Not a plane.
@@ -239,12 +182,7 @@ void MeshObject2D::initialize() {
parameters.p0 = v0;
m_planeParameters = parameters;
- if (m_vertices.size() >
- std::numeric_limits<typename decltype(m_triangles)::value_type>::max()) {
- throw std::invalid_argument(
- "Too many vertices (" + std::to_string(m_vertices.size()) +
- "). MeshObject cannot have more than 65535 vertices.");
- }
+ MeshObjectCommon::checkVertexLimit(m_vertices.size());
m_handler = boost::make_shared<GeometryHandler>(*this);
}
bool MeshObject2D::hasValidShape() const {
@@ -270,8 +208,9 @@ bool MeshObject2D::isValid(const Kernel::V3D &point) const {
static const double tolerance = 1e-9;
if (distanceToPlane(point) < tolerance) {
for (size_t i = 0; i < m_vertices.size(); i += 3) {
- if (isOnTriangle(point, m_vertices[i], m_vertices[i + 1],
- m_vertices[i + 2]))
+
+ if (MeshObjectCommon::isOnTriangle(point, m_vertices[i],
+ m_vertices[i + 1], m_vertices[i + 2]))
return true;
}
}
@@ -301,14 +240,16 @@ int MeshObject2D::interceptSurface(Geometry::Track &ut) const {
m_planeParameters.p0.scalar_prod(norm)) /
ut.direction().scalar_prod(norm);
- // Intersects infinite plane
+ // Intersects infinite plane. No point evaluating individual segements if this
+ // fails
if (t >= 0) {
- auto pIntersects = ut.startPoint() + ut.direction();
+ Kernel::V3D intersection;
+ int entryExit;
for (size_t i = 0; i < m_vertices.size(); i += 3) {
- // Need to know that this corresponds to a finite segment
- if (isOnTriangle(pIntersects, m_vertices[i], m_vertices[i + 1],
- m_vertices[i + 2])) {
- ut.addPoint(-1 /*HACK as exit*/, pIntersects, *this);
+ if (MeshObjectCommon::rayIntersectsTriangle(
+ ut.startPoint(), ut.direction(), m_vertices[i], m_vertices[i + 1],
+ m_vertices[i + 2], intersection, entryExit)) {
+ ut.addPoint(entryExit, intersection, *this);
ut.buildLink();
// All vertices on plane. So only one triangle intersection possible
break;
@@ -335,32 +276,42 @@ int MeshObject2D::getName() const {
// where this is used.
}
+/**
+ * Solid angle only considers triangle facing sample. Back faces do NOT
+ * contribute.
+ *
+ * This is tantamount to defining an object that is opaque to neutrons. Note
+ * that it is still possible to define a facing surface which is obscured by
+ * another. In that case there would still be a solid angle contribution as
+ * there is no way of detecting the shadowing.
+ *
+ * @param observer
+ * @return
+ */
double MeshObject2D::solidAngle(const Kernel::V3D &observer) const {
- double solidAngleSum(0), solidAngleNegativeSum(0);
- for (size_t i = 0; i < m_vertices.size(); i += 3) {
- auto sa = getTriangleSolidAngle(m_vertices[m_triangles[i]],
- m_vertices[m_triangles[i + 1]],
- m_vertices[m_triangles[i + 2]], observer);
- if (sa > 0.0) {
+ double solidAngleSum(0);
+ Kernel::V3D vertex1, vertex2, vertex3;
+ for (size_t i = 0;
+ getTriangle(i, m_triangles, m_vertices, vertex1, vertex2, vertex3);
+ ++i) {
+ double sa = MeshObjectCommon::getTriangleSolidAngle(vertex1, vertex2,
+ vertex3, observer);
+ if (sa > 0) {
solidAngleSum += sa;
- } else {
- solidAngleNegativeSum += sa;
}
}
- return 0.5 * (solidAngleSum - solidAngleNegativeSum);
+ return solidAngleSum;
}
double MeshObject2D::solidAngle(const Kernel::V3D &observer,
const Kernel::V3D &scaleFactor) const {
- std::vector<V3D> scaledVertices;
+ std::vector<Kernel::V3D> scaledVertices;
scaledVertices.reserve(m_vertices.size());
for (const auto &vertex : m_vertices) {
- scaledVertices.emplace_back(scaleFactor.X() * vertex.X(),
- scaleFactor.Y() * vertex.Y(),
- scaleFactor.Z() * vertex.Z());
+ scaledVertices.emplace_back(scaleFactor * vertex);
}
- MeshObject2D scaledObject(m_triangles, scaledVertices, m_material);
- return scaledObject.solidAngle(observer);
+ MeshObject2D meshScaled(m_triangles, scaledVertices, m_material);
+ return meshScaled.solidAngle(observer);
}
bool MeshObject2D::operator==(const MeshObject2D &other) const {
@@ -386,49 +337,14 @@ double MeshObject2D::volume() const {
* @returns A reference to a bounding box for this shape.
*/
const BoundingBox &MeshObject2D::getBoundingBox() const {
-
- if (m_boundingBox.isNull()) {
- double minX, maxX, minY, maxY, minZ, maxZ;
- minX = minY = minZ = std::numeric_limits<double>::max();
- maxX = maxY = maxZ = std::numeric_limits<double>::min();
-
- // Loop over all vertices and determine minima and maxima on each axis
- for (const auto &vertex : m_vertices) {
- auto vx = vertex.X();
- auto vy = vertex.Y();
- auto vz = vertex.Z();
-
- minX = std::min(minX, vx);
- maxX = std::max(maxX, vx);
- minY = std::min(minY, vy);
- maxY = std::max(maxY, vy);
- minZ = std::min(minZ, vz);
- maxZ = std::max(maxZ, vz);
- }
- if (minX == maxX)
- maxX += MinThickness;
- if (minY == maxY)
- maxY += MinThickness;
- if (minZ == maxZ)
- maxZ += MinThickness;
-
- // Cache bounding box, so we do not need to repeat calculation
- m_boundingBox = BoundingBox(maxX, maxY, maxZ, minX, minY, minZ);
- }
-
- return m_boundingBox;
+ return MeshObjectCommon::getBoundingBox(m_vertices, m_boundingBox);
}
void MeshObject2D::getBoundingBox(double &xmax, double &ymax, double &zmax,
double &xmin, double &ymin,
double &zmin) const {
- auto bb = this->getBoundingBox();
- xmax = bb.xMax();
- xmin = bb.xMin();
- ymax = bb.yMax();
- ymin = bb.yMin();
- zmax = bb.zMax();
- zmin = bb.zMin();
+ return MeshObjectCommon::getBoundingBox(m_vertices, m_boundingBox, xmax, ymax,
+ zmax, xmin, ymin, zmin);
}
/**
@@ -474,28 +390,12 @@ size_t MeshObject2D::numberOfTriangles() const {
}
std::vector<double> MeshObject2D::getVertices() const {
- std::vector<double> points;
- size_t nPoints = m_vertices.size();
- points.resize(static_cast<std::size_t>(nPoints) * 3);
- for (size_t i = 0; i < nPoints; ++i) {
- const auto &pnt = m_vertices[i];
- points[i * 3] = pnt.X();
- points[i * 3 + 1] = pnt.Y();
- points[i * 3 + 2] = pnt.Z();
- }
- return points;
+ return MeshObjectCommon::getVertices(m_vertices);
}
std::vector<uint32_t> MeshObject2D::getTriangles() const {
- std::vector<uint32_t> faces;
- size_t nFaceCorners = m_triangles.size();
- if (nFaceCorners > 0) {
- faces.resize(static_cast<std::size_t>(nFaceCorners));
- for (size_t i = 0; i < nFaceCorners; ++i) {
- faces[i] = static_cast<int>(m_triangles[i]);
- }
- }
- return faces;
+
+ return MeshObjectCommon::getTriangles_uint32(m_triangles);
}
void MeshObject2D::GetObjectGeom(detail::ShapeInfo::GeometryShape &,
diff --git a/Framework/Geometry/src/Objects/MeshObjectCommon.cpp b/Framework/Geometry/src/Objects/MeshObjectCommon.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..368cff0fa3426ede810b886b5d82b8d42062666f
--- /dev/null
+++ b/Framework/Geometry/src/Objects/MeshObjectCommon.cpp
@@ -0,0 +1,286 @@
+#include "MantidGeometry/Objects/MeshObjectCommon.h"
+#include "MantidGeometry/Objects/BoundingBox.h"
+#include <limits>
+#include <string>
+
+namespace Mantid {
+namespace Geometry {
+
+namespace MeshObjectCommon {
+/**
+ * getVertices converts vector Kernel::V3D to vector doubles. 3x size of input.
+ * ordered x,y,z,x,y,z...
+ * @param vertices : input vector of Kernel::V3D
+ * @return: vector of doubles. Elements of input.
+ */
+std::vector<double> getVertices(const std::vector<Kernel::V3D> &vertices) {
+ std::vector<double> points;
+ size_t nPoints = vertices.size();
+ if (nPoints > 0) {
+ points.resize(static_cast<std::size_t>(nPoints) * 3);
+ for (size_t i = 0; i < nPoints; ++i) {
+ const auto &pnt = vertices[i];
+ points[i * 3] = pnt.X();
+ points[i * 3 + 1] = pnt.Y();
+ points[i * 3 + 2] = pnt.Z();
+ }
+ }
+ return points;
+}
+/**
+ * Find the solid angle of a triangle defined by vectors a,b,c from point
+ *"observer"
+ *
+ * formula (Oosterom) O=2atan([a,b,c]/(abc+(a.b)c+(a.c)b+(b.c)a))
+ *
+ * @param a :: first point of triangle
+ * @param b :: second point of triangle
+ * @param c :: third point of triangle
+ * @param observer :: point from which solid angle is required
+ * @return :: solid angle of triangle in Steradians.
+ *
+ * This duplicates code in CSGOjbect both need a place to be merged.
+ * To aid this, this function has been defined as a non-member.
+ */
+double getTriangleSolidAngle(const Kernel::V3D &a, const Kernel::V3D &b,
+ const Kernel::V3D &c,
+ const Kernel::V3D &observer) {
+ const Kernel::V3D ao = a - observer;
+ const Kernel::V3D bo = b - observer;
+ const Kernel::V3D co = c - observer;
+ const double modao = ao.norm();
+ const double modbo = bo.norm();
+ const double modco = co.norm();
+ const double aobo = ao.scalar_prod(bo);
+ const double aoco = ao.scalar_prod(co);
+ const double boco = bo.scalar_prod(co);
+ const double scalTripProd = ao.scalar_prod(bo.cross_prod(co));
+ const double denom =
+ modao * modbo * modco + modco * aobo + modbo * aoco + modao * boco;
+ if (denom != 0.0)
+ return 2.0 * atan2(scalTripProd, denom);
+ else
+ return 0.0; // not certain this is correct
+}
+
+/**
+ * @brief isOnTriangle
+ * @param point : point to test
+ * @param v1 : first vertex of triangle
+ * @param v2 : second vertex of triangle
+ * @param v3 : thrid vertex of triangle
+ * @return True only point if is on triangle
+ */
+bool isOnTriangle(const Kernel::V3D &point, const Kernel::V3D &v1,
+ const Kernel::V3D &v2, const Kernel::V3D &v3) {
+
+ // p = w*p0 + u*p1 + v*p2, where numbered p refers to vertices of triangle
+ // w+u+v == 1, so w = 1-u-v
+ // p = (1-u-v)p0 + u*p1 + v*p2, rearranging ...
+ // p = u(p1 - p0) + v(p2 - p0) + p0
+ // in change of basis, barycentric coordinates p = p0 + u*e0 + v*e1. e0 and
+ // e1 are basis vectors. e2 = (p - p0)
+ // rewrite as e2 = u*e0 + v*e1
+ // i) e2.e0 = u*e0.e0 + v*e1.e0
+ // ii) e2.e1 = u*e0.e1 + v*e1.e1
+ // solve for u, v and check u and v >= 0 and u+v <=1
+
+ auto e0 = v3 - v1;
+ auto e1 = v2 - v1;
+ auto e2 = point - v1;
+
+ // Compute dot products
+ auto dot00 = e0.scalar_prod(e0);
+ auto dot01 = e0.scalar_prod(e1);
+ auto dot02 = e0.scalar_prod(e2);
+ auto dot11 = e1.scalar_prod(e1);
+ auto dot12 = e1.scalar_prod(e2);
+
+ /* in matrix form
+ M = e0.e0 e1.e0
+ e0.e1 e1.e1
+ U = u
+ v
+ R = e2.e0
+ e2.e1
+ U = R*(M^-1)
+ */
+
+ // Compute barycentric coordinates
+ auto invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
+ auto u = (dot11 * dot02 - dot01 * dot12) * invDenom;
+ auto v = (dot00 * dot12 - dot01 * dot02) * invDenom;
+
+ // Check if point is in or on triangle
+ return (u >= 0) && (v >= 0) && (u + v <= 1);
+}
+
+/**
+ * Get intersection points and their in out directions on the given ray
+ * @param start :: Start point of ray
+ * @param direction :: Direction of ray
+ * @param v1 :: First vertex of triangle
+ * @param v2 :: Second vertex of triangle
+ * @param v3 :: Third vertex of triangle
+ * @param intersection :: Intersection point
+ * @param entryExit :: 1 if intersection is entry, -1 if exit
+ * intersection
+ * @returns true if there is an intersection
+ */
+bool rayIntersectsTriangle(const Kernel::V3D &start,
+ const Kernel::V3D &direction, const Kernel::V3D &v1,
+ const Kernel::V3D &v2, const Kernel::V3D &v3,
+ Kernel::V3D &intersection, int &entryExit) {
+ // Implements Moller Trumbore intersection algorithm
+
+ // Eq line x = x0 + tV
+ //
+ // p = w*p0 + u*p1 + v*p2, where numbered p refers to vertices of triangle
+ // w+u+v == 1, so w = 1-u-v
+ // p = (1-u-v)p0 + u*p1 + v*p2, rearranging ...
+ // p = u(p1 - p0) + v(p2 - p0) + p0
+ // in change of basis, barycentric coordinates p = p0 + u*v0 + v*v1. v0 and
+ // v1 are basis vectors.
+
+ // For line to pass through triangle...
+ // (x0 + tV) = u(p1 - p0) + v(p2 - p0) + p0, yields
+ // (x0 - p0) = -tV + u(p1 - p0) + v(p2 - p0)
+
+ // rest is just to solve for u, v, t and check u and v are both >= 0 and <= 1
+ // and u+v <=1
+
+ auto edge1 = v2 - v1;
+ auto edge2 = v3 - v1;
+ auto h = direction.cross_prod(edge2);
+ auto a = edge1.scalar_prod(h);
+
+ const double EPSILON = 0.0000001 * edge1.norm();
+ if (a > -EPSILON && a < EPSILON)
+ return false; // Ray in or parallel to plane of triangle
+ auto f = 1 / a;
+ auto s = start - v1;
+ // Barycentric coordinate offset u
+ auto u = f * (s.scalar_prod(h));
+ if (u < 0.0 || u > 1.0)
+ return false; // Intersection with plane outside triangle
+ auto q = s.cross_prod(edge1);
+ // Barycentric coordinate offset v
+ auto v = f * direction.scalar_prod(q);
+ if (v < 0.0 || u + v > 1.0)
+ return false; // Intersection with plane outside triangle
+
+ // At this stage we can compute t to find out where the intersection point is
+ // on the line.
+ auto t = f * edge2.scalar_prod(q);
+ if (t >= -EPSILON) // ray intersection
+ {
+ intersection = start + direction * t;
+
+ // determine entry exit assuming anticlockwise triangle view from outside
+ Kernel::V3D normalDirection = edge1.cross_prod(edge2);
+ if (normalDirection.scalar_prod(direction) > 0.0) {
+ entryExit = -1; // exit
+ } else {
+ entryExit = 1; // entry
+ }
+ return true;
+ }
+ // The triangle is behind the start point. Forward ray does not intersect.
+ return false;
+}
+
+void checkVertexLimit(size_t nVertices) {
+ if (nVertices > std::numeric_limits<uint16_t>::max()) {
+ throw std::invalid_argument(
+ "Too many vertices (" + std::to_string(nVertices) +
+ "). MeshObject cannot have more than 65535 vertices.");
+ }
+}
+
+/**
+ * Converts triangle indices from unit16 to unit32
+ * @param input
+ * @return indices as unit32 vector
+ */
+std::vector<uint32_t> getTriangles_uint32(const std::vector<uint16_t> &input) {
+ std::vector<uint32_t> faces;
+ size_t nFaceCorners = input.size();
+ if (nFaceCorners > 0) {
+ faces.resize(static_cast<std::size_t>(nFaceCorners));
+ for (size_t i = 0; i < nFaceCorners; ++i) {
+ faces[i] = static_cast<int>(input[i]);
+ }
+ }
+ return faces;
+}
+
+/**
+ * Takes input vertices and calculates bounding box. Returns the bounding box.
+ *
+ * @param vertices :: vertices to create BB from
+ * @param cacheBB :: mutable BB object to write to.
+ */
+const BoundingBox &getBoundingBox(const std::vector<Kernel::V3D> &vertices,
+ BoundingBox &cacheBB) {
+
+ if (cacheBB.isNull()) {
+ static const double MinThickness = 0.001;
+ double minX, maxX, minY, maxY, minZ, maxZ;
+ minX = minY = minZ = std::numeric_limits<double>::max();
+ maxX = maxY = maxZ = std::numeric_limits<double>::min();
+
+ // Loop over all vertices and determine minima and maxima on each axis
+ for (const auto &vertex : vertices) {
+ auto vx = vertex.X();
+ auto vy = vertex.Y();
+ auto vz = vertex.Z();
+
+ minX = std::min(minX, vx);
+ maxX = std::max(maxX, vx);
+ minY = std::min(minY, vy);
+ maxY = std::max(maxY, vy);
+ minZ = std::min(minZ, vz);
+ maxZ = std::max(maxZ, vz);
+ }
+ if (minX == maxX)
+ maxX += MinThickness;
+ if (minY == maxY)
+ maxY += MinThickness;
+ if (minZ == maxZ)
+ maxZ += MinThickness;
+
+ // Cache bounding box, so we do not need to repeat calculation
+ cacheBB = BoundingBox(maxX, maxY, maxZ, minX, minY, minZ);
+ }
+
+ return cacheBB;
+}
+
+/**
+ * From vertices calculates the bounding box. Returns them back in max and min
+ * points as well as mutated BB object.
+ *
+ * @param vertices :: vertices to create BB from
+ * @param cacheBB :: mutable BB object to write to.
+ * @param xmax :: Maximum value for the bounding box in x direction
+ * @param ymax :: Maximum value for the bounding box in y direction
+ * @param zmax :: Maximum value for the bounding box in z direction
+ * @param xmin :: Minimum value for the bounding box in x direction
+ * @param ymin :: Minimum value for the bounding box in y direction
+ * @param zmin :: Minimum value for the bounding box in z direction
+ */
+void getBoundingBox(const std::vector<Kernel::V3D> &vertices,
+ BoundingBox &cacheBB, double &xmax, double &ymax,
+ double &zmax, double &xmin, double &ymin, double &zmin) {
+ auto bb = getBoundingBox(vertices, cacheBB);
+ xmax = bb.xMax();
+ xmin = bb.xMin();
+ ymax = bb.yMax();
+ ymin = bb.yMin();
+ zmax = bb.zMax();
+ zmin = bb.zMin();
+}
+
+} // namespace MeshObjectCommon
+} // namespace Geometry
+} // namespace Mantid
diff --git a/Framework/Geometry/test/ComponentInfoBankHelpersTest.h b/Framework/Geometry/test/ComponentInfoBankHelpersTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..76b0486d3cb0a14ef59e8e2c1da009c95d3fed3a
--- /dev/null
+++ b/Framework/Geometry/test/ComponentInfoBankHelpersTest.h
@@ -0,0 +1,75 @@
+#ifndef MANTID_GEOMETRY_COMPONENTINFOBANKHELPERSTEST_H_
+#define MANTID_GEOMETRY_COMPONENTINFOBANKHELPERSTEST_H_
+
+#include <cxxtest/TestSuite.h>
+
+#include "MantidGeometry/Instrument/ComponentInfo.h"
+#include "MantidGeometry/Instrument/ComponentInfoBankHelpers.h"
+#include "MantidGeometry/Instrument/DetectorInfo.h"
+#include "MantidGeometry/Instrument/GridDetector.h"
+#include "MantidGeometry/Instrument/InstrumentVisitor.h"
+#include "MantidTestHelpers/ComponentCreationHelper.h"
+#include <boost/make_shared.hpp>
+
+using namespace Mantid;
+using namespace Mantid::Kernel;
+using namespace Mantid::Geometry;
+using namespace Mantid::Geometry::ComponentInfoBankHelpers;
+
+class ComponentInfoBankHelpersTest : 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 ComponentInfoBankHelpersTest *createSuite() {
+ return new ComponentInfoBankHelpersTest();
+ }
+ static void destroySuite(ComponentInfoBankHelpersTest *suite) {
+ delete suite;
+ }
+
+ void test_DetectorFixedInBankTrueForRectangularBank() {
+ auto rectInstr =
+ ComponentCreationHelper::createTestInstrumentRectangular(1, 2);
+ auto wrappers = InstrumentVisitor::makeWrappers(*rectInstr);
+ const auto &componentInfo = *wrappers.first;
+
+ TS_ASSERT(isDetectorFixedInBank(componentInfo, 0));
+ }
+
+ void test_DetectorFixedInBankFalseForNonStructuredBank() {
+ auto instr = ComponentCreationHelper::createTestInstrumentCylindrical(1);
+ auto wrappers = InstrumentVisitor::makeWrappers(*instr);
+ const auto &componentInfo = *wrappers.first;
+
+ TS_ASSERT(!isDetectorFixedInBank(componentInfo, 0));
+ }
+
+ void test_DetectorFixedInBankFalseForMonitor() {
+ auto instr = ComponentCreationHelper::createTestInstrumentCylindrical(1);
+ auto det = new Detector("MyTestMonitor", 10, instr.get());
+ auto shape = ComponentCreationHelper::createCuboid(0.001, 0.001, 0.001);
+ det->setShape(shape);
+ det->setPos(V3D(0, 0, 0));
+ det->setRot(Quat());
+
+ instr->add(det);
+ instr->markAsMonitor(det);
+
+ auto wrappers = InstrumentVisitor::makeWrappers(*instr);
+ const auto &componentInfo = *wrappers.first;
+
+ auto index = componentInfo.indexOfAny("MyTestMonitor");
+
+ TS_ASSERT(!isDetectorFixedInBank(componentInfo, index));
+ }
+
+ void test_DetectorFixedInBankFalseForNonDetectorComponent() {
+ auto instr = ComponentCreationHelper::createTestInstrumentCylindrical(1);
+ auto wrappers = InstrumentVisitor::makeWrappers(*instr);
+ const auto &componentInfo = *wrappers.first;
+
+ TS_ASSERT(!isDetectorFixedInBank(componentInfo, componentInfo.root()));
+ }
+};
+
+#endif /* MANTID_GEOMETRY_COMPONENTINFOBANKHELPERSTEST_H_ */
\ No newline at end of file
diff --git a/Framework/Geometry/test/MeshObject2DTest.h b/Framework/Geometry/test/MeshObject2DTest.h
index e9cc20805bba67f87942f10a4259fccf8923b7d0..7d0f1a2e79b0eb6a83b060929baf37a40e4bde67 100644
--- a/Framework/Geometry/test/MeshObject2DTest.h
+++ b/Framework/Geometry/test/MeshObject2DTest.h
@@ -202,6 +202,68 @@ public:
TS_ASSERT_EQUALS(1.0, mesh.distanceToPlane(V3D{0, 0.5, 1}));
}
+ void test_solidAngle_side_on() {
+ using namespace Mantid::Kernel;
+ auto mesh = makeSimpleTriangleMesh();
+ auto solidAngle = mesh.solidAngle(
+ V3D{0, 2, 0}); // observer is in plane of triangle, outside the triangle
+ TS_ASSERT_EQUALS(solidAngle, 0); // seen side-on solid angle is 0
+ }
+ void test_square_solid_angle() {
+
+ // Unit square inside unit cube. Any cube face will have solid angle 1/6th
+ // of total 4pi steradians. Observer at origin.
+
+ double expected = 2.0 * M_PI / 3.0; // 4pi/6
+ // Unit square at distance cos(M_PI / 4) from observer
+ double unitSphereRadius = 1;
+ double halfSideLength = unitSphereRadius * sin(M_PI / 4);
+ double observerDistance = unitSphereRadius * cos(M_PI / 4);
+ std::vector<V3D> vertices = {
+ V3D{-halfSideLength, -halfSideLength, observerDistance},
+ V3D{-halfSideLength, halfSideLength, observerDistance},
+ V3D{halfSideLength, halfSideLength, observerDistance},
+ V3D{halfSideLength, -halfSideLength, observerDistance}};
+ std::vector<uint16_t> triangles{2, 1, 0, 0, 3, 2};
+ MeshObject2D mesh(triangles, vertices, Mantid::Kernel::Material{});
+ double solidAngle = mesh.solidAngle(V3D{0, 0, 0});
+ TS_ASSERT_DELTA(solidAngle, expected, 1e-3);
+
+ // Only the positive solid angle is counted. Observe from the other side and
+ // solid angle is zero.
+ solidAngle = mesh.solidAngle(V3D{0, 0, 2 * observerDistance});
+ TS_ASSERT_DELTA(solidAngle, 0, 1e-3);
+ }
+
+ void test_solidAngle_scaled() {
+ // Unit square inside unit cube. Any cube face will have solid angle 1/6th
+ // of total 4pi steradians. Observer at origin.
+
+ double expected = 2.0 * M_PI / 3.0; // 4pi/6
+ // Unit square at distance 0.5 from observer
+ double unitSphereRadius = 1;
+ double halfSideLength = unitSphereRadius * sin(M_PI / 4);
+ double observerDistance = unitSphereRadius * cos(M_PI / 4);
+ std::vector<V3D> vertices = {
+ V3D{-halfSideLength, -halfSideLength, observerDistance},
+ V3D{-halfSideLength, halfSideLength, observerDistance},
+ V3D{halfSideLength, halfSideLength, observerDistance},
+ V3D{halfSideLength, -halfSideLength, observerDistance}};
+ std::vector<uint16_t> triangles{2, 1, 0, 0, 3, 2};
+ // Scaling square uniformly (and reducing distance to origin by same
+ // factor), yields same angular area 4pi/6
+ V3D scaleFactor{0.5, 0.5, 0.5};
+ MeshObject2D mesh(triangles, vertices, Mantid::Kernel::Material{});
+ double solidAngle = mesh.solidAngle(V3D{0, 0, 0}, scaleFactor);
+ TS_ASSERT_DELTA(solidAngle, expected, 1e-3);
+
+ // Scaling square uniformly (and increasing distance to origin by same
+ // factor), yields same angular area 4pi/6
+ scaleFactor = {2, 2, 2};
+ solidAngle = mesh.solidAngle(V3D{0, 0, 0}, scaleFactor);
+ TS_ASSERT_DELTA(solidAngle, expected, 1e-3);
+ }
+
void test_isValid_multi_triangle() {
// Make 2 Triangles bounded by the specified V3Ds
@@ -216,36 +278,28 @@ public:
TSM_ASSERT("Just outside", !mesh.isValid(V3D{1, 1 + delta, 0}));
}
- void test_isOnTriangle() {
- auto p1 = V3D{-1, -1, 0};
- auto p2 = V3D{1, -1, 0};
- auto p3 = V3D{0, 1, 0};
- TS_ASSERT(MeshObject2D::isOnTriangle(V3D{0, 0, 0}, p1, p2, p3));
- TS_ASSERT(MeshObject2D::isOnTriangle(p1, p1, p2, p3));
- TS_ASSERT(MeshObject2D::isOnTriangle(p2, p1, p2, p3));
- TS_ASSERT(MeshObject2D::isOnTriangle(p3, p1, p2, p3));
- TS_ASSERT(!MeshObject2D::isOnTriangle(p1 - V3D(0.0001, 0, 0), p1, p2, p3));
- TS_ASSERT(!MeshObject2D::isOnTriangle(p1 - V3D(0, 0.0001, 0), p1, p2, p3));
- TS_ASSERT(!MeshObject2D::isOnTriangle(p2 + V3D(0.0001, 0, 0), p1, p2, p3));
- TS_ASSERT(!MeshObject2D::isOnTriangle(p2 - V3D(0, 0.0001, 0), p1, p2, p3));
- TS_ASSERT(!MeshObject2D::isOnTriangle(p3 + V3D(0.0001, 0, 0), p1, p2, p3));
- TS_ASSERT(!MeshObject2D::isOnTriangle(p3 + V3D(0, 0.0001, 0), p1, p2, p3));
- }
-
void test_interceptSurface() {
auto mesh = makeSimpleTriangleMesh();
+ // Track goes through triangle body
Mantid::Geometry::Track onTargetTrack(V3D{0.5, 0.5, -1},
V3D{0, 0, 1} /*along z*/);
TS_ASSERT_EQUALS(mesh.interceptSurface(onTargetTrack), 1);
TS_ASSERT_EQUALS(onTargetTrack.count(), 1);
+ // Track completely misses
Mantid::Geometry::Track missTargetTrack(
V3D{50, 0.5, -1},
V3D{0, 0, 1} /*along z*/); // Intersects plane but no triangles
TS_ASSERT_EQUALS(mesh.interceptSurface(missTargetTrack), 0);
TS_ASSERT_EQUALS(missTargetTrack.count(), 0);
+
+ // Track goes through edge
+ Mantid::Geometry::Track edgeTargetTrack(
+ V3D{0, 0, -1}, V3D{0, 0, 1} /*along z*/); // Passes through lower edge
+ TS_ASSERT_EQUALS(mesh.interceptSurface(edgeTargetTrack), 1);
+ TS_ASSERT_EQUALS(edgeTargetTrack.count(), 1);
}
void test_equals() {
@@ -278,32 +332,6 @@ public:
TS_ASSERT_EQUALS(a, *c);
}
- void test_solidAngle_side_on() {
- using namespace Mantid::Kernel;
-
- auto mesh = makeSimpleTriangleMesh();
- auto solidAngle = mesh.solidAngle(
- V3D{0, 2, 0}); // observer is in plane of triangle, outside the triangle
-
- TS_ASSERT_EQUALS(solidAngle, 0); // seen side-on solid angle is 0
- }
-
- void test_solidAngle() {
-
- double expected = M_PI / 3.0; // 0.5 * 4pi/6
- // Unit square at distance 0.5 from observer
- double unitSphereRadius = 1;
- double halfSideLength = unitSphereRadius * sin(M_PI / 4);
- double observerDistance = unitSphereRadius * cos(M_PI / 4);
- auto mesh = makeTrapezoidMesh(
- V3D{-halfSideLength, -halfSideLength, observerDistance},
- V3D{-halfSideLength, halfSideLength, observerDistance},
- V3D{halfSideLength, halfSideLength, observerDistance},
- V3D{halfSideLength, -halfSideLength, observerDistance});
- double solidAngle = mesh.solidAngle(V3D{0, 0, 0});
- TS_ASSERT_DELTA(solidAngle, expected, 1e-3);
- }
-
void test_boundingBox() {
auto mesh = makeSimpleTriangleMesh(); // Lies in z plane
auto boundingBox = mesh.getBoundingBox();
diff --git a/Framework/Geometry/test/MeshObjectCommonTest.h b/Framework/Geometry/test/MeshObjectCommonTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..6799b51410a03c67d7dd6798c74bd4fc360067d1
--- /dev/null
+++ b/Framework/Geometry/test/MeshObjectCommonTest.h
@@ -0,0 +1,123 @@
+#ifndef MANTID_GEOMETRY_MESHOBJECTCOMMONTEST_H_
+#define MANTID_GEOMETRY_MESHOBJECTCOMMONTEST_H_
+
+#include <cxxtest/TestSuite.h>
+
+#include "MantidGeometry/Objects/MeshObjectCommon.h"
+#include "MantidKernel/V3D.h"
+
+using namespace Mantid::Geometry;
+using Mantid::Kernel::V3D;
+
+class MeshObjectCommonTest : 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 MeshObjectCommonTest *createSuite() {
+ return new MeshObjectCommonTest();
+ }
+ static void destroySuite(MeshObjectCommonTest *suite) { delete suite; }
+
+ void test_ray_intersect_triangle_simple() {
+
+ const V3D start{0, 0, -1};
+ const V3D direction{0, 0, 1};
+ const V3D vertex1{-1, 0, 0};
+ const V3D vertex2{1, 0, 0};
+ const V3D vertex3{1, 1, 0};
+ V3D intersectionPoint;
+ int entryExitFlag;
+
+ // Direct intersection through triangle body
+ auto doesIntersect = MeshObjectCommon::rayIntersectsTriangle(
+ start, direction, vertex1, vertex2, vertex3, intersectionPoint,
+ entryExitFlag);
+ TS_ASSERT(doesIntersect);
+ TS_ASSERT_EQUALS(entryExitFlag, -1);
+ TS_ASSERT((start + (direction * 1) - intersectionPoint).norm2() < 1e-9);
+ }
+
+ void test_v3d_to_array() {
+ std::vector<V3D> input{{1, 2, 3}, {4, 5, 6}};
+ auto output = MeshObjectCommon::getVertices(input);
+ TS_ASSERT_EQUALS(output, (std::vector<double>{1, 2, 3, 4, 5, 6}));
+ }
+
+ void test_ray_intersect_triangle_edge() {
+
+ const V3D direction{0, 0, 1};
+ const V3D vertex1{-1, 0, 0};
+ const V3D vertex2{1, 0, 0};
+ const V3D vertex3{1, 1, 0};
+ V3D intersectionPoint;
+ int entryExitFlag;
+
+ // Test ray going through vertex of triangle
+ V3D start = vertex1 - direction;
+ auto doesIntersect = MeshObjectCommon::rayIntersectsTriangle(
+ start, direction, vertex1, vertex2, vertex3, intersectionPoint,
+ entryExitFlag);
+ TS_ASSERT(doesIntersect);
+
+ // Check another vertex
+ start = vertex3 - direction;
+ doesIntersect = MeshObjectCommon::rayIntersectsTriangle(
+ start, direction, vertex1, vertex2, vertex3, intersectionPoint,
+ entryExitFlag);
+ TS_ASSERT(doesIntersect);
+
+ // Check an edge
+ start = (vertex1 + vertex2) / 2 - direction; // along edge
+ doesIntersect = MeshObjectCommon::rayIntersectsTriangle(
+ start, direction, vertex1, vertex2, vertex3, intersectionPoint,
+ entryExitFlag);
+ TS_ASSERT(doesIntersect);
+
+ // Sanity check just outside.
+ start = (vertex1 + vertex2) / 2 - direction; // along edge
+ start += V3D(0, -1e-6, 0); // minor shift down in y
+ doesIntersect = MeshObjectCommon::rayIntersectsTriangle(
+ start, direction, vertex1, vertex2, vertex3, intersectionPoint,
+ entryExitFlag);
+ TS_ASSERT(!doesIntersect);
+ }
+
+ void test_no_ray_intersect_triangle_when_triangle_behind() {
+ V3D start{0, 0, -1};
+ V3D direction{0, 0, 1};
+ const V3D vertex1{-1, 0, 0};
+ const V3D vertex2{1, 0, 0};
+ const V3D vertex3{1, 1, 0};
+ V3D intersectionPoint;
+ int entryExitFlag;
+ // Triangle now behind start. Should not intersect
+ start = V3D{0, 0, 10};
+ auto doesIntersect = MeshObjectCommon::rayIntersectsTriangle(
+ start, direction, vertex1, vertex2, vertex3, intersectionPoint,
+ entryExitFlag);
+ TS_ASSERT(!doesIntersect);
+ }
+ void test_isOnTriangle() {
+ auto p1 = V3D{-1, -1, 0};
+ auto p2 = V3D{1, -1, 0};
+ auto p3 = V3D{0, 1, 0};
+ TS_ASSERT(MeshObjectCommon::isOnTriangle(V3D{0, 0, 0}, p1, p2, p3));
+ TS_ASSERT(MeshObjectCommon::isOnTriangle(p1, p1, p2, p3));
+ TS_ASSERT(MeshObjectCommon::isOnTriangle(p2, p1, p2, p3));
+ TS_ASSERT(MeshObjectCommon::isOnTriangle(p3, p1, p2, p3));
+ TS_ASSERT(
+ !MeshObjectCommon::isOnTriangle(p1 - V3D(0.0001, 0, 0), p1, p2, p3));
+ TS_ASSERT(
+ !MeshObjectCommon::isOnTriangle(p1 - V3D(0, 0.0001, 0), p1, p2, p3));
+ TS_ASSERT(
+ !MeshObjectCommon::isOnTriangle(p2 + V3D(0.0001, 0, 0), p1, p2, p3));
+ TS_ASSERT(
+ !MeshObjectCommon::isOnTriangle(p2 - V3D(0, 0.0001, 0), p1, p2, p3));
+ TS_ASSERT(
+ !MeshObjectCommon::isOnTriangle(p3 + V3D(0.0001, 0, 0), p1, p2, p3));
+ TS_ASSERT(
+ !MeshObjectCommon::isOnTriangle(p3 + V3D(0, 0.0001, 0), p1, p2, p3));
+ }
+};
+
+#endif /* MANTID_GEOMETRY_MESHOBJECTCOMMONTEST_H_ */
diff --git a/Framework/Geometry/test/MeshObjectTest.h b/Framework/Geometry/test/MeshObjectTest.h
index 905425850597edf6103a3814f709f7a6be01c64e..3d1d8d7351919b4be687ee51f33e313275bc506f 100644
--- a/Framework/Geometry/test/MeshObjectTest.h
+++ b/Framework/Geometry/test/MeshObjectTest.h
@@ -912,8 +912,8 @@ public:
Test solid angle calculation for a cube.
*/
{
- auto geom_obj = createCube(1.0);
- double satol = 1e-3; // tolerance for solid angle
+ auto geom_obj = createCube(1.0); // Cube centre at 0.5, 0.5, 0.5
+ double satol = 1e-3; // tolerance for solid angle
// solid angle at distance 0.5 should be 4pi/6 by symmetry
TS_ASSERT_DELTA(geom_obj->solidAngle(V3D(1.5, 0.5, 0.5)), M_PI * 2.0 / 3.0,
diff --git a/Framework/Geometry/test/ReferenceFrameTest.h b/Framework/Geometry/test/ReferenceFrameTest.h
index 05d40757ed4ce2cff882a81594b2f2b3ab533804..3a6f2d69c8aa9ba3671d7befa98737cb3714b5f2 100644
--- a/Framework/Geometry/test/ReferenceFrameTest.h
+++ b/Framework/Geometry/test/ReferenceFrameTest.h
@@ -146,6 +146,32 @@ public:
TS_ASSERT_EQUALS(1, z_vec[2]);
}
+ void testGetHorizontalDirectionVector() {
+ ReferenceFrame z1(Y, X, Right, "source");
+ V3D z_vec = z1.vecPointingHorizontal();
+ TS_ASSERT_EQUALS(0, z_vec[0]);
+ TS_ASSERT_EQUALS(0, z_vec[1]);
+ TS_ASSERT_EQUALS(1, z_vec[2]);
+
+ ReferenceFrame z2(X, Y, Right, "source");
+ z_vec = z2.vecPointingHorizontal();
+ TS_ASSERT_EQUALS(0, z_vec[0]);
+ TS_ASSERT_EQUALS(0, z_vec[1]);
+ TS_ASSERT_EQUALS(1, z_vec[2]);
+
+ ReferenceFrame y(X, Z, Right, "source");
+ V3D y_vec = y.vecPointingHorizontal();
+ TS_ASSERT_EQUALS(0, y_vec[0]);
+ TS_ASSERT_EQUALS(1, y_vec[1]);
+ TS_ASSERT_EQUALS(0, y_vec[2]);
+
+ ReferenceFrame x(Y, Z, Right, "source");
+ V3D x_vec = x.vecPointingHorizontal();
+ TS_ASSERT_EQUALS(1, x_vec[0]);
+ TS_ASSERT_EQUALS(0, x_vec[1]);
+ TS_ASSERT_EQUALS(0, x_vec[2]);
+ }
+
void testGetThetaSignAxisVector() {
// Default constructor, theta-sign axis is the same as up
ReferenceFrame y(Y, X, Right, "source");
diff --git a/Framework/PythonInterface/mantid/plots/__init__.py b/Framework/PythonInterface/mantid/plots/__init__.py
index 7f1db67bd3189a829c18e81cba3f807583fc14e4..f9103522c14813117c3b80daf06d3dbe0f806591 100644
--- a/Framework/PythonInterface/mantid/plots/__init__.py
+++ b/Framework/PythonInterface/mantid/plots/__init__.py
@@ -73,19 +73,19 @@ class MantidAxes(Axes):
'''
If the **mantid** projection is chosen, it can be
used the same as :py:meth:`matplotlib.axes.Axes.scatter` for arrays,
- or it can be used to plot :class:`mantid.api.MatrixWorkspace`
+ or it can be used to plot :class:`mantid.api.MatrixWorkspace`
or :class:`mantid.api.IMDHistoWorkspace`. You can have something like::
-
+
import matplotlib.pyplot as plt
from mantid import plots
-
+
...
-
+
fig, ax = plt.subplots(subplot_kw={'projection':'mantid'})
ax.scatter(workspace,'rs',specNum=1) #for workspaces
ax.scatter(x,y,'bo') #for arrays
fig.show()
-
+
For keywords related to workspaces, see :func:`mantid.plots.plotfunctions.scatter`
'''
if mantid.plots.helperfunctions.validate_args(*args):
@@ -98,19 +98,19 @@ class MantidAxes(Axes):
'''
If the **mantid** projection is chosen, it can be
used the same as :py:meth:`matplotlib.axes.Axes.errorbar` for arrays,
- or it can be used to plot :class:`mantid.api.MatrixWorkspace`
+ or it can be used to plot :class:`mantid.api.MatrixWorkspace`
or :class:`mantid.api.IMDHistoWorkspace`. You can have something like::
-
+
import matplotlib.pyplot as plt
from mantid import plots
-
+
...
-
+
fig, ax = plt.subplots(subplot_kw={'projection':'mantid'})
ax.errorbar(workspace,'rs',specNum=1) #for workspaces
ax.errorbar(x,y,yerr,'bo') #for arrays
fig.show()
-
+
For keywords related to workspaces, see :func:`mantid.plots.plotfunctions.errorbar`
'''
if mantid.plots.helperfunctions.validate_args(*args):
@@ -123,19 +123,19 @@ class MantidAxes(Axes):
'''
If the **mantid** projection is chosen, it can be
used the same as :py:meth:`matplotlib.axes.Axes.pcolor` for arrays,
- or it can be used to plot :class:`mantid.api.MatrixWorkspace`
+ or it can be used to plot :class:`mantid.api.MatrixWorkspace`
or :class:`mantid.api.IMDHistoWorkspace`. You can have something like::
-
+
import matplotlib.pyplot as plt
from mantid import plots
-
+
...
-
+
fig, ax = plt.subplots(subplot_kw={'projection':'mantid'})
ax.pcolor(workspace) #for workspaces
ax.pcolor(x,y,C) #for arrays
fig.show()
-
+
For keywords related to workspaces, see :func:`mantid.plots.plotfunctions.pcolor`
'''
if mantid.plots.helperfunctions.validate_args(*args):
@@ -148,19 +148,19 @@ class MantidAxes(Axes):
'''
If the **mantid** projection is chosen, it can be
used the same as :py:meth:`matplotlib.axes.Axes.pcolorfast` for arrays,
- or it can be used to plot :class:`mantid.api.MatrixWorkspace`
+ or it can be used to plot :class:`mantid.api.MatrixWorkspace`
or :class:`mantid.api.IMDHistoWorkspace`. You can have something like::
-
+
import matplotlib.pyplot as plt
from mantid import plots
-
+
...
-
+
fig, ax = plt.subplots(subplot_kw={'projection':'mantid'})
ax.pcolorfast(workspace) #for workspaces
ax.pcolorfast(x,y,C) #for arrays
fig.show()
-
+
For keywords related to workspaces, see :func:`mantid.plots.plotfunctions.pcolorfast`
'''
if mantid.plots.helperfunctions.validate_args(*args):
@@ -173,19 +173,19 @@ class MantidAxes(Axes):
'''
If the **mantid** projection is chosen, it can be
used the same as :py:meth:`matplotlib.axes.Axes.pcolormesh` for arrays,
- or it can be used to plot :class:`mantid.api.MatrixWorkspace`
+ or it can be used to plot :class:`mantid.api.MatrixWorkspace`
or :class:`mantid.api.IMDHistoWorkspace`. You can have something like::
-
+
import matplotlib.pyplot as plt
from mantid import plots
-
+
...
-
+
fig, ax = plt.subplots(subplot_kw={'projection':'mantid'})
ax.pcolormesh(workspace) #for workspaces
ax.pcolormesh(x,y,C) #for arrays
fig.show()
-
+
For keywords related to workspaces, see :func:`mantid.plots.plotfunctions.pcolormesh`
'''
if mantid.plots.helperfunctions.validate_args(*args):
@@ -194,23 +194,48 @@ class MantidAxes(Axes):
else:
return Axes.pcolormesh(self, *args, **kwargs)
+ def imshow(self, *args, **kwargs):
+ '''
+ If the **mantid** projection is chosen, it can be
+ used the same as :py:meth:`matplotlib.axes.Axes.imshow` for arrays,
+ or it can be used to plot :class:`mantid.api.MatrixWorkspace`
+ or :class:`mantid.api.IMDHistoWorkspace`. You can have something like::
+
+ import matplotlib.pyplot as plt
+ from mantid import plots
+
+ ...
+
+ fig, ax = plt.subplots(subplot_kw={'projection':'mantid'})
+ ax.imshow(workspace) #for workspaces
+ ax.imshow(C) #for arrays
+ fig.show()
+
+ For keywords related to workspaces, see :func:`mantid.plots.plotfunctions.imshow`
+ '''
+ if mantid.plots.helperfunctions.validate_args(*args):
+ mantid.kernel.logger.debug('using mantid.plots.plotfunctions')
+ return mantid.plots.plotfunctions.imshow(self, *args, **kwargs)
+ else:
+ return Axes.imshow(self, *args, **kwargs)
+
def contour(self, *args, **kwargs):
'''
If the **mantid** projection is chosen, it can be
used the same as :py:meth:`matplotlib.axes.Axes.contour` for arrays,
- or it can be used to plot :class:`mantid.api.MatrixWorkspace`
+ or it can be used to plot :class:`mantid.api.MatrixWorkspace`
or :class:`mantid.api.IMDHistoWorkspace`. You can have something like::
-
+
import matplotlib.pyplot as plt
from mantid import plots
-
+
...
-
+
fig, ax = plt.subplots(subplot_kw={'projection':'mantid'})
ax.contour(workspace) #for workspaces
ax.contour(x,y,z) #for arrays
fig.show()
-
+
For keywords related to workspaces, see :func:`mantid.plots.plotfunctions.contour`
'''
if mantid.plots.helperfunctions.validate_args(*args):
@@ -223,19 +248,19 @@ class MantidAxes(Axes):
'''
If the **mantid** projection is chosen, it can be
used the same as :py:meth:`matplotlib.axes.Axes.contourf` for arrays,
- or it can be used to plot :class:`mantid.api.MatrixWorkspace`
+ or it can be used to plot :class:`mantid.api.MatrixWorkspace`
or :class:`mantid.api.IMDHistoWorkspace`. You can have something like::
-
+
import matplotlib.pyplot as plt
from mantid import plots
-
+
...
-
+
fig, ax = plt.subplots(subplot_kw={'projection':'mantid'})
ax.contourf(workspace) #for workspaces
ax.contourf(x,y,z) #for arrays
fig.show()
-
+
For keywords related to workspaces, see :func:`mantid.plots.plotfunctions.contourf`
'''
if mantid.plots.helperfunctions.validate_args(*args):
@@ -248,19 +273,19 @@ class MantidAxes(Axes):
'''
If the **mantid** projection is chosen, it can be
used the same as :py:meth:`matplotlib.axes.Axes.tripcolor` for arrays,
- or it can be used to plot :class:`mantid.api.MatrixWorkspace`
+ or it can be used to plot :class:`mantid.api.MatrixWorkspace`
or :class:`mantid.api.IMDHistoWorkspace`. You can have something like::
-
+
import matplotlib.pyplot as plt
from mantid import plots
-
+
...
-
+
fig, ax = plt.subplots(subplot_kw={'projection':'mantid'})
ax.tripcolor(workspace) #for workspaces
ax.tripcolor(x,y,C) #for arrays
fig.show()
-
+
For keywords related to workspaces, see :func:`mantid.plots.plotfunctions.tripcolor`
'''
if mantid.plots.helperfunctions.validate_args(*args):
@@ -273,19 +298,19 @@ class MantidAxes(Axes):
'''
If the **mantid** projection is chosen, it can be
used the same as :py:meth:`matplotlib.axes.Axes.tricontour` for arrays,
- or it can be used to plot :class:`mantid.api.MatrixWorkspace`
+ or it can be used to plot :class:`mantid.api.MatrixWorkspace`
or :class:`mantid.api.IMDHistoWorkspace`. You can have something like::
-
+
import matplotlib.pyplot as plt
from mantid import plots
-
+
...
-
+
fig, ax = plt.subplots(subplot_kw={'projection':'mantid'})
ax.tricontour(workspace) #for workspaces
ax.tricontour(x,y,z) #for arrays
fig.show()
-
+
For keywords related to workspaces, see :func:`mantid.plots.plotfunctions.tricontour`
'''
if mantid.plots.helperfunctions.validate_args(*args):
@@ -298,19 +323,19 @@ class MantidAxes(Axes):
'''
If the **mantid** projection is chosen, it can be
used the same as :py:meth:`matplotlib.axes.Axes.tricontourf` for arrays,
- or it can be used to plot :class:`mantid.api.MatrixWorkspace`
+ or it can be used to plot :class:`mantid.api.MatrixWorkspace`
or :class:`mantid.api.IMDHistoWorkspace`. You can have something like::
-
+
import matplotlib.pyplot as plt
from mantid import plots
-
+
...
-
+
fig, ax = plt.subplots(subplot_kw={'projection':'mantid'})
ax.tricontourf(workspace) #for workspaces
ax.tricontourf(x,y,z) #for arrays
fig.show()
-
+
For keywords related to workspaces, see :func:`mantid.plots.plotfunctions.tricontourf`
'''
if mantid.plots.helperfunctions.validate_args(*args):
diff --git a/Framework/PythonInterface/mantid/plots/plotfunctions.py b/Framework/PythonInterface/mantid/plots/plotfunctions.py
index f345988a42a48b16d3c9197b96afa3c0960c2f09..5e797706b22f6b172d5f40d903e452c90c773700 100644
--- a/Framework/PythonInterface/mantid/plots/plotfunctions.py
+++ b/Framework/PythonInterface/mantid/plots/plotfunctions.py
@@ -357,6 +357,42 @@ def pcolormesh(axes, workspace, *args, **kwargs):
return axes.pcolormesh(x, y, z, *args, **kwargs)
+def imshow(axes, workspace, *args, **kwargs):
+ '''
+ Essentially the same as :meth:`matplotlib.axes.Axes.pcolormesh`.
+
+ :param axes: :class:`matplotlib.axes.Axes` object that will do the plotting
+ :param workspace: :class:`mantid.api.MatrixWorkspace` or :class:`mantid.api.IMDHistoWorkspace`
+ to extract the data from
+ :param distribution: ``None`` (default) asks the workspace. ``False`` means
+ divide by bin width. ``True`` means do not divide by bin width.
+ Applies only when the the matrix workspace is a histogram.
+ :param normalization: ``None`` (default) ask the workspace. Applies to MDHisto workspaces. It can override
+ the value from displayNormalizationHisto. It checks only if
+ the normalization is mantid.api.MDNormalization.NumEventsNormalization
+ :param axisaligned: ``False`` (default). If ``True``, or if the workspace has a variable
+ number of bins, the polygons will be aligned with the axes
+ '''
+ _setLabels2D(axes, workspace)
+ if isinstance(workspace, mantid.dataobjects.MDHistoWorkspace):
+ (normalization, kwargs) = get_normalization(workspace, **kwargs)
+ x, y, z = get_md_data2d_bin_bounds(workspace, normalization)
+ else:
+ (uneven_bins, kwargs) = get_data_uneven_flag(workspace, **kwargs)
+ (distribution, kwargs) = get_distribution(workspace, **kwargs)
+ if uneven_bins:
+ raise Exception('Variable number of bins is not supported by imshow.')
+ else:
+ (x, y, z) = get_matrix_2d_data(workspace, distribution, histogram2D=True)
+
+ diffs = numpy.diff(x, axis=1)
+ x_spacing_equal = numpy.alltrue(diffs == diffs[0])
+ diffs = numpy.diff(y, axis=0)
+ y_spacing_equal = numpy.alltrue(diffs == diffs[0])
+ if not x_spacing_equal or not y_spacing_equal:
+ raise Exception('Unevenly spaced bins are not supported by imshow')
+ kwargs['extent'] = [x[0,0],x[0,-1],y[0,0],y[-1,0]]
+ return axes.imshow(z, *args, **kwargs)
def tripcolor(axes, workspace, *args, **kwargs):
'''
diff --git a/Framework/PythonInterface/plugins/algorithms/IntegratePeaksProfileFitting.py b/Framework/PythonInterface/plugins/algorithms/IntegratePeaksProfileFitting.py
index f5d85f55649179a454bcde8a72f1302468fa5d33..0238c745bf200a111c53bc4eb1711489825db3fd 100644
--- a/Framework/PythonInterface/plugins/algorithms/IntegratePeaksProfileFitting.py
+++ b/Framework/PythonInterface/plugins/algorithms/IntegratePeaksProfileFitting.py
@@ -245,6 +245,7 @@ class IntegratePeaksProfileFitting(PythonAlgorithm):
sigX0Params, sigY0, sigP0Params = self.getBVGInitialGuesses(peaks_ws, strongPeakParams_ws)
for fitNumber, peakNumber in enumerate(peaksToFit):#range(peaks_ws.getNumberPeaks()):
+ peakNumber = int(peakNumber)
peak = peaks_ws_out.getPeak(peakNumber)
progress.report(' ')
if peak.getRunNumber() != MDdata.getExperimentInfo(0).getRunNumber():
diff --git a/Framework/PythonInterface/plugins/algorithms/ReflectometryReductionOneLiveData.py b/Framework/PythonInterface/plugins/algorithms/ReflectometryReductionOneLiveData.py
index 04370d79b0e332bfa02be4a2d1e71caea0057069..9a03ee3a086b858914503a3433c02226c4ba09e1 100644
--- a/Framework/PythonInterface/plugins/algorithms/ReflectometryReductionOneLiveData.py
+++ b/Framework/PythonInterface/plugins/algorithms/ReflectometryReductionOneLiveData.py
@@ -46,7 +46,7 @@ class ReflectometryReductionOneLiveData(DataProcessorAlgorithm):
'MonitorIntegrationWavelengthMin', 'MonitorIntegrationWavelengthMax',
'NormalizeByIntegratedMonitors', 'FirstTransmissionRun',
'SecondTransmissionRun', 'Params', 'StartOverlap', 'EndOverlap',
- 'StrictSpectrumChecking', 'CorrectionAlgorithm', 'Polynomial', 'C0', 'C1',
+ 'CorrectionAlgorithm', 'Polynomial', 'C0', 'C1',
'MomentumTransferMin', 'MomentumTransferStep', 'MomentumTransferMax',
'PolarizationAnalysis', 'Pp', 'Ap', 'Rho', 'Alpha', 'Debug', 'OutputWorkspace']
self.copyProperties('ReflectometryReductionOneAuto', self._child_properties)
diff --git a/Framework/PythonInterface/test/python/mantid/plots/plotfunctionsTest.py b/Framework/PythonInterface/test/python/mantid/plots/plotfunctionsTest.py
index 08a641d7da19b595ecdb3a9019b68cdcc253ad78..f815504db44a0af3ee3ce1026b9581a8a6e45ccc 100644
--- a/Framework/PythonInterface/test/python/mantid/plots/plotfunctionsTest.py
+++ b/Framework/PythonInterface/test/python/mantid/plots/plotfunctionsTest.py
@@ -121,6 +121,7 @@ class PlotFunctionsTest(unittest.TestCase):
funcs.tripcolor(ax, self.ws2d_histo, vmin=0)
funcs.pcolormesh(ax, self.ws_MD_2d)
funcs.pcolorfast(ax, self.ws2d_point_uneven, vmin=-1)
+ funcs.imshow(ax, self.ws2d_histo)
def test_1d_plots_with_unplottable_type_raises_attributeerror(self):
table = CreateEmptyTableWorkspace()
diff --git a/Framework/TestHelpers/inc/MantidTestHelpers/IndirectFitDataCreationHelper.h b/Framework/TestHelpers/inc/MantidTestHelpers/IndirectFitDataCreationHelper.h
new file mode 100644
index 0000000000000000000000000000000000000000..ddce2d0ed52e0a33a216d7d83559289e143d6262
--- /dev/null
+++ b/Framework/TestHelpers/inc/MantidTestHelpers/IndirectFitDataCreationHelper.h
@@ -0,0 +1,81 @@
+#ifndef MANTID_INDIRECTFITDATACREATIONHELPER_H_
+#define MANTID_INDIRECTFITDATACREATIONHELPER_H_
+
+#include "MantidAPI/AnalysisDataService.h"
+#include "MantidAPI/MatrixWorkspace_fwd.h"
+#include "MantidHistogramData/BinEdges.h"
+
+#include <string>
+
+#include <boost/variant.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+
+namespace Mantid {
+namespace IndirectFitDataCreationHelper {
+
+/// Functions used in the creation of workspaces
+Mantid::API::MatrixWorkspace_sptr createWorkspace(int const &numberOfSpectra);
+Mantid::API::MatrixWorkspace_sptr createInstrumentWorkspace(int const &xLength,
+ int const &yLength);
+Mantid::API::MatrixWorkspace_sptr
+setWorkspaceEFixed(Mantid::API::MatrixWorkspace_sptr workspace,
+ int const &xLength);
+Mantid::API::MatrixWorkspace_sptr
+setWorkspaceBinEdges(Mantid::API::MatrixWorkspace_sptr workspace,
+ int const &yLength,
+ Mantid::HistogramData::BinEdges const &binEdges);
+Mantid::API::MatrixWorkspace_sptr
+setWorkspaceBinEdges(Mantid::API::MatrixWorkspace_sptr workspace,
+ int const &xLength, int const &yLength);
+Mantid::API::MatrixWorkspace_sptr
+setWorkspaceProperties(Mantid::API::MatrixWorkspace_sptr workspace,
+ int const &xLength, int const &yLength);
+Mantid::API::MatrixWorkspace_sptr
+createWorkspaceWithInstrument(int const &xLength, int const &yLength);
+
+/// Simple struct used to access features of the ADS
+/// No destructor so ensure you tearDown the ADS
+struct SetUpADSWithWorkspace {
+
+ template <typename T>
+ SetUpADSWithWorkspace(std::string const &inputWSName, T const &workspace) {
+ Mantid::API::AnalysisDataService::Instance().addOrReplace(inputWSName,
+ workspace);
+ }
+
+ template <typename T>
+ void addOrReplace(std::string const &workspaceName, T const &workspace) {
+ Mantid::API::AnalysisDataService::Instance().addOrReplace(workspaceName,
+ workspace);
+ }
+
+ bool doesExist(std::string const &workspaceName) {
+ return Mantid::API::AnalysisDataService::Instance().doesExist(
+ workspaceName);
+ }
+
+ Mantid::API::MatrixWorkspace_sptr
+ retrieveWorkspace(std::string const &workspaceName) {
+ return boost::dynamic_pointer_cast<Mantid::API::MatrixWorkspace>(
+ Mantid::API::AnalysisDataService::Instance().retrieve(workspaceName));
+ }
+};
+
+/// This is used to compare Spectra which is implemented as a boost::variant
+struct AreSpectraEqual : public boost::static_visitor<bool> {
+
+ template <typename T, typename U>
+ bool operator()(const T &, const U &) const {
+ return false; // cannot compare different types
+ }
+
+ template <typename T> bool operator()(const T &lhs, const T &rhs) const {
+ return lhs == rhs;
+ }
+};
+
+} // namespace IndirectFitDataCreationHelper
+} // namespace Mantid
+
+#endif // MANTID_INDIRECTFITDATACREATIONHELPER_H
diff --git a/Framework/TestHelpers/src/IndirectFitDataCreationHelper.cpp b/Framework/TestHelpers/src/IndirectFitDataCreationHelper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..83082b0c41ef340802cfdb8591cfd883832370ba
--- /dev/null
+++ b/Framework/TestHelpers/src/IndirectFitDataCreationHelper.cpp
@@ -0,0 +1,60 @@
+#include "MantidTestHelpers/IndirectFitDataCreationHelper.h"
+#include "MantidTestHelpers/WorkspaceCreationHelper.h"
+
+namespace Mantid {
+namespace IndirectFitDataCreationHelper {
+using namespace Mantid::API;
+
+MatrixWorkspace_sptr createWorkspace(int const &numberOfSpectra) {
+ return WorkspaceCreationHelper::create2DWorkspace(numberOfSpectra, 10);
+}
+
+MatrixWorkspace_sptr createInstrumentWorkspace(int const &xLength,
+ int const &yLength) {
+ return WorkspaceCreationHelper::create2DWorkspaceWithFullInstrument(
+ xLength, yLength - 1, false, false, true, "testInst");
+}
+
+MatrixWorkspace_sptr setWorkspaceEFixed(MatrixWorkspace_sptr workspace,
+ int const &xLength) {
+ for (int i = 0; i < xLength; ++i)
+ workspace->setEFixed((i + 1), 0.50);
+ return workspace;
+}
+
+MatrixWorkspace_sptr
+setWorkspaceBinEdges(MatrixWorkspace_sptr workspace, int const &yLength,
+ Mantid::HistogramData::BinEdges const &binEdges) {
+ for (int i = 0; i < yLength; ++i)
+ workspace->setBinEdges(i, binEdges);
+ return workspace;
+}
+
+MatrixWorkspace_sptr setWorkspaceBinEdges(MatrixWorkspace_sptr workspace,
+ int const &xLength,
+ int const &yLength) {
+ Mantid::HistogramData::BinEdges binEdges(xLength - 1, 0.0);
+ int j = 0;
+ std::generate(begin(binEdges), end(binEdges),
+ [&j] { return 0.5 + 0.75 * ++j; });
+ setWorkspaceBinEdges(workspace, yLength, binEdges);
+ return workspace;
+}
+
+MatrixWorkspace_sptr setWorkspaceProperties(MatrixWorkspace_sptr workspace,
+ int const &xLength,
+ int const &yLength) {
+ setWorkspaceBinEdges(workspace, xLength, yLength);
+ setWorkspaceEFixed(workspace, xLength);
+ return workspace;
+}
+
+MatrixWorkspace_sptr createWorkspaceWithInstrument(int const &xLength,
+ int const &yLength) {
+ auto workspace = createInstrumentWorkspace(xLength, yLength);
+ workspace->initialize(yLength, xLength, xLength - 1);
+ return setWorkspaceProperties(workspace, xLength, yLength);
+}
+
+} // namespace IndirectFitDataCreationHelper
+} // namespace Mantid
diff --git a/MantidPlot/src/ProjectRecovery.cpp b/MantidPlot/src/ProjectRecovery.cpp
index 1c642ccccc67372f1aebafc38da4b4eddb0cb8e4..e2907555aba92045de84eb211adb8278e1c6e9a6 100644
--- a/MantidPlot/src/ProjectRecovery.cpp
+++ b/MantidPlot/src/ProjectRecovery.cpp
@@ -13,8 +13,10 @@
#include "ScriptingWindow.h"
#include "MantidAPI/AlgorithmManager.h"
+#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/FileProperty.h"
#include "MantidAPI/Workspace.h"
+#include "MantidAPI/WorkspaceGroup.h"
#include "MantidAPI/WorkspaceHistory.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/Logger.h"
@@ -241,6 +243,24 @@ Poco::File addLockFile(const Poco::Path &lockFilePath) {
return lockFile;
}
+/**
+ * Checks the passed parameter and if it is an empty group then it returns true.
+ *
+ * @param ws :: check this workspace to see if it's an empty group
+ * @return true :: bool when it is an empty group
+ * @return false :: bool when it is not an empty group
+ */
+bool checkIfEmptyGroup(const Mantid::API::Workspace_sptr &ws) {
+ if (auto groupWS =
+ boost::dynamic_pointer_cast<Mantid::API::WorkspaceGroup>(ws)) {
+ if (groupWS->isEmpty()) {
+ g_log.debug("Empty group was present when recovery ran so was removed");
+ return true;
+ }
+ }
+ return false;
+}
+
const std::string OUTPUT_PROJ_NAME = "recovery.mantid";
const std::string SAVING_TIME_KEY = "projectRecovery.secondsBetween";
@@ -627,8 +647,7 @@ void ProjectRecovery::saveWsHistories(const Poco::Path &historyDestFolder) {
const auto &ads = Mantid::API::AnalysisDataService::Instance();
// Hold a copy to the shared pointers so they do not get deleted under us
- std::vector<boost::shared_ptr<Mantid::API::Workspace>> wsHandles =
- ads.getObjects(Mantid::Kernel::DataServiceHidden::Include);
+ auto wsHandles = ads.getObjects(Mantid::Kernel::DataServiceHidden::Include);
if (wsHandles.empty()) {
return;
@@ -644,6 +663,11 @@ void ProjectRecovery::saveWsHistories(const Poco::Path &historyDestFolder) {
alg->setLogging(false);
for (auto i = 0u; i < wsHandles.size(); ++i) {
+ // Check if workspace is an empty worksapce group and remove it if it is as
+ // well as skip
+ if (checkIfEmptyGroup(wsHandles[i]))
+ continue;
+
std::string filename = std::to_string(i) + ".py";
Poco::Path destFilename = historyDestFolder;
diff --git a/MantidPlot/src/ProjectRecovery.h b/MantidPlot/src/ProjectRecovery.h
index c957f550bff7350bfc56cc0d5925e0fa694b1800..fac42876a3e6382a9c7b90d81009b668875156ea 100644
--- a/MantidPlot/src/ProjectRecovery.h
+++ b/MantidPlot/src/ProjectRecovery.h
@@ -7,6 +7,7 @@
#ifndef PROJECT_RECOVERY_H_
#define PROJECT_RECOVERY_H_
+#include "MantidAPI/Workspace.h"
#include "MantidKernel/ConfigService.h"
#include <Poco/NObserver.h>
diff --git a/Testing/SystemTests/tests/analysis/reference/ISIS_Powder-GEM83605_FocusSempty.nxs.md5 b/Testing/SystemTests/tests/analysis/reference/ISIS_Powder-GEM83605_FocusSempty.nxs.md5
index e1dee0343f1ec3b8b492ce2f7b73106db8606678..57c32f59bdb04dc9d68578edd6247a6383542a91 100644
--- a/Testing/SystemTests/tests/analysis/reference/ISIS_Powder-GEM83605_FocusSempty.nxs.md5
+++ b/Testing/SystemTests/tests/analysis/reference/ISIS_Powder-GEM83605_FocusSempty.nxs.md5
@@ -1 +1 @@
-1feccda871823814107a21de6eb9a260
+2e0a73c2c476682db7d404efe18a324a
diff --git a/buildconfig/CMake/CPackCommon.cmake b/buildconfig/CMake/CPackCommon.cmake
index ecb8ee635b5d73f9d3cb6c853b8a8e7eae369b1b..9059f0c3b537aebf76354007e338fa890532a1ec 100644
--- a/buildconfig/CMake/CPackCommon.cmake
+++ b/buildconfig/CMake/CPackCommon.cmake
@@ -3,8 +3,8 @@
###############################################################################
# Common description stuff
-set ( CPACK_PACKAGE_DESCRIPTION_SUMMARY "Neutron Scattering Data Analysis" )
-set ( CPACK_PACKAGE_VENDOR "ISIS Rutherford Appleton Laboratory and NScD Oak Ridge National Laboratory" )
+set ( CPACK_PACKAGE_DESCRIPTION_SUMMARY "Neutron Scattering Data Reduction and Analysis" )
+set ( CPACK_PACKAGE_VENDOR "ISIS Rutherford Appleton Laboratory UKRI, NScD Oak Ridge National Laboratory, European Spallation Source and Institut Laue - Langevin" )
set ( CPACK_PACKAGE_URL http://www.mantidproject.org/ )
set ( CPACK_PACKAGE_CONTACT mantid-help@mantidproject.org )
set ( CPACK_PACKAGE_VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH} )
@@ -21,6 +21,8 @@ set ( CPACK_RPM_PACKAGE_LICENSE GPLv3+ )
set ( CPACK_RPM_PACKAGE_RELEASE 1 )
set ( CPACK_RPM_PACKAGE_GROUP Applications/Engineering )
-# DEB informatin - the package does not have an original
+# DEB information - the package does not have an original
# in debian archives so the debian release is 0
set ( CPACK_DEBIAN_PACKAGE_RELEASE 0 )
+set ( CPACK_DEBIAN_PACKAGE_MAINTAINER "Mantid Project <${CPACK_PACKAGE_CONTACT}>")
+set ( CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION TRUE )
diff --git a/docs/source/algorithms/CreateTransmissionWorkspace-v2.rst b/docs/source/algorithms/CreateTransmissionWorkspace-v2.rst
index b4bc5f1ffcda580efbf0f0026afade20586d0c86..8e8731024dafd2583f4ca83903fe77a1288038e8 100644
--- a/docs/source/algorithms/CreateTransmissionWorkspace-v2.rst
+++ b/docs/source/algorithms/CreateTransmissionWorkspace-v2.rst
@@ -63,7 +63,7 @@ Usage
trans = Load(Filename='INTER00013463.nxs')
transWS = CreateTransmissionWorkspace(FirstTransmissionRun = trans,
I0MonitorIndex = 2,
- ProcessingInstructions = '3,4',
+ ProcessingInstructions = '4,5',
WavelengthMin = 1,
WavelengthMax = 17,
MonitorBackgroundWavelengthMin = 15,
@@ -97,7 +97,7 @@ Output:
StartOverlap = 10.0,
EndOverlap = 12.0,
I0MonitorIndex = 2,
- ProcessingInstructions = '3,4',
+ ProcessingInstructions = '4,5',
WavelengthMin = 1,
WavelengthMax = 17,
MonitorBackgroundWavelengthMin = 15,
diff --git a/docs/source/algorithms/EditInstrumentGeometry-v1.rst b/docs/source/algorithms/EditInstrumentGeometry-v1.rst
index 2ef6b3fb137bb7532b4afc1fedaf76ddcdb0c95a..2d0b960124184a408528d57687bcbfbdc6aa91ad 100644
--- a/docs/source/algorithms/EditInstrumentGeometry-v1.rst
+++ b/docs/source/algorithms/EditInstrumentGeometry-v1.rst
@@ -9,53 +9,67 @@
Description
-----------
-This algorithm can
+This algorithm can:
-| ``1. add an Instrument to a Workspace without any real instrument associated with, or``
-| ``2. replace a Workspace's Instrument with a new Instrument, or``
-| ``3. edit all detectors' parameters of the instrument associated with a Workspace (partial instrument editing is not supported).``
+#. Add an Instrument to a Workspace without any real instrument associated with, or
+#. Replace a Workspace's Instrument with a new Instrument, or
+#. Edit all detectors' parameters of the instrument associated with a Workspace (partial instrument editing is not supported).
Requirements on input properties
--------------------------------
-1. PrimaryFightPath (L1): If it is not given, L1 will be the distance
-between source and sample in the original instrument. Otherwise, L1 is
-read from input. The source position of the modified instrument is (0,
-0, -L1);
-
-2. SpectrumIDs: If not specified (empty list), then Spectrum Numbers will be
-set up to any array such that SpectrumNos[wsindex] is the spectrum Number of
-workspace index 'wsindex';
-
-3. L2 and Polar cannot be empty list;
-
-4. SpectrumIDs[i], L2[i], Polar[i], Azimuthal[i] and optional
-DetectorIDs[i] correspond to the detector of a same spectrum.
-
-5. Angles are specified in degrees.
+#. PrimaryFightPath (L1): If it is not given, L1 will be the distance
+ between source and sample in the original instrument. Otherwise, L1 is
+ read from input. The source position of the modified instrument is (0,
+ 0, -L1);
+#. SpectrumIDs: If not specified (empty list), then Spectrum Numbers will be
+ set up to any array such that SpectrumNos[wsindex] is the spectrum Number of
+ workspace index 'wsindex';
+#. L2 and Polar cannot be empty list;
+#. SpectrumIDs[i], L2[i], Polar[i], Azimuthal[i] and optional
+ DetectorIDs[i] correspond to the detector of a same spectrum.
+#. Angles are specified in degrees.
Limitations
-----------
There are some limitations of this algorithm.
-1. The key to locate the detector is via spectrum Number;
-
-2. For each spectrum, there is only one and only one new detector. Thus,
-if one spectrum is associated with a group of detectors previously, the
-replacement (new) detector is the one which is (diffraction) focused on
-after this algorithm is called.
-
-Instruction
------------
-
-1. For powder diffractomer with 3 spectra, user can input
-
-| ``  SpectrumIDs = "1, 3, 2"``
-| ``  L2 = "3.1, 3.2, 3.3"``
-| ``  Polar = "90.01, 90.02, 90.03"``
-| ``  Azimuthal = "0.1,0.2,0.3"``
-| ``  to set up the focused detectors' parameters for spectrum 1, 3 and 2.``
+#. The key to locate the detector is via spectrum Number;
+#. For each spectrum, there is only one and only one new detector. Thus, if one spectrum is associated with a group of detectors previously, the replacement (new) detector is the one which is (diffraction) focused on after this algorithm is called.
+
+Usage
+-----
+
+**Example - Adding a new instrument to a workspace**
+
+.. testcode:: AddExample
+
+ import numpy
+ ws = CreateWorkspace(
+ DataX=[0., 1.],
+ DataY=[1., 2., 3.],
+ NSpec=3)
+ EditInstrumentGeometry(
+ ws,
+ PrimaryFlightPath=5.,
+ SpectrumIDs=[1, 2, 3],
+ L2=[2.0, 2.3, 2.6],
+ Polar=[10.0, 15.0, 23.0],
+ Azimuthal=[0.0, 0.0, 0.0],
+ DetectorIDs=[100, 101, 102],
+ InstrumentName='Bizarrio')
+ spectrumInfo = ws.spectrumInfo()
+ for i in range(ws.getNumberHistograms()):
+ print('Histogram {} scattering angle: {:.3} degrees'.format(i + 1, numpy.rad2deg(spectrumInfo.twoTheta(i))))
+
+Output:
+
+.. testoutput:: AddExample
+
+ Histogram 1 scattering angle: 10.0 degrees
+ Histogram 2 scattering angle: 15.0 degrees
+ Histogram 3 scattering angle: 23.0 degrees
.. categories::
diff --git a/docs/source/algorithms/MSDFit-v1.rst b/docs/source/algorithms/MSDFit-v1.rst
index 4e01c6d43b5b051247d008e7ace9b83591a1d160..de2210a2ba884dbc990d24c7f8d39f6a4ce23adc 100644
--- a/docs/source/algorithms/MSDFit-v1.rst
+++ b/docs/source/algorithms/MSDFit-v1.rst
@@ -53,16 +53,17 @@ Usage
print('A0: ' + str(y_msd.readY(0)))
print('A1: ' + str(y_msd.readY(1)))
-Output:
+Output (the numbers on your machine my not match exactly):
.. testoutput:: ExGeneratedDataFit
-
+ :options: +ELLIPSIS, +NORMALIZE_WHITESPACE
+
Using Gauss Model
- A0: [ 0.87079958]
- A1: [ 0.03278263]
+ A0: [ 0.87...]
+ A1: [ 0.03...]
Using Yi Model
- A0: [ 0.95770532]
- A1: [ 0.58819225]
+ A0: [ 0.95...]
+ A1: [ 0.58...]
.. categories::
diff --git a/docs/source/algorithms/ReflectometryReductionOne-v2.rst b/docs/source/algorithms/ReflectometryReductionOne-v2.rst
index 0116f7f71ff330415cd5673c97a6fbdc3155f7bf..61a694bdcdd82d872aaa39b702f588c2f58f4010 100644
--- a/docs/source/algorithms/ReflectometryReductionOne-v2.rst
+++ b/docs/source/algorithms/ReflectometryReductionOne-v2.rst
@@ -113,10 +113,8 @@ transmission runs or specific correction algorithms.
When normalizing by transmission runs, i.e. when one or two transmission runs
are given, the spectrum numbers in the
transmission workspaces must be the same as those in the input run
-workspace. If spectrum numbers do not match, the algorithm will throw and exception
-and execution of the algorithm will be stopped. This behaviour can be optionally
-switched off by setting :literal:`StrictSpectrumChecking` to false, in which case
-a warning message will be shown instead.
+workspace. You can pass individual processing instructions to the transmission
+runs.
When normalizing by transmission run, this algorithm will run
:ref:`algm-CreateTransmissionWorkspace` as a child algorithm, with properties :literal:`WavelengthMin`,
@@ -224,7 +222,7 @@ Usage
IvsQ, IvsLam = ReflectometryReductionOne(InputWorkspace=run,
WavelengthMin=1.0,
WavelengthMax=17.0,
- ProcessingInstructions='3',
+ ProcessingInstructions='4',
I0MonitorIndex=2,
MonitorBackgroundWavelengthMin=15.0,
MonitorBackgroundWavelengthMax=17.0,
@@ -258,7 +256,7 @@ Output:
IvsQ, IvsLam = ReflectometryReductionOne(InputWorkspace=run,
WavelengthMin=1.0,
WavelengthMax=17.0,
- ProcessingInstructions='3',
+ ProcessingInstructions='4',
I0MonitorIndex=2,
MonitorBackgroundWavelengthMin=15.0,
MonitorBackgroundWavelengthMax=17.0,
diff --git a/docs/source/algorithms/SetInstrumentParameter-v1.rst b/docs/source/algorithms/SetInstrumentParameter-v1.rst
index b3280db781ee8ce758293fbe953307fe521fd939..6fec4a65348a803b58be717f160094834e985c30 100644
--- a/docs/source/algorithms/SetInstrumentParameter-v1.rst
+++ b/docs/source/algorithms/SetInstrumentParameter-v1.rst
@@ -12,7 +12,7 @@ Description
This algorithm adds or replaces an parameter attached to an instrument
component, or the entire instrument. Instrument parameters are specific
to a workspace, they will get carried on to output workspaces created
-from an input workspace to an algorithm, but will not appear one
+from an input workspace to an algorithm, but will not appear on
unrelated workspaces that happen to have been recorded on the same
instrument.
@@ -32,7 +32,7 @@ For `Bool` type, valid values are `1`, `0`, `true` or `false` (not case-sensitiv
Usage
-----
-**Example - a few simple parameters**
+**Example - a few simple parameters**
.. testcode:: Ex1
@@ -61,7 +61,7 @@ Usage
#For this one call getNumberParameter as the number was a float
print(" bank 2: " + str(bank2.getNumberParameter("NumberParam")[0]))
#if you are not sure of the type of a parameter you can call getParameterType
- print(" The type of NumberParam in bank 1: " + bank1.getParameterType("NumberParam"))
+ print(" The type of NumberParam in bank 1: " + bank1.getParameterType("NumberParam"))
print(" The type of NumberParam in bank 2: " + bank2.getParameterType("NumberParam"))
@@ -79,7 +79,7 @@ Output:
The type of NumberParam in bank 1: int
The type of NumberParam in bank 2: double
-**Example - Overwriting existing values**
+**Example - Overwriting existing values**
.. testcode:: Ex2
@@ -91,10 +91,10 @@ Output:
instrument=ws.getInstrument()
bank1=instrument.getComponentByName("bank1")
-
+
print("The SetInstrumentParameter overwrites previous values where the ParameterName and Component match.")
print(" The test param for the instrument is: " + instrument.getStringParameter("TestParam")[0])
- print("Different Components can have the same Parameter Name with different values.")
+ print("Different Components can have the same Parameter Name with different values.")
print("You will receive the closest value to the component you ask from.")
print(" The test param for bank 1 is: " + bank1.getStringParameter("TestParam")[0])
diff --git a/docs/source/algorithms/SpecularReflectionPositionCorrect-v2.rst b/docs/source/algorithms/SpecularReflectionPositionCorrect-v2.rst
index 1773378e9535431b5681566d76f58f7b87bf97e1..f2cc1a80666a2ea05e152cd7bdae4049bf5c7a11 100644
--- a/docs/source/algorithms/SpecularReflectionPositionCorrect-v2.rst
+++ b/docs/source/algorithms/SpecularReflectionPositionCorrect-v2.rst
@@ -9,15 +9,49 @@
Description
-----------
-Moves the specified detector component so that the angle between the beam and
-the sample-to-detector vector is :literal:`TwoTheta`. The detector component is moved as a
-block. The rest of the instrument components remain in the original position. The component
-can be shifted vertically (default), or rotated around the sample position.
+Moves the specified detector component to a given angle between the beam and
+the sample-to-detector vector. The detector component is moved as a
+block. The rest of the instrument components remain in original positions. The component
+can be shifted vertically (default), or rotated around the sample position. When rotating
+around the sample, an optional rotation can be applied so that the detector always faces
+the sample.
+
+In the most basic operation, the detector is moved to the angle specified by ``TwoTheta``.
+This case is schematically shown below for rotation around the sample position and
+``DetectorFacesSample`` set to ``True``.
+
+.. figure:: ../images/SpecularReflectionCorrection_figure1.png
+ :alt: Schematic representation of angle correction when only TwoTheta is given.
+ :scale: 100%
+
+
+If ``LinePosition`` and ``PixelSize`` are also given, the detector will be moved such
+that the angle will be ``TwoTheta`` for the pixel at workspace index ``LinePosition``.
+Note that ``LinePosition`` can be a fractional index making it possible to adjust the
+detector angle to a fitted line position. The figure below illustrates this option.
+
+.. figure:: ../images/SpecularReflectionCorrection_figure2.png
+ :alt: Schematic representation of angle correction when TwoTheta and LinePosition are given.
+ :scale: 100%
+
+The last possible detector position correction is calibration by a separate direct beam
+measurement. The idea is to correct the detector angle by difference between the
+nominal beam axis and the measured direct beam as shown in the figure below. In this mode
+``TwoTheta`` is omitted but ``DirectLinePosition``, ``DirectLineWorkspace`` and ``PixelSize``
+have to be specified.
+
+.. figure:: ../images/SpecularReflectionCorrection_figure3.png
+ :alt: Schematic representation of angle correction when direct beam reference is used.
+ :scale: 100%
+
+.. note::
+ The line positions can be acquired by using, for instance,
+ :ref:`FindReflectometryLines <algm-FindReflectometryLines>`.
Previous Versions
-----------------
-For version 1 of the algorithm, please see `SpecularReflectionPositionCorrect-v1. <SpecularReflectionPositionCorrect-v1.html>`_
+For version 1 of the algorithm, please see :ref:`SpecularReflectionPositionCorrect-v1. <algm-SpecularReflectionPositionCorrect-v1>`
Usage
-----
@@ -110,6 +144,81 @@ Output:
Vertical shift: [26,0,0.0513177]
Rotated: [25.9996,0,0.0513102]
+**Example - Rotate given pixel**
+
+.. testcode:: SpecularReflectionPositionCorrectLinePosition
+
+ import numpy
+ # We'll just use an empty workspace here.
+ ws = LoadEmptyInstrument(InstrumentName='D17')
+ # Get rid of monitors
+ ExtractMonitors(ws, DetectorWorkspace='ws')
+ ws = mtd['ws']
+ line_position = 22.
+ spectrum_info = ws.spectrumInfo()
+ two_theta = numpy.rad2deg(spectrum_info.twoTheta(int(line_position)))
+ print('Pixel {} 2theta'.format(int(line_position)))
+ print('before angle correction: {:.3}'.format(two_theta))
+ ws = SpecularReflectionPositionCorrect(
+ ws,
+ TwoTheta=1.5,
+ DetectorCorrectionType='RotateAroundSample',
+ DetectorComponentName='detector',
+ DetectorFacesSample=True,
+ LinePosition=line_position,
+ PixelSize=0.001195)
+ spectrum_info = ws.spectrumInfo()
+ two_theta = numpy.rad2deg(spectrum_info.twoTheta(int(line_position)))
+ print('after angle correction: {:.3}'.format(two_theta))
+
+Output:
+
+.. testoutput:: SpecularReflectionPositionCorrectLinePosition
+
+ Pixel 22 2theta
+ before angle correction: 2.33
+ after angle correction: 1.5
+
+**Example - Use direct beam for angle calibration**
+
+.. testcode:: SpecularReflectionPositionCorrectDirectBeamCalibration
+
+ import numpy
+ # We'll just use empty workspaces here.
+ reflected = LoadEmptyInstrument(InstrumentName='Figaro')
+ direct = LoadEmptyInstrument(InstrumentName='Figaro')
+ # Get rid of monitors
+ ExtractMonitors(reflected, DetectorWorkspace='reflected')
+ reflected = mtd['reflected']
+ ExtractMonitors(direct, DetectorWorkspace='direct')
+ direct = mtd['direct']
+ line_position = 202.
+ spectrum_info = reflected.spectrumInfo()
+ two_theta = numpy.rad2deg(spectrum_info.twoTheta(int(line_position)))
+ print('Pixel {} 2theta'.format(int(line_position)))
+ print('before angle correction: {:.3}'.format(two_theta))
+ direct_line_position = 130.7 # This could come from some fitting procedure
+ reflected = SpecularReflectionPositionCorrect(
+ reflected,
+ DetectorCorrectionType='RotateAroundSample',
+ DetectorComponentName='detector',
+ DetectorFacesSample=True,
+ PixelSize=0.001195,
+ DirectLineWorkspace=direct,
+ DirectLinePosition=direct_line_position)
+ spectrum_info = reflected.spectrumInfo()
+ two_theta = numpy.rad2deg(spectrum_info.twoTheta(int(line_position)))
+ print('after angle correction: {:.3}'.format(two_theta))
+
+
+Output:
+
+.. testoutput:: SpecularReflectionPositionCorrectDirectBeamCalibration
+
+ Pixel 202 2theta
+ before angle correction: 5.11
+ after angle correction: 4.89
+
.. categories::
.. sourcelink::
diff --git a/docs/source/concepts/TableWorkspaces.rst b/docs/source/concepts/TableWorkspaces.rst
index 925bda03de49c2421c808684c57c233180965f52..08cb5b0619124368500c81f1ecbc555563873136 100644
--- a/docs/source/concepts/TableWorkspaces.rst
+++ b/docs/source/concepts/TableWorkspaces.rst
@@ -169,11 +169,11 @@ Working with Table Workspaces in C++
Table workspaces can be created using the workspace factory:
-``ITableWorkspace_sptr table = WorkspaceFactory::Instance().createTable("TableWorkspace");``
+``ITableWorkspace_sptr table = WorkspaceFactory::Instance().createTable("TableWorkspace");``
Columns are added using the addColumn method:
-| ``table->addColumn("str","Parameter Name");``
+| ``table->addColumn("str","Parameter Name");``
| ``table->addColumn("double","Value");``
| ``table->addColumn("double","Error");``
| ``table->addColumn("int","Index");``
@@ -224,26 +224,26 @@ Table rows
Cells with the same index form a row. TableRow class represents a row.
Use getRow(int) or getFirstRow() to access existing rows. For example:
-.. code-block:: c
+.. code-block:: c++
- std::string key;
- double value;
- TableRow row = table->getFirstRow();
+ std::string key;
+ double value;
+ TableRow row = table->getFirstRow();
do
{
-   row >> key >> value;
-   std::cout << "key=" << key << " value=" << value << std::endl;
+ row >> key >> value;
+ std::cout << "key=" << key << " value=" << value << std::endl;
}
while(row.next());
TableRow can also be use for writing into a table:
-.. code-block:: c
+.. code-block:: c++
- for(int i=0; i < n; ++i)
+ for(int i=0; i < n; ++i)
{
- TableRow row = table->appendRow();
- row << keys[i] << values[i];
+ TableRow row = table->appendRow();
+ row << keys[i] << values[i];
}
Defining new column types
diff --git a/docs/source/images/SpecularReflectionCorrection_figure1.png b/docs/source/images/SpecularReflectionCorrection_figure1.png
new file mode 100644
index 0000000000000000000000000000000000000000..aecabc082a3ed9dce5e548bb84f6d802e993f996
Binary files /dev/null and b/docs/source/images/SpecularReflectionCorrection_figure1.png differ
diff --git a/docs/source/images/SpecularReflectionCorrection_figure2.png b/docs/source/images/SpecularReflectionCorrection_figure2.png
new file mode 100644
index 0000000000000000000000000000000000000000..1327e3f9f2664505e4d8f3adeb73bb13f7be105f
Binary files /dev/null and b/docs/source/images/SpecularReflectionCorrection_figure2.png differ
diff --git a/docs/source/images/SpecularReflectionCorrection_figure3.png b/docs/source/images/SpecularReflectionCorrection_figure3.png
new file mode 100644
index 0000000000000000000000000000000000000000..8156be43ce129c93d9e36c9acb5ec8800af6e5d1
Binary files /dev/null and b/docs/source/images/SpecularReflectionCorrection_figure3.png differ
diff --git a/docs/source/interfaces/ISIS Reflectometry.rst b/docs/source/interfaces/ISIS Reflectometry.rst
index cc19a4e12687ad9876a8abb0ddbdcc7549208bda..b20f2fab93624916583a67a5741bca4a33b2cfb2 100644
--- a/docs/source/interfaces/ISIS Reflectometry.rst
+++ b/docs/source/interfaces/ISIS Reflectometry.rst
@@ -336,8 +336,7 @@ Columns
| | | column will prevail over options specified |
| | | in the **Settings** tab. |
| | | |
-| | | Example: ``StrictSpectrumChecking=0,`` |
-| | | ``RegionOfDirectBeam="0,2", Params="1,2,3"`` |
+| | | Example: ``RegionOfDirectBeam="0,2", Params="1,2,3"`` |
+---------------------+-----------+---------------------------------------------------------------------------------+
Search Interface
diff --git a/docs/source/release/v3.14.0/diffraction.rst b/docs/source/release/v3.14.0/diffraction.rst
index 1f696d5826987be49e4e0adcb57041bd22ff0f9e..3925285e2a3656c5b28440e8219ec15e5949809a 100644
--- a/docs/source/release/v3.14.0/diffraction.rst
+++ b/docs/source/release/v3.14.0/diffraction.rst
@@ -58,6 +58,7 @@ Improvements
- Added save_all flag to Gem that is set to true by default, setting it to false disables the saving of .NXS files.
- Added subtract_empty_instrument flag to Gem that is true by default, setting it to false disables subrtracting the empty.
- Changed spline coefficient so that the default for long_mode on and long_mode off can be set separately.
+- Focus on Pearl now saves out xye_tof files.
Bugfixes
########
diff --git a/docs/source/release/v3.14.0/indirect_inelastic.rst b/docs/source/release/v3.14.0/indirect_inelastic.rst
index c9fd7a9a92b6c0e5eeb7ef7ee757a27b39b64fbb..12ed7eec892a94b0dbb580cbb559f6db2f6f9057 100644
--- a/docs/source/release/v3.14.0/indirect_inelastic.rst
+++ b/docs/source/release/v3.14.0/indirect_inelastic.rst
@@ -78,3 +78,13 @@ Improvements
- The Run button has been moved to be above the output options. The run button, save button and plotting options
are now disabled while a tab is running or plotting.
- It is now possible to choose which spectrum to Plot Output for in the S(Q,w) Tab.
+
+
+Bayes Interface
+---------------
+
+Improvements
+############
+
+- The Run button is now above the output options.
+- The Run, Plot and Save buttons are now disabled while running and plotting is taking place.
diff --git a/docs/source/release/v3.14.0/reflectometry.rst b/docs/source/release/v3.14.0/reflectometry.rst
index e9dbe1e3ab44d40e6dd574060153244bd9c7e8cf..ba3612c69c3f58db844b244b5a96a8b2eadadb48 100644
--- a/docs/source/release/v3.14.0/reflectometry.rst
+++ b/docs/source/release/v3.14.0/reflectometry.rst
@@ -68,7 +68,7 @@ Improved
Bug fixes
#########
-
+- The SaveASCII tab from the interface was unable to save in some places on Windows and that has now been fixed.
Algorithms
----------
@@ -83,7 +83,10 @@ Improved
########
- :ref:`algm-ReflectometryReductionOneAuto` now supports the Wildes method for polarization corrections as well as Fredrikze when configured in the parameters file.
+- :ref:`algm-ReflectometryReductionOne`, :ref:`algm-ReflectometryReductionOneAuto`, :ref:`algm-CreateTransmissionWorkspace` and :ref:`algm-CreateTransmissionWorkspaceAuto` now use spectrum numbers for their processing instructions instead of workspace indcies
+- :ref:`algm-ReflectometryReductionOne` and :ref:`algm-ReflectometryReductionOneAuto` Now take a parameter to pass processing instructions to the transmission workspace algorithms and no longer accept strict spectrum checking
- Common naming of slit component name and size properties across algorithms.
+- :ref:`algm-SpecularReflectionPositionCorrect` is now compatible with the reflectometers at ILL.
Bug fixes
#########
diff --git a/docs/source/release/v3.14.0/ui.rst b/docs/source/release/v3.14.0/ui.rst
index 6a9711a87deb9f7ed3f6a2778b0457daaa01ba5d..1fe89daff709d5362c34b5468a98aacd38504406 100644
--- a/docs/source/release/v3.14.0/ui.rst
+++ b/docs/source/release/v3.14.0/ui.rst
@@ -42,6 +42,7 @@ Bugfixes
- Project Recovery will now run normally when you select no or the recovery fails when recovering from a ungraceful exit.
- When autosaving or saving a recovery checkpoint with the Instrument View open the results log would be filled with excess logging and no longer does this.
- Fixed an issue where Project Recovery would start regardless of the config options
+- If an empty group workspace is present in the ADS it will no longer crash the save thread of project recovery and instead will delete it from the ADS and ignore it.
MantidPlot
----------
diff --git a/qt/scientific_interfaces/ISISReflectometry/ReflAsciiSaver.cpp b/qt/scientific_interfaces/ISISReflectometry/ReflAsciiSaver.cpp
index 7efb2651bc7a447037ed7da32b6a17b33b086d53..654d3671e4e9204624a97767ea4c6bb56e66272e 100644
--- a/qt/scientific_interfaces/ISISReflectometry/ReflAsciiSaver.cpp
+++ b/qt/scientific_interfaces/ISISReflectometry/ReflAsciiSaver.cpp
@@ -53,7 +53,7 @@ bool ReflAsciiSaver::isValidSaveDirectory(std::string const &path) const {
try {
auto pocoPath = Poco::Path().parseDirectory(path);
auto pocoFile = Poco::File(pocoPath);
- return pocoFile.exists() && pocoFile.canWrite();
+ return pocoFile.exists();
} catch (Poco::PathSyntaxException &) {
return false;
}
diff --git a/qt/scientific_interfaces/Indirect/AbsorptionCorrections.cpp b/qt/scientific_interfaces/Indirect/AbsorptionCorrections.cpp
index 84a8ec7729095acce4e3b46f5105bcfa719564bc..ca02cde8744d83ded69302e3bac015e11eb30e24 100644
--- a/qt/scientific_interfaces/Indirect/AbsorptionCorrections.cpp
+++ b/qt/scientific_interfaces/Indirect/AbsorptionCorrections.cpp
@@ -524,18 +524,20 @@ void AbsorptionCorrections::setSaveResultEnabled(bool enabled) {
m_uiForm.pbSave->setEnabled(enabled);
}
+void AbsorptionCorrections::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+}
+
void AbsorptionCorrections::setRunIsRunning(bool running) {
m_uiForm.pbRun->setText(running ? "Running..." : "Run");
- setRunEnabled(!running);
- setPlotResultEnabled(!running);
- setSaveResultEnabled(!running);
+ setButtonsEnabled(!running);
}
void AbsorptionCorrections::setPlotResultIsPlotting(bool plotting) {
m_uiForm.pbPlot->setText(plotting ? "Plotting..." : "Plot");
- setPlotResultEnabled(!plotting);
- setRunEnabled(!plotting);
- setSaveResultEnabled(!plotting);
+ setButtonsEnabled(!plotting);
}
} // namespace CustomInterfaces
diff --git a/qt/scientific_interfaces/Indirect/AbsorptionCorrections.h b/qt/scientific_interfaces/Indirect/AbsorptionCorrections.h
index 8e05c61083abaa813a70ed48e425e0004fe5ef7e..1b20fe231df58c813d8028bed4b0c4a329500b21 100644
--- a/qt/scientific_interfaces/Indirect/AbsorptionCorrections.h
+++ b/qt/scientific_interfaces/Indirect/AbsorptionCorrections.h
@@ -64,6 +64,7 @@ private:
void setRunEnabled(bool enabled);
void setPlotResultEnabled(bool enabled);
void setSaveResultEnabled(bool enabled);
+ void setButtonsEnabled(bool enabled);
void setRunIsRunning(bool running);
void setPlotResultIsPlotting(bool plotting);
diff --git a/qt/scientific_interfaces/Indirect/ApplyAbsorptionCorrections.cpp b/qt/scientific_interfaces/Indirect/ApplyAbsorptionCorrections.cpp
index c2c1de121fb5a0134dc3d8c0b152372acc8e7b6e..266857b561a22642d43352a134fa261aa9f4b8c2 100644
--- a/qt/scientific_interfaces/Indirect/ApplyAbsorptionCorrections.cpp
+++ b/qt/scientific_interfaces/Indirect/ApplyAbsorptionCorrections.cpp
@@ -220,6 +220,9 @@ void ApplyAbsorptionCorrections::run() {
m_uiForm.ckRebinContainer->setChecked(true);
} else {
m_batchAlgoRunner->clearQueue();
+ setRunIsRunning(false);
+ setPlotResultEnabled(false);
+ setSaveResultEnabled(false);
g_log.error("Cannot apply absorption corrections "
"using a sample and "
"container with different binning.");
@@ -279,6 +282,9 @@ void ApplyAbsorptionCorrections::run() {
break;
default:
m_batchAlgoRunner->clearQueue();
+ setRunIsRunning(false);
+ setPlotResultEnabled(false);
+ setSaveResultEnabled(false);
g_log.error(
"ApplyAbsorptionCorrections cannot run with corrections that do "
"not match sample binning.");
@@ -651,18 +657,20 @@ void ApplyAbsorptionCorrections::setSaveResultEnabled(bool enabled) {
m_uiForm.pbSave->setEnabled(enabled);
}
+void ApplyAbsorptionCorrections::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+}
+
void ApplyAbsorptionCorrections::setRunIsRunning(bool running) {
m_uiForm.pbRun->setText(running ? "Running..." : "Run");
- setRunEnabled(!running);
- setPlotResultEnabled(!running);
- setSaveResultEnabled(!running);
+ setButtonsEnabled(!running);
}
void ApplyAbsorptionCorrections::setPlotResultIsPlotting(bool plotting) {
m_uiForm.pbPlot->setText(plotting ? "Plotting..." : "Plot");
- setPlotResultEnabled(!plotting);
- setRunEnabled(!plotting);
- setSaveResultEnabled(!plotting);
+ setButtonsEnabled(!plotting);
}
} // namespace CustomInterfaces
diff --git a/qt/scientific_interfaces/Indirect/ApplyAbsorptionCorrections.h b/qt/scientific_interfaces/Indirect/ApplyAbsorptionCorrections.h
index a638c62adf650dec39b918011e5334a8770a98d9..274a8cde1120e1b0d3d7b69e534172768a283f6b 100644
--- a/qt/scientific_interfaces/Indirect/ApplyAbsorptionCorrections.h
+++ b/qt/scientific_interfaces/Indirect/ApplyAbsorptionCorrections.h
@@ -56,6 +56,7 @@ private:
void setRunEnabled(bool enabled);
void setPlotResultEnabled(bool enabled);
void setSaveResultEnabled(bool enabled);
+ void setButtonsEnabled(bool enabled);
void setRunIsRunning(bool running);
void setPlotResultIsPlotting(bool plotting);
diff --git a/qt/scientific_interfaces/Indirect/CalculatePaalmanPings.cpp b/qt/scientific_interfaces/Indirect/CalculatePaalmanPings.cpp
index f6be70429199fe2a73eb7eb983553af224673fc0..a2963baf344f885c69c4bfe7c9a38e006f9d842a 100644
--- a/qt/scientific_interfaces/Indirect/CalculatePaalmanPings.cpp
+++ b/qt/scientific_interfaces/Indirect/CalculatePaalmanPings.cpp
@@ -603,18 +603,20 @@ void CalculatePaalmanPings::setSaveResultEnabled(bool enabled) {
m_uiForm.pbSave->setEnabled(enabled);
}
+void CalculatePaalmanPings::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+}
+
void CalculatePaalmanPings::setRunIsRunning(bool running) {
m_uiForm.pbRun->setText(running ? "Running..." : "Run");
- setRunEnabled(!running);
- setPlotResultEnabled(!running);
- setSaveResultEnabled(!running);
+ setButtonsEnabled(!running);
}
void CalculatePaalmanPings::setPlotResultIsPlotting(bool plotting) {
m_uiForm.pbPlot->setText(plotting ? "Plotting..." : "Plot");
- setPlotResultEnabled(!plotting);
- setRunEnabled(!plotting);
- setSaveResultEnabled(!plotting);
+ setButtonsEnabled(!plotting);
}
} // namespace CustomInterfaces
diff --git a/qt/scientific_interfaces/Indirect/CalculatePaalmanPings.h b/qt/scientific_interfaces/Indirect/CalculatePaalmanPings.h
index a64433789ded7ecfa29add0f6b1cb665c1dc54c5..e2b1874db48a4c4e9d0c9c467848eb3f42169ece 100644
--- a/qt/scientific_interfaces/Indirect/CalculatePaalmanPings.h
+++ b/qt/scientific_interfaces/Indirect/CalculatePaalmanPings.h
@@ -48,6 +48,7 @@ private:
void setRunEnabled(bool enabled);
void setPlotResultEnabled(bool enabled);
void setSaveResultEnabled(bool enabled);
+ void setButtonsEnabled(bool enabled);
void setRunIsRunning(bool running);
void setPlotResultIsPlotting(bool plotting);
diff --git a/qt/scientific_interfaces/Indirect/ContainerSubtraction.cpp b/qt/scientific_interfaces/Indirect/ContainerSubtraction.cpp
index 851aeb016c46b991e73d7e02228eda18a07dfe8c..f286267fa6292505f7df4ed220f678492a965eab 100644
--- a/qt/scientific_interfaces/Indirect/ContainerSubtraction.cpp
+++ b/qt/scientific_interfaces/Indirect/ContainerSubtraction.cpp
@@ -81,6 +81,9 @@ void ContainerSubtraction::run() {
containerWs = requestRebinToSample(containerWs);
if (!checkWorkspaceBinningMatches(m_csSampleWS, containerWs)) {
+ setRunIsRunning(false);
+ setPlotResultEnabled(false);
+ setSaveResultEnabled(false);
g_log.error("Cannot apply container corrections using a sample and "
"container with different binning.");
return;
@@ -554,18 +557,20 @@ void ContainerSubtraction::setSaveResultEnabled(bool enabled) {
m_uiForm.pbSave->setEnabled(enabled);
}
+void ContainerSubtraction::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+}
+
void ContainerSubtraction::setRunIsRunning(bool running) {
m_uiForm.pbRun->setText(running ? "Running..." : "Run");
- setRunEnabled(!running);
- setPlotResultEnabled(!running);
- setSaveResultEnabled(!running);
+ setButtonsEnabled(!running);
}
void ContainerSubtraction::setPlotResultIsPlotting(bool plotting) {
m_uiForm.pbPlot->setText(plotting ? "Plotting..." : "Plot");
- setPlotResultEnabled(!plotting);
- setRunEnabled(!plotting);
- setSaveResultEnabled(!plotting);
+ setButtonsEnabled(!plotting);
}
} // namespace CustomInterfaces
diff --git a/qt/scientific_interfaces/Indirect/ContainerSubtraction.h b/qt/scientific_interfaces/Indirect/ContainerSubtraction.h
index be4e78960bd7825b38541d8bc3ec79b1c070fc30..45023799de1d67a620a1c306f38a9edcb17004a3 100644
--- a/qt/scientific_interfaces/Indirect/ContainerSubtraction.h
+++ b/qt/scientific_interfaces/Indirect/ContainerSubtraction.h
@@ -93,6 +93,7 @@ private:
void setRunEnabled(bool enabled);
void setPlotResultEnabled(bool enabled);
void setSaveResultEnabled(bool enabled);
+ void setButtonsEnabled(bool enabled);
void setRunIsRunning(bool running);
void setPlotResultIsPlotting(bool plotting);
diff --git a/qt/scientific_interfaces/Indirect/ConvFit.cpp b/qt/scientific_interfaces/Indirect/ConvFit.cpp
index 229a551fc1f6c969a8180e112c6dfcef398c7307..b6d1bb739286777163450e3da41b3028fddb4918 100644
--- a/qt/scientific_interfaces/Indirect/ConvFit.cpp
+++ b/qt/scientific_interfaces/Indirect/ConvFit.cpp
@@ -195,17 +195,21 @@ void ConvFit::setSaveResultEnabled(bool enabled) {
m_uiForm->pbSave->setEnabled(enabled);
}
+void ConvFit::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+ setFitSingleSpectrumEnabled(enabled);
+}
+
void ConvFit::setRunIsRunning(bool running) {
m_uiForm->pbRun->setText(running ? "Running..." : "Run");
- setRunEnabled(!running);
- setPlotResultEnabled(!running);
- setSaveResultEnabled(!running);
- setFitSingleSpectrumEnabled(!running);
+ setButtonsEnabled(!running);
}
void ConvFit::setPlotResultIsPlotting(bool plotting) {
m_uiForm->pbPlot->setText(plotting ? "Plotting..." : "Plot");
- setPlotResultEnabled(!plotting);
+ setButtonsEnabled(!plotting);
}
void ConvFit::runClicked() { runTab(); }
diff --git a/qt/scientific_interfaces/Indirect/ConvFit.h b/qt/scientific_interfaces/Indirect/ConvFit.h
index 4659b93a83a55ff3b14027da9ddf1df77f404d9f..b73f96366c31a7113bdd7128b4ac38e89009365a 100644
--- a/qt/scientific_interfaces/Indirect/ConvFit.h
+++ b/qt/scientific_interfaces/Indirect/ConvFit.h
@@ -46,7 +46,7 @@ private:
void setRunEnabled(bool enabled);
void setFitSingleSpectrumEnabled(bool enabled);
-
+ void setButtonsEnabled(bool enabled);
void setPlotResultIsPlotting(bool plotting);
std::string fitTypeString() const;
diff --git a/qt/scientific_interfaces/Indirect/Elwin.cpp b/qt/scientific_interfaces/Indirect/Elwin.cpp
index 7c8c6c064dd2b274d4c01b985d4a2a7ecb892cdc..34d8fd5b0c3ab91fd405ac7e59494fba830cab39 100644
--- a/qt/scientific_interfaces/Indirect/Elwin.cpp
+++ b/qt/scientific_interfaces/Indirect/Elwin.cpp
@@ -256,8 +256,9 @@ void Elwin::unGroupInput(bool error) {
ungroupAlg->setProperty("InputWorkspace", "IDA_Elwin_Input");
ungroupAlg->execute();
}
- setPlotResultEnabled(true);
- setSaveResultEnabled(true);
+ } else {
+ setPlotResultEnabled(false);
+ setSaveResultEnabled(false);
}
}
@@ -529,16 +530,20 @@ void Elwin::setSaveResultEnabled(bool enabled) {
m_uiForm.pbSave->setEnabled(enabled);
}
+void Elwin::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+}
+
void Elwin::setRunIsRunning(bool running) {
m_uiForm.pbRun->setText(running ? "Running..." : "Run");
- setRunEnabled(!running);
- setPlotResultEnabled(!running);
- setSaveResultEnabled(!running);
+ setButtonsEnabled(!running);
}
void Elwin::setPlotResultIsPlotting(bool plotting) {
m_uiForm.pbPlot->setText(plotting ? "Plotting..." : "Plot Result");
- setPlotResultEnabled(!plotting);
+ setButtonsEnabled(!plotting);
}
void Elwin::runClicked() { runTab(); }
diff --git a/qt/scientific_interfaces/Indirect/Elwin.h b/qt/scientific_interfaces/Indirect/Elwin.h
index 8fc9430e2dae840e8004cf7f2477d15aebd1e8df..73249fadae0612c11d36a8e87d077c823923fb5e 100644
--- a/qt/scientific_interfaces/Indirect/Elwin.h
+++ b/qt/scientific_interfaces/Indirect/Elwin.h
@@ -20,6 +20,19 @@ class DLLExport Elwin : public IndirectDataAnalysisTab {
public:
Elwin(QWidget *parent = nullptr);
+private slots:
+ void newInputFiles();
+ void newPreviewFileSelected(int index);
+ void plotInput();
+ void twoRanges(QtProperty *prop, bool);
+ void minChanged(double val);
+ void maxChanged(double val);
+ void updateRS(QtProperty *prop, double val);
+ void unGroupInput(bool error);
+ void runClicked();
+ void saveClicked();
+ void plotClicked();
+
private:
void run() override;
void setup() override;
@@ -32,24 +45,10 @@ private:
void setRunEnabled(bool enabled);
void setPlotResultEnabled(bool enabled);
void setSaveResultEnabled(bool enabled);
-
+ void setButtonsEnabled(bool enabled);
void setRunIsRunning(bool running);
void setPlotResultIsPlotting(bool plotting);
-private slots:
- void newInputFiles();
- void newPreviewFileSelected(int index);
- void plotInput();
- void twoRanges(QtProperty *prop, bool);
- void minChanged(double val);
- void maxChanged(double val);
- void updateRS(QtProperty *prop, double val);
- void unGroupInput(bool error);
- void runClicked();
- void saveClicked();
- void plotClicked();
-
-private:
Ui::Elwin m_uiForm;
QtTreePropertyBrowser *m_elwTree;
};
diff --git a/qt/scientific_interfaces/Indirect/IndirectBayes.cpp b/qt/scientific_interfaces/Indirect/IndirectBayes.cpp
index 48aee3726243814dca6ed6c84a1e254e9d1d00f5..248aff44ba52de9c6fc97cc8e40fdaae33c81b0f 100644
--- a/qt/scientific_interfaces/Indirect/IndirectBayes.cpp
+++ b/qt/scientific_interfaces/Indirect/IndirectBayes.cpp
@@ -49,7 +49,6 @@ IndirectBayes::IndirectBayes(QWidget *parent)
// Connect statements for the buttons shared between all tabs on the Indirect
// Bayes interface
- connect(m_uiForm.pbRun, SIGNAL(clicked()), this, SLOT(runClicked()));
connect(m_uiForm.pbHelp, SIGNAL(clicked()), this, SLOT(helpClicked()));
connect(m_uiForm.pbManageDirs, SIGNAL(clicked()), this,
SLOT(manageUserDirectories()));
@@ -101,21 +100,6 @@ void IndirectBayes::loadSettings() {
settings.endGroup();
}
-/**
- * Slot to run the underlying algorithm code based on the currently selected
- * tab.
- *
- * This method checks the tabs validate method is passing before calling
- * the run method.
- */
-void IndirectBayes::runClicked() {
- int tabIndex = m_uiForm.indirectBayesTabs->currentIndex();
-
- if (m_bayesTabs[tabIndex]->validateTab()) {
- m_bayesTabs[tabIndex]->runTab();
- }
-}
-
/**
* Slot to open a new browser window and navigate to the help page
* on the wiki for the currently selected tab.
diff --git a/qt/scientific_interfaces/Indirect/IndirectBayes.h b/qt/scientific_interfaces/Indirect/IndirectBayes.h
index 963d24906401070ad36659e4cb5d7922616f0057..12ecffcddfc51305e582c864c96032d21b7fbe28 100644
--- a/qt/scientific_interfaces/Indirect/IndirectBayes.h
+++ b/qt/scientific_interfaces/Indirect/IndirectBayes.h
@@ -48,8 +48,6 @@ public: // public constructor, destructor and functions
private slots:
// Run the appropriate action depending based on the selected tab
- /// Slot for clicking on the run button
- void runClicked();
/// Slot for clicking on the hlep button
void helpClicked();
/// Slot for clicking on the manage directories button
diff --git a/qt/scientific_interfaces/Indirect/IndirectBayes.ui b/qt/scientific_interfaces/Indirect/IndirectBayes.ui
index a258af6592862e57f2f471a7ec5d87ef1ac82e44..e10a747d1f2e14f7c52c16ff3aba4373b8ccefc5 100644
--- a/qt/scientific_interfaces/Indirect/IndirectBayes.ui
+++ b/qt/scientific_interfaces/Indirect/IndirectBayes.ui
@@ -14,96 +14,76 @@
<string>Indirect Bayes</string>
</property>
<widget class="QWidget" name="centralwidget">
- <layout class="QVBoxLayout" name="verticalLayout">
- <item>
- <widget class="QTabWidget" name="indirectBayesTabs">
- <property name="currentIndex">
- <number>0</number>
- </property>
- <widget class="QWidget" name="ResNorm">
- <attribute name="title">
- <string>ResNorm</string>
- </attribute>
- </widget>
- <widget class="QWidget" name="Quasi">
- <attribute name="title">
- <string>Quasi</string>
- </attribute>
- </widget>
- <widget class="QWidget" name="Stretch">
- <attribute name="title">
- <string>Stretch</string>
- </attribute>
- </widget>
- </widget>
- </item>
- <item>
- <layout class="QHBoxLayout" name="layout_bottom">
- <item>
- <widget class="QPushButton" name="pbHelp">
- <property name="enabled">
- <bool>true</bool>
- </property>
- <property name="sizePolicy">
- <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="maximumSize">
- <size>
- <width>20</width>
- <height>20</height>
- </size>
- </property>
- <property name="text">
- <string>?</string>
- </property>
+ <layout class="QVBoxLayout" name="verticalLayout">
+ <item>
+ <widget class="QTabWidget" name="indirectBayesTabs">
+ <property name="currentIndex">
+ <number>0</number>
+ </property>
+ <widget class="QWidget" name="ResNorm">
+ <attribute name="title">
+ <string>ResNorm</string>
+ </attribute>
</widget>
- </item>
- <item>
- <spacer name="horizontalSpacer_14">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="QPushButton" name="pbRun">
- <property name="text">
- <string>Run</string>
- </property>
+ <widget class="QWidget" name="Quasi">
+ <attribute name="title">
+ <string>Quasi</string>
+ </attribute>
</widget>
- </item>
- <item>
- <spacer name="horizontalSpacer_11">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="QPushButton" name="pbManageDirs">
- <property name="text">
- <string>Manage Directories</string>
- </property>
+ <widget class="QWidget" name="Stretch">
+ <attribute name="title">
+ <string>Stretch</string>
+ </attribute>
</widget>
- </item>
- </layout>
- </item>
- </layout>
+ </widget>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="layout_bottom">
+ <item>
+ <widget class="QPushButton" name="pbHelp">
+ <property name="enabled">
+ <bool>true</bool>
+ </property>
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>20</width>
+ <height>20</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>?</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_14">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="pbManageDirs">
+ <property name="text">
+ <string>Manage Directories</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ </layout>
</widget>
</widget>
<resources/>
diff --git a/qt/scientific_interfaces/Indirect/IndirectFitOutput.cpp b/qt/scientific_interfaces/Indirect/IndirectFitOutput.cpp
index 31fb3c5edb6d3b60e837c1c9ae7fd8283eb66f0d..e5e1909e15c11d95d7718017c7783399d9ef9ce0 100644
--- a/qt/scientific_interfaces/Indirect/IndirectFitOutput.cpp
+++ b/qt/scientific_interfaces/Indirect/IndirectFitOutput.cpp
@@ -272,10 +272,9 @@ IndirectFitOutput::getResultLocation(IndirectFitData const *fitData,
}
std::vector<std::string> IndirectFitOutput::getResultParameterNames() const {
- if (auto resultWorkspace = getLastResultWorkspace()) {
+ if (auto resultWorkspace = getLastResultWorkspace())
if (auto workspace = getMatrixWorkspaceFromGroup(resultWorkspace, 0))
return getAxisLabels(workspace, 1);
- }
return std::vector<std::string>();
}
@@ -324,11 +323,11 @@ void IndirectFitOutput::addOutput(WorkspaceGroup_sptr resultGroup,
m_resultGroup = resultGroup;
}
-void IndirectFitOutput::addOutput(
- Mantid::API::WorkspaceGroup_sptr resultGroup,
- Mantid::API::ITableWorkspace_sptr parameterTable,
- Mantid::API::WorkspaceGroup_sptr resultWorkspace,
- IndirectFitData const *fitData, std::size_t spectrum) {
+void IndirectFitOutput::addOutput(WorkspaceGroup_sptr resultGroup,
+ ITableWorkspace_sptr parameterTable,
+ WorkspaceGroup_sptr resultWorkspace,
+ IndirectFitData const *fitData,
+ std::size_t spectrum) {
TableRowExtractor extractRowFromTable(parameterTable);
m_parameters[fitData][spectrum] = extractRowFromTable(0);
m_outputResultLocations[fitData][spectrum] = ResultLocation(resultGroup, 0);
@@ -359,8 +358,8 @@ void IndirectFitOutput::updateParameters(ITableWorkspace_sptr parameterTable,
}
void IndirectFitOutput::updateFitResultsFromUnstructured(
- Mantid::API::WorkspaceGroup_sptr resultGroup,
- const FitDataIterator &fitDataBegin, const FitDataIterator &fitDataEnd) {
+ WorkspaceGroup_sptr resultGroup, const FitDataIterator &fitDataBegin,
+ const FitDataIterator &fitDataEnd) {
std::unordered_map<MatrixWorkspace *,
std::unordered_map<std::size_t, std::size_t>>
resultIndices;
@@ -376,8 +375,8 @@ void IndirectFitOutput::updateFitResultsFromUnstructured(
}
void IndirectFitOutput::updateFitResultsFromStructured(
- Mantid::API::WorkspaceGroup_sptr resultGroup,
- const FitDataIterator &fitDataBegin, const FitDataIterator &fitDataEnd) {
+ WorkspaceGroup_sptr resultGroup, const FitDataIterator &fitDataBegin,
+ const FitDataIterator &fitDataEnd) {
auto update = [&](IndirectFitData const *inputData) {
auto &fitResults = extractOrAddDefault(m_outputResultLocations, inputData);
return [&](std::size_t index, std::size_t spectrum) {
diff --git a/qt/scientific_interfaces/Indirect/IndirectFitOutput.h b/qt/scientific_interfaces/Indirect/IndirectFitOutput.h
index 85a8188e4867032dc67fce43565e87f0078bfd9b..c92182711fd7ffea092c7ad2e052d16ddd7caabc 100644
--- a/qt/scientific_interfaces/Indirect/IndirectFitOutput.h
+++ b/qt/scientific_interfaces/Indirect/IndirectFitOutput.h
@@ -9,6 +9,7 @@
#include "IndirectFitData.h"
+#include "DllConfig.h"
#include "MantidAPI/ITableWorkspace.h"
#include "MantidAPI/WorkspaceGroup.h"
@@ -49,7 +50,7 @@ using FitDataIterator =
IndirectFitOutput - Stores the output of a QENS fit and provides
convenient access to the output parameters.
*/
-class IndirectFitOutput {
+class MANTIDQT_INDIRECT_DLL IndirectFitOutput {
public:
IndirectFitOutput(Mantid::API::WorkspaceGroup_sptr resultGroup,
Mantid::API::ITableWorkspace_sptr parameterTable,
diff --git a/qt/scientific_interfaces/Indirect/IndirectFitPlotModel.cpp b/qt/scientific_interfaces/Indirect/IndirectFitPlotModel.cpp
index d7446b0846f1529ceaa973301d59f5acdc3c6d0d..634c668f12269b0bd42eec48997c7fffe22e2e0a 100644
--- a/qt/scientific_interfaces/Indirect/IndirectFitPlotModel.cpp
+++ b/qt/scientific_interfaces/Indirect/IndirectFitPlotModel.cpp
@@ -17,7 +17,7 @@
namespace {
using namespace Mantid::API;
-// The name of the conjoined input and guess name -- required for
+// The name of the conjoined input and guess workspaces -- required for
// creating an external guess plot.
const std::string INPUT_AND_GUESS_NAME = "__QENSInputAndGuess";
@@ -124,11 +124,13 @@ void IndirectFitPlotModel::setActiveSpectrum(std::size_t spectrum) {
}
void IndirectFitPlotModel::setStartX(double startX) {
- m_fittingModel->setStartX(startX, m_activeIndex, m_activeSpectrum);
+ if (getRange().second > startX)
+ m_fittingModel->setStartX(startX, m_activeIndex, m_activeSpectrum);
}
void IndirectFitPlotModel::setEndX(double endX) {
- m_fittingModel->setEndX(endX, m_activeIndex, m_activeSpectrum);
+ if (getRange().first < endX)
+ m_fittingModel->setEndX(endX, m_activeIndex, m_activeSpectrum);
}
void IndirectFitPlotModel::setFWHM(double fwhm) {
@@ -182,7 +184,9 @@ std::size_t IndirectFitPlotModel::numberOfWorkspaces() const {
}
std::string IndirectFitPlotModel::getFitDataName(std::size_t index) const {
- return m_fittingModel->createDisplayName("%1% (%2%)", "-", index);
+ if (m_fittingModel->getWorkspace(index))
+ return m_fittingModel->createDisplayName("%1% (%2%)", "-", index);
+ return "";
}
std::string IndirectFitPlotModel::getFitDataName() const {
@@ -190,7 +194,9 @@ std::string IndirectFitPlotModel::getFitDataName() const {
}
std::string IndirectFitPlotModel::getLastFitDataName() const {
- return getFitDataName(m_fittingModel->numberOfWorkspaces() - 1);
+ if (m_fittingModel->numberOfWorkspaces())
+ return getFitDataName(m_fittingModel->numberOfWorkspaces() - 1);
+ return "";
}
boost::optional<double> IndirectFitPlotModel::getFirstHWHM() const {
diff --git a/qt/scientific_interfaces/Indirect/Iqt.cpp b/qt/scientific_interfaces/Indirect/Iqt.cpp
index 72f7ae349ca737693016384f58036d3e0e00acc2..5866c91b89de081a776eab23c900c30131cc9468 100644
--- a/qt/scientific_interfaces/Indirect/Iqt.cpp
+++ b/qt/scientific_interfaces/Indirect/Iqt.cpp
@@ -187,10 +187,10 @@ void Iqt::run() {
*/
void Iqt::algorithmComplete(bool error) {
setRunIsRunning(false);
- if (!error) {
- setPlotResultEnabled(true);
- setTiledPlotEnabled(true);
- setSaveResultEnabled(true);
+ if (error) {
+ setPlotResultEnabled(false);
+ setTiledPlotEnabled(false);
+ setSaveResultEnabled(false);
}
}
/**
@@ -478,22 +478,26 @@ void Iqt::setSaveResultEnabled(bool enabled) {
m_uiForm.pbSave->setEnabled(enabled);
}
+void Iqt::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+ setTiledPlotEnabled(enabled);
+}
+
void Iqt::setRunIsRunning(bool running) {
m_uiForm.pbRun->setText(running ? "Running..." : "Run");
- setRunEnabled(!running);
- setPlotResultEnabled(!running);
- setSaveResultEnabled(!running);
- setTiledPlotEnabled(!running);
+ setButtonsEnabled(!running);
}
void Iqt::setPlotResultIsPlotting(bool plotting) {
m_uiForm.pbPlot->setText(plotting ? "Plotting..." : "Plot Result");
- setPlotResultEnabled(!plotting);
+ setButtonsEnabled(!plotting);
}
void Iqt::setTiledPlotIsPlotting(bool plotting) {
m_uiForm.pbTile->setText(plotting ? "Plotting..." : "Tiled Plot");
- setTiledPlotEnabled(!plotting);
+ setButtonsEnabled(!plotting);
}
void Iqt::runClicked() { runTab(); }
diff --git a/qt/scientific_interfaces/Indirect/Iqt.h b/qt/scientific_interfaces/Indirect/Iqt.h
index 26f8c5e83dd75dd658cfc7d82eab7da242e1dc76..d23248a10445eee0960eb4d8a353d594dc34ec1e 100644
--- a/qt/scientific_interfaces/Indirect/Iqt.h
+++ b/qt/scientific_interfaces/Indirect/Iqt.h
@@ -31,7 +31,7 @@ private:
void setPlotResultEnabled(bool enabled);
void setTiledPlotEnabled(bool enabled);
void setSaveResultEnabled(bool enabled);
-
+ void setButtonsEnabled(bool enabled);
void setRunIsRunning(bool running);
void setPlotResultIsPlotting(bool plotting);
void setTiledPlotIsPlotting(bool plotting);
diff --git a/qt/scientific_interfaces/Indirect/IqtFit.cpp b/qt/scientific_interfaces/Indirect/IqtFit.cpp
index f5b089429db78e51985b94965459320caedc281c..c6506b49fd361012ad300148dbf2791629b5d1a6 100644
--- a/qt/scientific_interfaces/Indirect/IqtFit.cpp
+++ b/qt/scientific_interfaces/Indirect/IqtFit.cpp
@@ -152,17 +152,21 @@ void IqtFit::setSaveResultEnabled(bool enabled) {
m_uiForm->pbSave->setEnabled(enabled);
}
+void IqtFit::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+ setFitSingleSpectrumEnabled(enabled);
+}
+
void IqtFit::setRunIsRunning(bool running) {
m_uiForm->pbRun->setText(running ? "Running..." : "Run");
- setRunEnabled(!running);
- setPlotResultEnabled(!running);
- setSaveResultEnabled(!running);
- setFitSingleSpectrumEnabled(!running);
+ setButtonsEnabled(!running);
}
void IqtFit::setPlotResultIsPlotting(bool plotting) {
m_uiForm->pbPlot->setText(plotting ? "Plotting..." : "Plot");
- setPlotResultEnabled(!plotting);
+ setButtonsEnabled(!plotting);
}
void IqtFit::runClicked() { runTab(); }
diff --git a/qt/scientific_interfaces/Indirect/IqtFit.h b/qt/scientific_interfaces/Indirect/IqtFit.h
index a2a8aa17a8dda8e4624683c6e5d388a706e105a2..8fd5ead60b8bec92a74dd56ac58b53b3b383aee6 100644
--- a/qt/scientific_interfaces/Indirect/IqtFit.h
+++ b/qt/scientific_interfaces/Indirect/IqtFit.h
@@ -57,6 +57,7 @@ private:
void setRunEnabled(bool enabled);
void setFitSingleSpectrumEnabled(bool enabled);
+ void setButtonsEnabled(bool enabled);
void setPlotResultIsPlotting(bool plotting);
diff --git a/qt/scientific_interfaces/Indirect/JumpFit.cpp b/qt/scientific_interfaces/Indirect/JumpFit.cpp
index 4f18cf68ff632beda6fec19450a063d5f8e12c7c..c66bd341e88cdc7c72b7a51595811cedb64020a7 100644
--- a/qt/scientific_interfaces/Indirect/JumpFit.cpp
+++ b/qt/scientific_interfaces/Indirect/JumpFit.cpp
@@ -137,17 +137,21 @@ void JumpFit::setSaveResultEnabled(bool enabled) {
m_uiForm->pbSave->setEnabled(enabled);
}
+void JumpFit::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+ setFitSingleSpectrumEnabled(enabled);
+}
+
void JumpFit::setRunIsRunning(bool running) {
m_uiForm->pbRun->setText(running ? "Running..." : "Run");
- setRunEnabled(!running);
- setPlotResultEnabled(!running);
- setSaveResultEnabled(!running);
- setFitSingleSpectrumEnabled(!running);
+ setButtonsEnabled(!running);
}
void JumpFit::setPlotResultIsPlotting(bool plotting) {
m_uiForm->pbPlot->setText(plotting ? "Plotting..." : "Plot");
- setPlotResultEnabled(!plotting);
+ setButtonsEnabled(!plotting);
}
void JumpFit::runClicked() { runTab(); }
diff --git a/qt/scientific_interfaces/Indirect/JumpFit.h b/qt/scientific_interfaces/Indirect/JumpFit.h
index b79c3fbbd653aebf35aac3d5b0e6ea252921b7a5..81742380b129e9c8e384cc34fd01709a87d50197 100644
--- a/qt/scientific_interfaces/Indirect/JumpFit.h
+++ b/qt/scientific_interfaces/Indirect/JumpFit.h
@@ -48,7 +48,7 @@ private:
void setRunEnabled(bool enabled);
void setFitSingleSpectrumEnabled(bool enabled);
-
+ void setButtonsEnabled(bool enabled);
void setPlotResultIsPlotting(bool plotting);
JumpFitModel *m_jumpFittingModel;
diff --git a/qt/scientific_interfaces/Indirect/MSDFit.cpp b/qt/scientific_interfaces/Indirect/MSDFit.cpp
index b345224ad0cc0082175755f7a5a17f342668a928..9f038d32c7133e11b85933de82c87e52346a5859 100644
--- a/qt/scientific_interfaces/Indirect/MSDFit.cpp
+++ b/qt/scientific_interfaces/Indirect/MSDFit.cpp
@@ -98,17 +98,21 @@ void MSDFit::setSaveResultEnabled(bool enabled) {
m_uiForm->pbSave->setEnabled(enabled);
}
+void MSDFit::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+ setFitSingleSpectrumEnabled(enabled);
+}
+
void MSDFit::setRunIsRunning(bool running) {
m_uiForm->pbRun->setText(running ? "Running..." : "Run");
- setRunEnabled(!running);
- setPlotResultEnabled(!running);
- setSaveResultEnabled(!running);
- setFitSingleSpectrumEnabled(!running);
+ setButtonsEnabled(!running);
}
void MSDFit::setPlotResultIsPlotting(bool plotting) {
m_uiForm->pbPlot->setText(plotting ? "Plotting..." : "Plot");
- setPlotResultEnabled(!plotting);
+ setButtonsEnabled(!plotting);
}
void MSDFit::runClicked() { runTab(); }
diff --git a/qt/scientific_interfaces/Indirect/MSDFit.h b/qt/scientific_interfaces/Indirect/MSDFit.h
index 5958fe078db11b74e128ea3b517419b2d7ecc02c..7e08dffc71956d82a77f53b54f6afbff7f88eec4 100644
--- a/qt/scientific_interfaces/Indirect/MSDFit.h
+++ b/qt/scientific_interfaces/Indirect/MSDFit.h
@@ -41,7 +41,7 @@ private:
void setRunEnabled(bool enabled);
void setFitSingleSpectrumEnabled(bool enabled);
-
+ void setButtonsEnabled(bool enabled);
void setPlotResultIsPlotting(bool plotting);
MSDFitModel *m_msdFittingModel;
diff --git a/qt/scientific_interfaces/Indirect/Quasi.cpp b/qt/scientific_interfaces/Indirect/Quasi.cpp
index 69ceb393d189b45e3664ed0218bcdf6ea3ba1cb8..7ed13fc675746b643f4b38996d0a40dd5697a57d 100644
--- a/qt/scientific_interfaces/Indirect/Quasi.cpp
+++ b/qt/scientific_interfaces/Indirect/Quasi.cpp
@@ -71,10 +71,8 @@ Quasi::Quasi(QWidget *parent) : IndirectBayesTab(parent), m_previewSpec(0) {
connect(m_uiForm.pbPlotPreview, SIGNAL(clicked()), this,
SLOT(plotCurrentPreview()));
- // Post saving
+ connect(m_uiForm.pbRun, SIGNAL(clicked()), this, SLOT(runClicked()));
connect(m_uiForm.pbSave, SIGNAL(clicked()), this, SLOT(saveClicked()));
-
- // Post plotting
connect(m_uiForm.pbPlot, SIGNAL(clicked()), this, SLOT(plotClicked()));
}
@@ -146,24 +144,6 @@ bool Quasi::validate() {
* Run the BayesQuasi algorithm
*/
void Quasi::run() {
-
- auto saveDirectory = Mantid::Kernel::ConfigService::Instance().getString(
- "defaultsave.directory");
- if (saveDirectory.compare("") == 0) {
- const char *textMessage =
- "BayesQuasi requires a default save directory and "
- "one is not currently set."
- " If run, the algorithm will default to saving files "
- "to the current working directory."
- " Would you still like to run the algorithm?";
- int result = QMessageBox::question(nullptr, tr("Save Directory"),
- tr(textMessage), QMessageBox::Yes,
- QMessageBox::No, QMessageBox::NoButton);
- if (result == QMessageBox::No) {
- return;
- }
- }
-
bool elasticPeak = false;
bool sequence = false;
@@ -173,9 +153,9 @@ void Quasi::run() {
bool useResNorm = false;
std::string resNormFile("");
- std::string sampleName =
+ std::string const sampleName =
m_uiForm.dsSample->getCurrentDataName().toStdString();
- std::string resName =
+ std::string const resName =
m_uiForm.dsResolution->getCurrentDataName().toStdString();
std::string program = m_uiForm.cbProgram->currentText().toStdString();
@@ -187,7 +167,8 @@ void Quasi::run() {
}
// Collect input from fit options section
- std::string background = m_uiForm.cbBackground->currentText().toStdString();
+ std::string const background =
+ m_uiForm.cbBackground->currentText().toStdString();
if (m_uiForm.chkElasticPeak->isChecked()) {
elasticPeak = true;
@@ -207,11 +188,11 @@ void Quasi::run() {
}
// Collect input from the properties browser
- double eMin = m_properties["EMin"]->valueText().toDouble();
- double eMax = m_properties["EMax"]->valueText().toDouble();
+ double const eMin = m_properties["EMin"]->valueText().toDouble();
+ double const eMax = m_properties["EMax"]->valueText().toDouble();
- long sampleBins = m_properties["SampleBinning"]->valueText().toLong();
- long resBins = m_properties["ResBinning"]->valueText().toLong();
+ long const sampleBins = m_properties["SampleBinning"]->valueText().toLong();
+ long const resBins = m_properties["ResBinning"]->valueText().toLong();
IAlgorithm_sptr runAlg = AlgorithmManager::Instance().create("BayesQuasi");
runAlg->initialize();
@@ -244,13 +225,12 @@ void Quasi::run() {
* Enable plotting and saving and fit curves on the mini plot.
*/
void Quasi::algorithmComplete(bool error) {
- if (error)
- return;
- else {
+ setRunIsRunning(false);
+ if (!error)
updateMiniPlot();
- m_uiForm.cbPlot->setEnabled(true);
- m_uiForm.pbPlot->setEnabled(true);
- m_uiForm.pbSave->setEnabled(true);
+ else {
+ setPlotResultEnabled(false);
+ setSaveResultEnabled(false);
}
}
@@ -449,33 +429,69 @@ void Quasi::saveClicked() {
QString saveDirectory = QString::fromStdString(
Mantid::Kernel::ConfigService::Instance().getString(
"defaultsave.directory"));
- const auto fitWS = m_QuasiAlg->getPropertyValue("OutputWorkspaceFit");
+ auto const fitWS = m_QuasiAlg->getPropertyValue("OutputWorkspaceFit");
IndirectTab::checkADSForPlotSaveWorkspace(fitWS, false);
- QString QfitWS = QString::fromStdString(fitWS);
- const auto fitPath = saveDirectory + QfitWS + ".nxs";
+ QString const QfitWS = QString::fromStdString(fitWS);
+ auto const fitPath = saveDirectory + QfitWS + ".nxs";
addSaveWorkspaceToQueue(QfitWS, fitPath);
- const auto resultWS = m_QuasiAlg->getPropertyValue("OutputWorkspaceResult");
+ auto const resultWS = m_QuasiAlg->getPropertyValue("OutputWorkspaceResult");
IndirectTab::checkADSForPlotSaveWorkspace(resultWS, false);
- QString QresultWS = QString::fromStdString(resultWS);
- const auto resultPath = saveDirectory + QresultWS + ".nxs";
+ QString const QresultWS = QString::fromStdString(resultWS);
+ auto const resultPath = saveDirectory + QresultWS + ".nxs";
addSaveWorkspaceToQueue(QresultWS, resultPath);
m_batchAlgoRunner->executeBatchAsync();
}
+void Quasi::runClicked() {
+ if (validateTab()) {
+ auto const saveDirectory =
+ Mantid::Kernel::ConfigService::Instance().getString(
+ "defaultsave.directory");
+ displayMessageAndRun(saveDirectory);
+ }
+}
+
+void Quasi::displayMessageAndRun(std::string const &saveDirectory) {
+ if (saveDirectory.empty()) {
+ int const result = displaySaveDirectoryMessage();
+ if (result != QMessageBox::No) {
+ setRunIsRunning(true);
+ runTab();
+ }
+ } else {
+ setRunIsRunning(true);
+ runTab();
+ }
+}
+
+int Quasi::displaySaveDirectoryMessage() {
+ char const *textMessage =
+ "BayesQuasi requires a default save directory and "
+ "one is not currently set."
+ " If run, the algorithm will default to saving files "
+ "to the current working directory."
+ " Would you still like to run the algorithm?";
+ return QMessageBox::question(nullptr, tr("Save Directory"), tr(textMessage),
+ QMessageBox::Yes, QMessageBox::No,
+ QMessageBox::NoButton);
+}
+
/**
* Handles plotting the selected plot when plot is clicked
*/
void Quasi::plotClicked() {
+ setPlotResultIsPlotting(true);
+
// Output options
- std::string plot = m_uiForm.cbPlot->currentText().toStdString();
- QString program = m_uiForm.cbProgram->currentText();
- const auto resultName = m_QuasiAlg->getPropertyValue("OutputWorkspaceResult");
+ std::string const plot = m_uiForm.cbPlot->currentText().toStdString();
+ QString const program = m_uiForm.cbProgram->currentText();
+ auto const resultName = m_QuasiAlg->getPropertyValue("OutputWorkspaceResult");
if ((plot == "Prob" || plot == "All") && (program == "Lorentzians")) {
- const auto probWS = m_QuasiAlg->getPropertyValue("OutputWorkspaceProb");
+ auto const probWS = m_QuasiAlg->getPropertyValue("OutputWorkspaceProb");
// Check workspace exists
IndirectTab::checkADSForPlotSaveWorkspace(probWS, true);
- QString QprobWS = QString::fromStdString(probWS);
+ QString const QprobWS = QString::fromStdString(probWS);
IndirectTab::plotSpectrum(QprobWS, 1, 2);
}
if (plot == "Fit" || plot == "All") {
@@ -483,27 +499,27 @@ void Quasi::plotClicked() {
fitName.pop_back();
fitName.append("_0");
IndirectTab::checkADSForPlotSaveWorkspace(fitName, true);
- QString QfitWS = QString::fromStdString(fitName);
+ QString const QfitWS = QString::fromStdString(fitName);
if (program == "Lorentzians")
IndirectTab::plotSpectra(QfitWS, {0, 1, 2, 4});
else
IndirectTab::plotSpectra(QfitWS, {0, 1, 2});
}
- MatrixWorkspace_sptr resultWS =
+ auto const resultWS =
AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(resultName);
- int numSpectra = (int)resultWS->getNumberHistograms();
+ int const numSpectra = (int)resultWS->getNumberHistograms();
IndirectTab::checkADSForPlotSaveWorkspace(resultName, true);
- QString QresultWS = QString::fromStdString(resultName);
- auto paramNames = {"Amplitude", "FWHM", "Beta"};
- for (std::string paramName : paramNames) {
+ QString const QresultWS = QString::fromStdString(resultName);
+ auto const paramNames = {"Amplitude", "FWHM", "Beta"};
+ for (std::string const ¶mName : paramNames) {
if (plot == paramName || plot == "All") {
std::vector<int> spectraIndices = {};
for (int i = 0; i < numSpectra; i++) {
auto axisLabel = resultWS->getAxis(1)->label(i);
- auto found = axisLabel.find(paramName);
+ auto const found = axisLabel.find(paramName);
if (found != std::string::npos) {
spectraIndices.push_back(i);
@@ -517,6 +533,34 @@ void Quasi::plotClicked() {
}
}
}
+ setPlotResultIsPlotting(false);
+}
+
+void Quasi::setRunEnabled(bool enabled) { m_uiForm.pbRun->setEnabled(enabled); }
+
+void Quasi::setPlotResultEnabled(bool enabled) {
+ m_uiForm.pbPlot->setEnabled(enabled);
+ m_uiForm.cbPlot->setEnabled(enabled);
+}
+
+void Quasi::setSaveResultEnabled(bool enabled) {
+ m_uiForm.pbSave->setEnabled(enabled);
+}
+
+void Quasi::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+}
+
+void Quasi::setRunIsRunning(bool running) {
+ m_uiForm.pbRun->setText(running ? "Running..." : "Run");
+ setButtonsEnabled(!running);
+}
+
+void Quasi::setPlotResultIsPlotting(bool plotting) {
+ m_uiForm.pbPlot->setText(plotting ? "Plotting..." : "Plot");
+ setButtonsEnabled(!plotting);
}
} // namespace CustomInterfaces
diff --git a/qt/scientific_interfaces/Indirect/Quasi.h b/qt/scientific_interfaces/Indirect/Quasi.h
index 02eb29f41491617e5bd4ad10faac7dc9da74905b..a8dd6e8af8aa17e0669963f83c7efe37421caef2 100644
--- a/qt/scientific_interfaces/Indirect/Quasi.h
+++ b/qt/scientific_interfaces/Indirect/Quasi.h
@@ -44,14 +44,23 @@ private slots:
void updateMiniPlot();
/// Handles what happen after the algorithm is run
void algorithmComplete(bool error);
- // Handles saving of workspace
- void saveClicked();
- // Handles plotting
+
+ void runClicked();
void plotClicked();
- // Handles plotting current preview
void plotCurrentPreview();
+ void saveClicked();
private:
+ void displayMessageAndRun(std::string const &saveDirectory);
+ int displaySaveDirectoryMessage();
+
+ void setRunEnabled(bool enabled);
+ void setPlotResultEnabled(bool enabled);
+ void setSaveResultEnabled(bool enabled);
+ void setButtonsEnabled(bool enabled);
+ void setRunIsRunning(bool running);
+ void setPlotResultIsPlotting(bool plotting);
+
/// Current preview spectrum
int m_previewSpec;
/// The ui form
diff --git a/qt/scientific_interfaces/Indirect/Quasi.ui b/qt/scientific_interfaces/Indirect/Quasi.ui
index 1afe4818179401a145e4322ec8396a32e31fed28..e360191b09420430001b07a36f3b9837df53ab9a 100644
--- a/qt/scientific_interfaces/Indirect/Quasi.ui
+++ b/qt/scientific_interfaces/Indirect/Quasi.ui
@@ -327,89 +327,170 @@
</layout>
</item>
<item>
- <layout class="QHBoxLayout" name="horizontalLayout_44">
- <item>
- <widget class="QGroupBox" name="gbOutput">
- <property name="title">
- <string>Output Options</string>
- </property>
- <layout class="QHBoxLayout" name="horizontalLayout_2">
- <item>
- <widget class="QLabel" name="lblPlotResult">
- <property name="text">
- <string>Plot Result: </string>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QComboBox" name="cbPlot">
- <property name="enabled">
- <bool>false</bool>
- </property>
- <item>
- <property name="text">
- <string>Amplitude</string>
+ <widget class="QFrame" name="frame">
+ <layout class="QVBoxLayout" name="verticalLayout_3">
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>0</number>
+ </property>
+ <item>
+ <widget class="QGroupBox" name="gbRun">
+ <property name="maximumSize">
+ <size>
+ <width>16777215</width>
+ <height>45</height>
+ </size>
+ </property>
+ <property name="title">
+ <string>Run</string>
+ </property>
+ <layout class="QHBoxLayout" name="horizontalLayout_4">
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>7</number>
+ </property>
+ <item>
+ <spacer name="horizontalSpacer_3">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
</property>
- </item>
- <item>
- <property name="text">
- <string>FWHM</string>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>385</width>
+ <height>20</height>
+ </size>
</property>
- </item>
- <item>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="pbRun">
<property name="text">
- <string>Fit</string>
+ <string>Run</string>
</property>
- </item>
- <item>
- <property name="text">
- <string>Prob</string>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_2">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
</property>
- </item>
- <item>
- <property name="text">
- <string>All</string>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>384</width>
+ <height>20</height>
+ </size>
</property>
- </item>
- </widget>
- </item>
- <item>
- <widget class="QPushButton" name="pbPlot">
- <property name="enabled">
- <bool>false</bool>
- </property>
- <property name="text">
- <string>Plot</string>
- </property>
- </widget>
- </item>
+ </spacer>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_44">
<item>
- <spacer name="horizontalSpacer_18">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="QPushButton" name="pbSave">
- <property name="enabled">
- <bool>false</bool>
- </property>
- <property name="text">
- <string>Save</string>
+ <widget class="QGroupBox" name="gbOutput">
+ <property name="title">
+ <string>Output Options</string>
</property>
+ <layout class="QHBoxLayout" name="horizontalLayout_2">
+ <item>
+ <widget class="QLabel" name="lblPlotResult">
+ <property name="text">
+ <string>Plot Result: </string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QComboBox" name="cbPlot">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>75</width>
+ <height>0</height>
+ </size>
+ </property>
+ <item>
+ <property name="text">
+ <string>Amplitude</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>FWHM</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Fit</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Prob</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>All</string>
+ </property>
+ </item>
+ </widget>
+ </item>
+ <item>
+ <widget class="QPushButton" name="pbPlot">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="text">
+ <string>Plot</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_18">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="pbSave">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="text">
+ <string>Save</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
</widget>
</item>
</layout>
- </widget>
- </item>
- </layout>
+ </item>
+ </layout>
+ </widget>
</item>
</layout>
</widget>
diff --git a/qt/scientific_interfaces/Indirect/ResNorm.cpp b/qt/scientific_interfaces/Indirect/ResNorm.cpp
index 1eed5eecbf6b1ca1ca7495637adffb7ed098eacc..3b26d2f5a2be3424ef6d569377e2ed30f3063aca 100644
--- a/qt/scientific_interfaces/Indirect/ResNorm.cpp
+++ b/qt/scientific_interfaces/Indirect/ResNorm.cpp
@@ -51,6 +51,7 @@ ResNorm::ResNorm(QWidget *parent) : IndirectBayesTab(parent), m_previewSpec(0) {
SLOT(handleAlgorithmComplete(bool)));
// Post Plot and Save
+ connect(m_uiForm.pbRun, SIGNAL(clicked()), this, SLOT(runClicked()));
connect(m_uiForm.pbSave, SIGNAL(clicked()), this, SLOT(saveClicked()));
connect(m_uiForm.pbPlot, SIGNAL(clicked()), this, SLOT(plotClicked()));
connect(m_uiForm.pbPlotCurrent, SIGNAL(clicked()), this,
@@ -153,16 +154,14 @@ void ResNorm::run() {
* @param error If the algorithm failed
*/
void ResNorm::handleAlgorithmComplete(bool error) {
- if (error)
- return;
-
- // Enable plot and save
- m_uiForm.cbPlot->setEnabled(true);
- m_uiForm.pbPlot->setEnabled(true);
- m_uiForm.pbSave->setEnabled(true);
-
- // Update preview plot
- previewSpecChanged(m_previewSpec);
+ setRunIsRunning(false);
+ if (!error)
+ // Update preview plot
+ previewSpecChanged(m_previewSpec);
+ else {
+ setPlotResultEnabled(false);
+ setSaveResultEnabled(false);
+ }
}
/**
@@ -337,10 +336,16 @@ void ResNorm::plotCurrentPreview() {
plotMultipleSpectra(plotWorkspaces, plotIndices);
}
+void ResNorm::runClicked() {
+ if (validateTab()) {
+ setRunIsRunning(true);
+ runTab();
+ }
+}
+
/**
* Handles saving when button is clicked
*/
-
void ResNorm::saveClicked() {
const auto resWsName(m_uiForm.dsResolution->getCurrentDataName());
@@ -358,8 +363,8 @@ void ResNorm::saveClicked() {
/**
* Handles plotting when button is clicked
*/
-
void ResNorm::plotClicked() {
+ setPlotResultIsPlotting(true);
WorkspaceGroup_sptr fitWorkspaces =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
m_pythonExportWsName + "_Fit_Workspaces");
@@ -377,6 +382,37 @@ void ResNorm::plotClicked() {
plotSpectrum(QString::fromStdString(m_pythonExportWsName) + "_Stretch");
if (plotOptions == "Fit" || plotOptions == "All")
plotSpectrum(fitWsName, 0, 1);
+
+ setPlotResultIsPlotting(false);
+}
+
+void ResNorm::setRunEnabled(bool enabled) {
+ m_uiForm.pbRun->setEnabled(enabled);
+}
+
+void ResNorm::setPlotResultEnabled(bool enabled) {
+ m_uiForm.pbPlot->setEnabled(enabled);
+ m_uiForm.cbPlot->setEnabled(enabled);
+}
+
+void ResNorm::setSaveResultEnabled(bool enabled) {
+ m_uiForm.pbSave->setEnabled(enabled);
+}
+
+void ResNorm::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+}
+
+void ResNorm::setRunIsRunning(bool running) {
+ m_uiForm.pbRun->setText(running ? "Running..." : "Run");
+ setButtonsEnabled(!running);
+}
+
+void ResNorm::setPlotResultIsPlotting(bool plotting) {
+ m_uiForm.pbPlot->setText(plotting ? "Plotting..." : "Plot");
+ setButtonsEnabled(!plotting);
}
} // namespace CustomInterfaces
diff --git a/qt/scientific_interfaces/Indirect/ResNorm.h b/qt/scientific_interfaces/Indirect/ResNorm.h
index ed7ebdecfd746d350dc28a99b1df00c52ad0656f..2def3ba0697f04e94fdec0108afa02388b6fecbe 100644
--- a/qt/scientific_interfaces/Indirect/ResNorm.h
+++ b/qt/scientific_interfaces/Indirect/ResNorm.h
@@ -41,11 +41,19 @@ private slots:
/// Slot to handle the preview spectrum being changed
void previewSpecChanged(int value);
/// Slots to handle plot and save
+ void runClicked();
void saveClicked();
void plotClicked();
void plotCurrentPreview();
private:
+ void setRunEnabled(bool enabled);
+ void setPlotResultEnabled(bool enabled);
+ void setSaveResultEnabled(bool enabled);
+ void setButtonsEnabled(bool enabled);
+ void setRunIsRunning(bool running);
+ void setPlotResultIsPlotting(bool plotting);
+
/// Current preview spectrum
int m_previewSpec;
/// The ui form
diff --git a/qt/scientific_interfaces/Indirect/ResNorm.ui b/qt/scientific_interfaces/Indirect/ResNorm.ui
index 177527f671bcc1310aea81ff411c4cb5e77d12c5..b7b1bbdc8af40a388cf8fcf05c1b445f0ff7ed72 100644
--- a/qt/scientific_interfaces/Indirect/ResNorm.ui
+++ b/qt/scientific_interfaces/Indirect/ResNorm.ui
@@ -154,79 +154,160 @@
</layout>
</item>
<item>
- <layout class="QHBoxLayout" name="horizontalLayout_44">
- <item>
- <widget class="QGroupBox" name="gbOutput">
- <property name="title">
- <string>Output Options</string>
- </property>
- <layout class="QHBoxLayout" name="horizontalLayout">
- <item>
- <widget class="QLabel" name="lblPlot">
- <property name="text">
- <string>Plot Result: </string>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QComboBox" name="cbPlot">
- <property name="enabled">
- <bool>false</bool>
- </property>
- <item>
- <property name="text">
- <string>Intensity</string>
+ <widget class="QFrame" name="frame">
+ <layout class="QVBoxLayout" name="verticalLayout_2">
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>0</number>
+ </property>
+ <item>
+ <widget class="QGroupBox" name="gbRun">
+ <property name="maximumSize">
+ <size>
+ <width>16777215</width>
+ <height>45</height>
+ </size>
+ </property>
+ <property name="title">
+ <string>Run</string>
+ </property>
+ <layout class="QHBoxLayout" name="horizontalLayout_2">
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>7</number>
+ </property>
+ <item>
+ <spacer name="horizontalSpacer">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
</property>
- </item>
- <item>
- <property name="text">
- <string>Stretch</string>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>385</width>
+ <height>20</height>
+ </size>
</property>
- </item>
- <item>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="pbRun">
<property name="text">
- <string>All</string>
+ <string>Run</string>
</property>
- </item>
- </widget>
- </item>
- <item>
- <widget class="QPushButton" name="pbPlot">
- <property name="enabled">
- <bool>false</bool>
- </property>
- <property name="text">
- <string>Plot</string>
- </property>
- </widget>
- </item>
- <item>
- <spacer name="horizontalSpacer_18">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_2">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>384</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_44">
<item>
- <widget class="QPushButton" name="pbSave">
- <property name="enabled">
- <bool>false</bool>
- </property>
- <property name="text">
- <string>Save</string>
+ <widget class="QGroupBox" name="gbOutput">
+ <property name="title">
+ <string>Output Options</string>
</property>
+ <layout class="QHBoxLayout" name="horizontalLayout">
+ <item>
+ <widget class="QLabel" name="lblPlot">
+ <property name="text">
+ <string>Plot Result: </string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QComboBox" name="cbPlot">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>75</width>
+ <height>0</height>
+ </size>
+ </property>
+ <item>
+ <property name="text">
+ <string>Intensity</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Stretch</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>All</string>
+ </property>
+ </item>
+ </widget>
+ </item>
+ <item>
+ <widget class="QPushButton" name="pbPlot">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="text">
+ <string>Plot</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_18">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="pbSave">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="text">
+ <string>Save</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
</widget>
</item>
</layout>
- </widget>
- </item>
- </layout>
+ </item>
+ </layout>
+ </widget>
</item>
</layout>
</widget>
diff --git a/qt/scientific_interfaces/Indirect/Stretch.cpp b/qt/scientific_interfaces/Indirect/Stretch.cpp
index 4dbea7b9948cf1d34b6a9f66b9e45291dd278cff..73b9aa9d1d70cd3582abd574c27714e994745c01 100644
--- a/qt/scientific_interfaces/Indirect/Stretch.cpp
+++ b/qt/scientific_interfaces/Indirect/Stretch.cpp
@@ -71,6 +71,7 @@ Stretch::Stretch(QWidget *parent)
m_uiForm.spPreviewSpectrum->setMaximum(0);
// Connect the plot and save push buttons
+ connect(m_uiForm.pbRun, SIGNAL(clicked()), this, SLOT(runClicked()));
connect(m_uiForm.pbPlot, SIGNAL(clicked()), this, SLOT(plotWorkspaces()));
connect(m_uiForm.pbSave, SIGNAL(clicked()), this, SLOT(saveWorkspaces()));
connect(m_uiForm.pbPlotPreview, SIGNAL(clicked()), this,
@@ -105,47 +106,30 @@ bool Stretch::validate() {
void Stretch::run() {
// Workspace input
- const auto sampleName = m_uiForm.dsSample->getCurrentDataName().toStdString();
- const auto resName =
+ auto const sampleName = m_uiForm.dsSample->getCurrentDataName().toStdString();
+ auto const resName =
m_uiForm.dsResolution->getCurrentDataName().toStdString();
- auto saveDirectory = Mantid::Kernel::ConfigService::Instance().getString(
- "defaultsave.directory");
- if (saveDirectory.compare("") == 0) {
- const char *textMessage =
- "BayesStretch requires a default save directory and "
- "one is not currently set."
- " If run, the algorithm will default to saving files "
- "to the current working directory."
- " Would you still like to run the algorithm?";
- int result = QMessageBox::question(nullptr, tr("Save Directory"),
- tr(textMessage), QMessageBox::Yes,
- QMessageBox::No, QMessageBox::NoButton);
- if (result == QMessageBox::No) {
- return;
- }
- }
-
// Obtain save and plot state
m_plotType = m_uiForm.cbPlot->currentText().toStdString();
// Collect input from options section
- const auto background = m_uiForm.cbBackground->currentText().toStdString();
+ auto const background = m_uiForm.cbBackground->currentText().toStdString();
// Collect input from the properties browser
- const auto eMin = m_properties["EMin"]->valueText().toDouble();
- const auto eMax = m_properties["EMax"]->valueText().toDouble();
- const auto beta = m_properties["Beta"]->valueText().toLong();
- const auto sigma = m_properties["Sigma"]->valueText().toLong();
- const auto nBins = m_properties["SampleBinning"]->valueText().toLong();
+ auto const eMin = m_properties["EMin"]->valueText().toDouble();
+ auto const eMax = m_properties["EMax"]->valueText().toDouble();
+ auto const beta = m_properties["Beta"]->valueText().toLong();
+ auto const sigma = m_properties["Sigma"]->valueText().toLong();
+ auto const nBins = m_properties["SampleBinning"]->valueText().toLong();
// Bool options
- const auto elasticPeak = m_uiForm.chkElasticPeak->isChecked();
- const auto sequence = m_uiForm.chkSequentialFit->isChecked();
+ auto const elasticPeak = m_uiForm.chkElasticPeak->isChecked();
+ auto const sequence = m_uiForm.chkSequentialFit->isChecked();
// Construct OutputNames
- auto cutIndex = sampleName.find_last_of("_");
- auto baseName = sampleName.substr(0, cutIndex);
+ auto const cutIndex = sampleName.find_last_of("_");
+ auto const baseName = sampleName.substr(0, cutIndex);
m_fitWorkspaceName = baseName + "_Stretch_Fit";
m_contourWorkspaceName = baseName + "_Stretch_Contour";
@@ -169,7 +153,6 @@ void Stretch::run() {
SLOT(algorithmComplete(bool)));
m_batchAlgoRunner->executeBatchAsync();
- m_uiForm.cbPlot->setEnabled(true);
m_plotType = m_uiForm.cbPlot->currentText().toStdString();
}
@@ -180,13 +163,11 @@ void Stretch::algorithmComplete(const bool &error) {
disconnect(m_batchAlgoRunner, SIGNAL(batchComplete(bool)), this,
SLOT(algorithmComplete(bool)));
- if (error)
- return;
-
- // Enables plot and save
- m_uiForm.cbPlot->setEnabled(true);
- m_uiForm.pbPlot->setEnabled(true);
- m_uiForm.pbSave->setEnabled(true);
+ setRunIsRunning(false);
+ if (error) {
+ setPlotResultEnabled(false);
+ setSaveResultEnabled(false);
+ }
}
/**
@@ -212,11 +193,45 @@ void Stretch::saveWorkspaces() {
m_batchAlgoRunner->executeBatchAsync();
}
+void Stretch::runClicked() {
+ if (validateTab()) {
+ auto const saveDirectory =
+ Mantid::Kernel::ConfigService::Instance().getString(
+ "defaultsave.directory");
+ displayMessageAndRun(saveDirectory);
+ }
+}
+
+void Stretch::displayMessageAndRun(std::string const &saveDirectory) {
+ if (saveDirectory.empty()) {
+ int const result = displaySaveDirectoryMessage();
+ if (result != QMessageBox::No) {
+ setRunIsRunning(true);
+ runTab();
+ }
+ } else {
+ setRunIsRunning(true);
+ runTab();
+ }
+}
+
+int Stretch::displaySaveDirectoryMessage() {
+ char const *textMessage =
+ "BayesQuasi requires a default save directory and "
+ "one is not currently set."
+ " If run, the algorithm will default to saving files "
+ "to the current working directory."
+ " Would you still like to run the algorithm?";
+ return QMessageBox::question(nullptr, tr("Save Directory"), tr(textMessage),
+ QMessageBox::Yes, QMessageBox::No,
+ QMessageBox::NoButton);
+}
+
/**
* Handles the plotting of workspace post algorithm completion
*/
void Stretch::plotWorkspaces() {
-
+ setPlotResultIsPlotting(true);
WorkspaceGroup_sptr fitWorkspace;
fitWorkspace = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
m_fitWorkspaceName);
@@ -246,6 +261,7 @@ void Stretch::plotWorkspaces() {
g_log.error(
"Beta and Sigma workspace were not found and could not be plotted.");
}
+ setPlotResultIsPlotting(false);
}
/**
@@ -349,5 +365,34 @@ void Stretch::updateProperties(QtProperty *prop, double val) {
}
}
+void Stretch::setRunEnabled(bool enabled) {
+ m_uiForm.pbRun->setEnabled(enabled);
+}
+
+void Stretch::setPlotResultEnabled(bool enabled) {
+ m_uiForm.pbPlot->setEnabled(enabled);
+ m_uiForm.cbPlot->setEnabled(enabled);
+}
+
+void Stretch::setSaveResultEnabled(bool enabled) {
+ m_uiForm.pbSave->setEnabled(enabled);
+}
+
+void Stretch::setButtonsEnabled(bool enabled) {
+ setRunEnabled(enabled);
+ setPlotResultEnabled(enabled);
+ setSaveResultEnabled(enabled);
+}
+
+void Stretch::setRunIsRunning(bool running) {
+ m_uiForm.pbRun->setText(running ? "Running..." : "Run");
+ setButtonsEnabled(!running);
+}
+
+void Stretch::setPlotResultIsPlotting(bool plotting) {
+ m_uiForm.pbPlot->setText(plotting ? "Plotting..." : "Plot");
+ setButtonsEnabled(!plotting);
+}
+
} // namespace CustomInterfaces
} // namespace MantidQt
diff --git a/qt/scientific_interfaces/Indirect/Stretch.h b/qt/scientific_interfaces/Indirect/Stretch.h
index 81d61e78c412aa85262bec726b6f2e810b33d9bb..99d6a2746b6d88e14e6e649bbd07af5747266a37 100644
--- a/qt/scientific_interfaces/Indirect/Stretch.h
+++ b/qt/scientific_interfaces/Indirect/Stretch.h
@@ -37,13 +37,24 @@ private slots:
void handleSampleInputReady(const QString &filename);
/// Save the workspaces produces from the algorithm
void saveWorkspaces();
- /// Plot the workspaces specified by the interface
+
+ void runClicked();
void plotWorkspaces();
void algorithmComplete(const bool &error);
void plotCurrentPreview();
void previewSpecChanged(int value);
private:
+ void displayMessageAndRun(std::string const &saveDirectory);
+ int displaySaveDirectoryMessage();
+
+ void setRunEnabled(bool enabled);
+ void setPlotResultEnabled(bool enabled);
+ void setSaveResultEnabled(bool enabled);
+ void setButtonsEnabled(bool enabled);
+ void setRunIsRunning(bool running);
+ void setPlotResultIsPlotting(bool plotting);
+
/// Current preview spectrum
int m_previewSpec;
// The ui form
diff --git a/qt/scientific_interfaces/Indirect/Stretch.ui b/qt/scientific_interfaces/Indirect/Stretch.ui
index 4f406ffc16f03973689fbe909e4d8b8acb127ab3..79420a4ca60214dfceb9722c3576a9909e647c29 100644
--- a/qt/scientific_interfaces/Indirect/Stretch.ui
+++ b/qt/scientific_interfaces/Indirect/Stretch.ui
@@ -223,79 +223,160 @@
</layout>
</item>
<item>
- <layout class="QHBoxLayout" name="horizontalLayout_44">
- <item>
- <widget class="QGroupBox" name="gbOutput">
- <property name="title">
- <string>Output Options</string>
- </property>
- <layout class="QHBoxLayout" name="horizontalLayout">
- <item>
- <widget class="QLabel" name="lblPlotResult">
- <property name="text">
- <string>Plot Result: </string>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QComboBox" name="cbPlot">
- <property name="enabled">
- <bool>false</bool>
- </property>
- <item>
- <property name="text">
- <string>Sigma</string>
+ <widget class="QFrame" name="frame">
+ <layout class="QVBoxLayout" name="verticalLayout_3">
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>0</number>
+ </property>
+ <item>
+ <widget class="QGroupBox" name="gbRun">
+ <property name="maximumSize">
+ <size>
+ <width>16777215</width>
+ <height>45</height>
+ </size>
+ </property>
+ <property name="title">
+ <string>Run</string>
+ </property>
+ <layout class="QHBoxLayout" name="horizontalLayout_3">
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>7</number>
+ </property>
+ <item>
+ <spacer name="horizontalSpacer_3">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
</property>
- </item>
- <item>
- <property name="text">
- <string>Beta</string>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>385</width>
+ <height>20</height>
+ </size>
</property>
- </item>
- <item>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="pbRun">
<property name="text">
- <string>All</string>
+ <string>Run</string>
</property>
- </item>
- </widget>
- </item>
- <item>
- <widget class="QPushButton" name="pbPlot">
- <property name="enabled">
- <bool>false</bool>
- </property>
- <property name="text">
- <string>Plot</string>
- </property>
- </widget>
- </item>
- <item>
- <spacer name="horizontalSpacer_18">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_4">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>384</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_44">
<item>
- <widget class="QPushButton" name="pbSave">
- <property name="enabled">
- <bool>false</bool>
- </property>
- <property name="text">
- <string>Save Result</string>
+ <widget class="QGroupBox" name="gbOutput">
+ <property name="title">
+ <string>Output Options</string>
</property>
+ <layout class="QHBoxLayout" name="horizontalLayout">
+ <item>
+ <widget class="QLabel" name="lblPlotResult">
+ <property name="text">
+ <string>Plot Result: </string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QComboBox" name="cbPlot">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>75</width>
+ <height>0</height>
+ </size>
+ </property>
+ <item>
+ <property name="text">
+ <string>Sigma</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>Beta</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>All</string>
+ </property>
+ </item>
+ </widget>
+ </item>
+ <item>
+ <widget class="QPushButton" name="pbPlot">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="text">
+ <string>Plot</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_18">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="pbSave">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="text">
+ <string>Save Result</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
</widget>
</item>
</layout>
- </widget>
- </item>
- </layout>
+ </item>
+ </layout>
+ </widget>
</item>
</layout>
</widget>
diff --git a/qt/scientific_interfaces/Indirect/test/CMakeLists.txt b/qt/scientific_interfaces/Indirect/test/CMakeLists.txt
index c360d1400efc6d94b02d31897d8553e6a2579568..d90a6e4b033257ac23cb73607d4d39fa291930f8 100644
--- a/qt/scientific_interfaces/Indirect/test/CMakeLists.txt
+++ b/qt/scientific_interfaces/Indirect/test/CMakeLists.txt
@@ -2,8 +2,10 @@
# Testing
###########################################################################
set ( TEST_FILES
- IndirectFittingModelTest.h
IndirectFitDataTest.h
+ IndirectFitOutputTest.h
+ IndirectFitPlotModelTest.h
+ IndirectFittingModelTest.h
)
mtd_add_qt_tests (TARGET_NAME MantidQtInterfacesIndirectTest
@@ -16,6 +18,7 @@ mtd_add_qt_tests (TARGET_NAME MantidQtInterfacesIndirectTest
../
TEST_HELPER_SRCS
../../../../Framework/TestHelpers/src/ComponentCreationHelper.cpp
+ ../../../../Framework/TestHelpers/src/IndirectFitDataCreationHelper.cpp
../../../../Framework/TestHelpers/src/InstrumentCreationHelper.cpp
../../../../Framework/TestHelpers/src/WorkspaceCreationHelper.cpp
../../../../Framework/TestHelpers/src/TearDownWorld.cpp
diff --git a/qt/scientific_interfaces/Indirect/test/IndirectFitDataTest.h b/qt/scientific_interfaces/Indirect/test/IndirectFitDataTest.h
index 4d4a5f5a5f6641b3632a2e65f9dbbd34794be91c..68348bf503539085fc25761c28d5be53126abcb8 100644
--- a/qt/scientific_interfaces/Indirect/test/IndirectFitDataTest.h
+++ b/qt/scientific_interfaces/Indirect/test/IndirectFitDataTest.h
@@ -6,6 +6,7 @@
#include "IndirectFitData.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
+#include "MantidTestHelpers/IndirectFitDataCreationHelper.h"
#include "MantidTestHelpers/WorkspaceCreationHelper.h"
#include <iostream>
@@ -13,42 +14,18 @@
using namespace Mantid::API;
using namespace Mantid::DataObjects;
using namespace MantidQt::CustomInterfaces::IDA;
+using namespace Mantid::IndirectFitDataCreationHelper;
namespace {
-IndirectFitData getIndirectFitData(std::size_t const &numberOfSpectra,
- std::size_t const &numberOfBins) {
- auto const workspace = WorkspaceCreationHelper::create2DWorkspace123(
- numberOfSpectra, numberOfBins);
+std::unique_ptr<IndirectFitData>
+getIndirectFitData(int const &numberOfSpectra) {
+ auto const workspace = createWorkspace(numberOfSpectra);
Spectra const spec = std::make_pair(0u, workspace->getNumberHistograms() - 1);
IndirectFitData data(workspace, spec);
- return data;
+ return std::make_unique<IndirectFitData>(data);
}
-/// Simple class to set up the ADS with the configuration required
-struct SetUpADSWithWorkspace {
-
- SetUpADSWithWorkspace(std::string const &inputWSName,
- IndirectFitData const &data) {
- AnalysisDataService::Instance().addOrReplace(inputWSName, data.workspace());
- };
-
- ~SetUpADSWithWorkspace() { AnalysisDataService::Instance().clear(); };
-};
-
-/// This is used to compare Spectra which is implemented as a boost::variant
-struct AreSpectraEqual : public boost::static_visitor<bool> {
-
- template <typename T, typename U>
- bool operator()(const T &, const U &) const {
- return false; // cannot compare different types
- }
-
- template <typename T> bool operator()(const T &lhs, const T &rhs) const {
- return lhs == rhs;
- }
-};
-
} // namespace
class IndirectFitDataTest : public CxxTest::TestSuite {
@@ -59,8 +36,10 @@ public:
static void destroySuite(IndirectFitDataTest *suite) { delete suite; }
+ void tearDown() override { AnalysisDataService::Instance().clear(); }
+
void test_data_is_instantiated() {
- auto const workspace = WorkspaceCreationHelper::create2DWorkspace123(1, 3);
+ auto const workspace = createWorkspace(1);
Spectra const spec =
std::make_pair(0u, workspace->getNumberHistograms() - 1);
@@ -86,87 +65,88 @@ public:
void
test_that_DiscontinuousSpectra_is_sorted_before_being_stored_when_the_input_string_contains_overlapping_spectra() {
- auto data = getIndirectFitData(11, 3);
+ auto data = getIndirectFitData(11);
std::string const inputString = "8,0-7,6,10";
Spectra const spectra = DiscontinuousSpectra<std::size_t>("0-8,10");
- data.setSpectra(inputString);
+ data->setSpectra(inputString);
- TS_ASSERT(boost::apply_visitor(AreSpectraEqual(), data.spectra(), spectra));
+ TS_ASSERT(
+ boost::apply_visitor(AreSpectraEqual(), data->spectra(), spectra));
}
void
test_that_DiscontinuousSpectra_is_sorted_before_being_stored_when_the_input_string_contains_an_invalid_spectra_range() {
- auto data = getIndirectFitData(11, 3);
+ auto data = getIndirectFitData(11);
std::string const inputString = "1,2,4-3,10";
Spectra const spectra = DiscontinuousSpectra<std::size_t>("1-4,10");
- data.setSpectra(inputString);
+ data->setSpectra(inputString);
- TS_ASSERT(boost::apply_visitor(AreSpectraEqual(), data.spectra(), spectra));
+ TS_ASSERT(
+ boost::apply_visitor(AreSpectraEqual(), data->spectra(), spectra));
}
void
test_that_DiscontinuousSpectra_is_sorted_before_being_stored_when_the_input_string_contains_large_spaces() {
- auto data = getIndirectFitData(11, 3);
+ auto data = getIndirectFitData(11);
std::string const inputString = " 8,10, 7";
Spectra const spectra = DiscontinuousSpectra<std::size_t>("7-8,10");
- data.setSpectra(inputString);
+ data->setSpectra(inputString);
- TS_ASSERT(boost::apply_visitor(AreSpectraEqual(), data.spectra(), spectra));
+ TS_ASSERT(
+ boost::apply_visitor(AreSpectraEqual(), data->spectra(), spectra));
}
void test_data_is_stored_in_the_ADS() {
- auto const data = getIndirectFitData(1, 3);
- SetUpADSWithWorkspace ads("WorkspaceName", data);
+ auto const data = getIndirectFitData(1);
+ SetUpADSWithWorkspace ads("WorkspaceName", data->workspace());
- TS_ASSERT(AnalysisDataService::Instance().doesExist("WorkspaceName"));
- MatrixWorkspace_sptr workspace =
- boost::dynamic_pointer_cast<MatrixWorkspace>(
- AnalysisDataService::Instance().retrieve("WorkspaceName"));
+ TS_ASSERT(ads.doesExist("WorkspaceName"));
+ auto workspace = ads.retrieveWorkspace("WorkspaceName");
TS_ASSERT_EQUALS(workspace->getNumberHistograms(), 1);
}
void
test_displayName_returns_a_valid_name_when_provided_a_rangeDelimiter_and_spectrum_number() {
- auto const data = getIndirectFitData(1, 3);
+ auto const data = getIndirectFitData(1);
std::vector<std::string> const formatStrings{
"%1%_s%2%_Result", "%1%_f%2%,s%2%_Parameter", "%1%_s%2%_Parameter"};
std::string const rangeDelimiter = "_to_";
std::size_t const spectrum = 1;
- TS_ASSERT_EQUALS(data.displayName(formatStrings[0], rangeDelimiter),
+ TS_ASSERT_EQUALS(data->displayName(formatStrings[0], rangeDelimiter),
"_s0_Result");
- TS_ASSERT_EQUALS(data.displayName(formatStrings[1], rangeDelimiter),
+ TS_ASSERT_EQUALS(data->displayName(formatStrings[1], rangeDelimiter),
"_f0+s0_Parameter");
- TS_ASSERT_EQUALS(data.displayName(formatStrings[2], spectrum),
+ TS_ASSERT_EQUALS(data->displayName(formatStrings[2], spectrum),
"_s1_Parameter");
}
void test_displayName_removes_red_part_of_a_workspace_name() {
- auto const data = getIndirectFitData(1, 3);
+ auto const data = getIndirectFitData(1);
- SetUpADSWithWorkspace ads("Workspace_3456_red", data);
+ SetUpADSWithWorkspace ads("Workspace_3456_red", data->workspace());
std::string const formatString = "%1%_s%2%_Result";
std::string const rangeDelimiter = "_to_";
- TS_ASSERT_EQUALS(data.displayName(formatString, rangeDelimiter),
+ TS_ASSERT_EQUALS(data->displayName(formatString, rangeDelimiter),
"Workspace_3456_s0_Result");
}
void
test_that_the_number_of_spectra_returned_matches_the_instantiated_value() {
- auto const data = getIndirectFitData(10, 3);
- TS_ASSERT_EQUALS(data.numberOfSpectra(), 10);
+ auto const data = getIndirectFitData(10);
+ TS_ASSERT_EQUALS(data->numberOfSpectra(), 10);
}
void test_that_getSpectrum_returns_the_expected_spectrum_numbers() {
- auto const data = getIndirectFitData(4, 3);
+ auto const data = getIndirectFitData(4);
- for (auto i = 0u; i < data.numberOfSpectra(); ++i) {
- std::size_t const spectrumNum = data.getSpectrum(i);
+ for (auto i = 0u; i < data->numberOfSpectra(); ++i) {
+ std::size_t const spectrumNum = data->getSpectrum(i);
TS_ASSERT_EQUALS(spectrumNum, i);
}
}
@@ -182,7 +162,7 @@ public:
void
test_that_true_is_returned_from_zeroSpectra_if_data_contains_empty_spectra() {
- auto const workspace = WorkspaceCreationHelper::create2DWorkspace123(1, 3);
+ auto const workspace = createWorkspace(1);
DiscontinuousSpectra<std::size_t> const spec("");
IndirectFitData const data(workspace, spec);
@@ -192,8 +172,8 @@ public:
void
test_that_false_is_returned_from_zeroSpectra_if_data_contains_one_or_more_spectra() {
for (auto i = 1u; i < 10; ++i) {
- auto const data = getIndirectFitData(i, 3);
- TS_ASSERT_EQUALS(data.zeroSpectra(), false);
+ auto const data = getIndirectFitData(i);
+ TS_ASSERT_EQUALS(data->zeroSpectra(), false);
}
}
@@ -201,80 +181,80 @@ public:
test_that_correct_excludeRegion_is_returned_when_regions_are_in_correct_order() {
/// When each pair of numbers in the string are in order, then the whole
/// string is in the correct order(unordered: 10,11 9,7 ordered:10,11,7,9)
- auto data = getIndirectFitData(4, 3);
+ auto data = getIndirectFitData(4);
- data.setExcludeRegionString("1,8", 0);
- data.setExcludeRegionString("2,5", 1);
- data.setExcludeRegionString("1,2,5,6,3,4", 2);
+ data->setExcludeRegionString("1,8", 0);
+ data->setExcludeRegionString("2,5", 1);
+ data->setExcludeRegionString("1,2,5,6,3,4", 2);
- TS_ASSERT_EQUALS(data.getExcludeRegion(0), "1.0,8.0");
- TS_ASSERT_EQUALS(data.getExcludeRegion(1), "2.0,5.0");
- TS_ASSERT_EQUALS(data.getExcludeRegion(2), "1.0,2.0,5.0,6.0,3.0,4.0");
- TS_ASSERT_EQUALS(data.getExcludeRegion(3), "");
+ TS_ASSERT_EQUALS(data->getExcludeRegion(0), "1.0,8.0");
+ TS_ASSERT_EQUALS(data->getExcludeRegion(1), "2.0,5.0");
+ TS_ASSERT_EQUALS(data->getExcludeRegion(2), "1.0,2.0,5.0,6.0,3.0,4.0");
+ TS_ASSERT_EQUALS(data->getExcludeRegion(3), "");
}
void
test_that_correct_excludeRegionVector_is_returned_when_regions_are_in_correct_order() {
/// When each pair of numbers in the string are in order, then the whole
/// string is in the correct order(unordered: 10,11 9,7 ordered:10,11,7,9)
- auto data = getIndirectFitData(4, 3);
+ auto data = getIndirectFitData(4);
- data.setExcludeRegionString("1,8", 0);
- data.setExcludeRegionString("2,5", 1);
+ data->setExcludeRegionString("1,8", 0);
+ data->setExcludeRegionString("2,5", 1);
std::vector<double> const regionVector1{1.0, 8.0};
std::vector<double> const regionVector2{2.0, 5.0};
- TS_ASSERT_EQUALS(data.excludeRegionsVector(0), regionVector1);
- TS_ASSERT_EQUALS(data.excludeRegionsVector(1), regionVector2);
- TS_ASSERT_EQUALS(data.excludeRegionsVector(3).empty(), true);
+ TS_ASSERT_EQUALS(data->excludeRegionsVector(0), regionVector1);
+ TS_ASSERT_EQUALS(data->excludeRegionsVector(1), regionVector2);
+ TS_ASSERT_EQUALS(data->excludeRegionsVector(3).empty(), true);
}
void test_that_excludeRegion_pairs_are_stored_in_an_order_of_low_to_high() {
/// Example: unordered: 10,11 9,7 ordered: 10,11,7,9
- auto data = getIndirectFitData(3, 3);
+ auto data = getIndirectFitData(3);
- data.setExcludeRegionString("6,2", 0);
- data.setExcludeRegionString("6,2,1,2,3,4,7,6", 1);
- data.setExcludeRegionString("1,2,2,3,20,18,21,22,7,8", 2);
+ data->setExcludeRegionString("6,2", 0);
+ data->setExcludeRegionString("6,2,1,2,3,4,7,6", 1);
+ data->setExcludeRegionString("1,2,2,3,20,18,21,22,7,8", 2);
std::vector<double> const regionVector{2.0, 6.0};
- TS_ASSERT_EQUALS(data.getExcludeRegion(0), "2.0,6.0");
- TS_ASSERT_EQUALS(data.getExcludeRegion(1),
+ TS_ASSERT_EQUALS(data->getExcludeRegion(0), "2.0,6.0");
+ TS_ASSERT_EQUALS(data->getExcludeRegion(1),
"2.0,6.0,1.0,2.0,3.0,4.0,6.0,7.0");
- TS_ASSERT_EQUALS(data.getExcludeRegion(2),
+ TS_ASSERT_EQUALS(data->getExcludeRegion(2),
"1.0,2.0,2.0,3.0,18.0,20.0,21.0,22.0,7.0,8.0");
- TS_ASSERT_EQUALS(data.excludeRegionsVector(0), regionVector);
+ TS_ASSERT_EQUALS(data->excludeRegionsVector(0), regionVector);
}
void
test_that_excludeRegion_is_stored_without_spaces_when_there_are_many_spaces_in_input_string() {
- auto data = getIndirectFitData(3, 3);
+ auto data = getIndirectFitData(3);
- data.setExcludeRegionString(" 6, 2", 0);
- data.setExcludeRegionString("6, 2,1 ,2, 3,4 ,7,6", 1);
- data.setExcludeRegionString("1,2 ,2,3, 20, 18,21,22,7, 8 ", 2);
+ data->setExcludeRegionString(" 6, 2", 0);
+ data->setExcludeRegionString("6, 2,1 ,2, 3,4 ,7,6", 1);
+ data->setExcludeRegionString("1,2 ,2,3, 20, 18,21,22,7, 8 ", 2);
- TS_ASSERT_EQUALS(data.getExcludeRegion(0), "2.0,6.0");
- TS_ASSERT_EQUALS(data.getExcludeRegion(1),
+ TS_ASSERT_EQUALS(data->getExcludeRegion(0), "2.0,6.0");
+ TS_ASSERT_EQUALS(data->getExcludeRegion(1),
"2.0,6.0,1.0,2.0,3.0,4.0,6.0,7.0");
- TS_ASSERT_EQUALS(data.getExcludeRegion(2),
+ TS_ASSERT_EQUALS(data->getExcludeRegion(2),
"1.0,2.0,2.0,3.0,18.0,20.0,21.0,22.0,7.0,8.0");
}
void
test_that_setExcludeRegion_rounds_the_numbers_in_the_input_string_to_the_appropriate_decimal_place() {
- auto data = getIndirectFitData(2, 3);
+ auto data = getIndirectFitData(2);
- data.setExcludeRegionString("6.29,2.93", 0);
- data.setExcludeRegionString("2.6,2.3,1.99,3.01", 1);
+ data->setExcludeRegionString("6.29,2.93", 0);
+ data->setExcludeRegionString("2.6,2.3,1.99,3.01", 1);
- TS_ASSERT_EQUALS(data.getExcludeRegion(0), "2.9,6.3");
- TS_ASSERT_EQUALS(data.getExcludeRegion(1), "2.3,2.6,2.0,3.0");
+ TS_ASSERT_EQUALS(data->getExcludeRegion(0), "2.9,6.3");
+ TS_ASSERT_EQUALS(data->getExcludeRegion(1), "2.3,2.6,2.0,3.0");
}
void test_throws_when_setSpectra_is_provided_an_out_of_range_spectra() {
- auto data = getIndirectFitData(10, 3);
+ auto data = getIndirectFitData(10);
std::vector<Spectra> const spectraPairs{
std::make_pair(0u, 11u), std::make_pair(0u, 1000000000000000000u),
@@ -283,13 +263,13 @@ public:
"10", "100000000000000000000000000000", "1,5,10", "1,2,3,4,5,6,22"};
for (auto i = 0u; i < spectraPairs.size(); ++i)
- TS_ASSERT_THROWS(data.setSpectra(spectraPairs[i]), std::runtime_error);
+ TS_ASSERT_THROWS(data->setSpectra(spectraPairs[i]), std::runtime_error);
for (auto i = 0u; i < spectraStrings.size(); ++i)
- TS_ASSERT_THROWS(data.setSpectra(spectraStrings[i]), std::runtime_error);
+ TS_ASSERT_THROWS(data->setSpectra(spectraStrings[i]), std::runtime_error);
}
void test_no_throw_when_setSpectra_is_provided_a_valid_spectra() {
- auto data = getIndirectFitData(10, 3);
+ auto data = getIndirectFitData(10);
std::vector<Spectra> const spectraPairs{
std::make_pair(0u, 9u), std::make_pair(4u, 4u), std::make_pair(7u, 4u)};
@@ -297,61 +277,61 @@ public:
"1,2,3,4,5,6"};
for (auto i = 0u; i < spectraPairs.size(); ++i)
- TS_ASSERT_THROWS_NOTHING(data.setSpectra(spectraPairs[i]));
+ TS_ASSERT_THROWS_NOTHING(data->setSpectra(spectraPairs[i]));
for (auto i = 0u; i < spectraStrings.size(); ++i)
- TS_ASSERT_THROWS_NOTHING(data.setSpectra(spectraStrings[i]));
+ TS_ASSERT_THROWS_NOTHING(data->setSpectra(spectraStrings[i]));
}
void
test_no_throw_when_setStartX_is_provided_a_valid_xValue_and_spectrum_number() {
- auto data = getIndirectFitData(10, 3);
+ auto data = getIndirectFitData(10);
- TS_ASSERT_THROWS_NOTHING(data.setStartX(0.0, 0));
- TS_ASSERT_THROWS_NOTHING(data.setStartX(-5.0, 0));
- TS_ASSERT_THROWS_NOTHING(data.setStartX(5000000, 10));
+ TS_ASSERT_THROWS_NOTHING(data->setStartX(0.0, 0));
+ TS_ASSERT_THROWS_NOTHING(data->setStartX(-5.0, 0));
+ TS_ASSERT_THROWS_NOTHING(data->setStartX(5000000, 10));
}
void test_the_provided_startX_is_stored_in_range_after_using_setStartX() {
- auto data = getIndirectFitData(3, 3);
+ auto data = getIndirectFitData(3);
- data.setStartX(-5.0, 0);
- data.setStartX(6.53, 1);
- data.setStartX(100000000000000.0, 2);
+ data->setStartX(-5.0, 0);
+ data->setStartX(6.53, 1);
+ data->setStartX(100000000000000.0, 2);
- TS_ASSERT_EQUALS(data.getRange(0).first, -5.0);
- TS_ASSERT_EQUALS(data.getRange(1).first, 6.53);
- TS_ASSERT_EQUALS(data.getRange(2).first, 100000000000000.0);
+ TS_ASSERT_EQUALS(data->getRange(0).first, -5.0);
+ TS_ASSERT_EQUALS(data->getRange(1).first, 6.53);
+ TS_ASSERT_EQUALS(data->getRange(2).first, 100000000000000.0);
}
void
test_no_throw_when_setEndX_is_provided_a_valid_xValue_and_spectrum_number() {
- auto data = getIndirectFitData(10, 3);
+ auto data = getIndirectFitData(10);
- TS_ASSERT_THROWS_NOTHING(data.setStartX(0.0, 0));
- TS_ASSERT_THROWS_NOTHING(data.setStartX(-5.0, 0));
- TS_ASSERT_THROWS_NOTHING(data.setStartX(5000000, 10));
+ TS_ASSERT_THROWS_NOTHING(data->setStartX(0.0, 0));
+ TS_ASSERT_THROWS_NOTHING(data->setStartX(-5.0, 0));
+ TS_ASSERT_THROWS_NOTHING(data->setStartX(5000000, 10));
}
void test_the_provided_endX_is_stored_in_range_after_using_setEndX() {
- auto data = getIndirectFitData(3, 3);
+ auto data = getIndirectFitData(3);
- data.setEndX(-5.0, 0);
- data.setEndX(6.53, 1);
- data.setEndX(100000000000000.0, 2);
+ data->setEndX(-5.0, 0);
+ data->setEndX(6.53, 1);
+ data->setEndX(100000000000000.0, 2);
- TS_ASSERT_EQUALS(data.getRange(0).second, -5.0);
- TS_ASSERT_EQUALS(data.getRange(1).second, 6.53);
- TS_ASSERT_EQUALS(data.getRange(2).second, 100000000000000.0);
+ TS_ASSERT_EQUALS(data->getRange(0).second, -5.0);
+ TS_ASSERT_EQUALS(data->getRange(1).second, 6.53);
+ TS_ASSERT_EQUALS(data->getRange(2).second, 100000000000000.0);
}
void
test_that_the_startX_of_two_data_sets_are_combined_when_relating_to_two_seperate_spectra() {
- auto data1 = getIndirectFitData(2, 3);
- auto data2 = getIndirectFitData(2, 3);
+ auto data1 = getIndirectFitData(2);
+ auto data2 = getIndirectFitData(2);
- data1.setStartX(6.53, 0);
- data2.setStartX(5.0, 1);
- auto const combinedData = data2.combine(data1);
+ data1->setStartX(6.53, 0);
+ data2->setStartX(5.0, 1);
+ auto const combinedData = data2->combine(*data1);
TS_ASSERT_EQUALS(combinedData.getRange(0).first, 6.53);
TS_ASSERT_EQUALS(combinedData.getRange(1).first, 5.0);
@@ -359,12 +339,12 @@ public:
void
test_that_the_endX_of_two_datasets_are_combined_when_relating_to_two_seperate_spectra() {
- auto data1 = getIndirectFitData(2, 3);
- auto data2 = getIndirectFitData(2, 3);
+ auto data1 = getIndirectFitData(2);
+ auto data2 = getIndirectFitData(2);
- data1.setEndX(2.34, 0);
- data2.setEndX(5.9, 1);
- auto const combinedData = data2.combine(data1);
+ data1->setEndX(2.34, 0);
+ data2->setEndX(5.9, 1);
+ auto const combinedData = data2->combine(*data1);
TS_ASSERT_EQUALS(combinedData.getRange(0).second, 2.34);
TS_ASSERT_EQUALS(combinedData.getRange(1).second, 5.9);
@@ -372,12 +352,12 @@ public:
void
test_that_the_excludeRegion_of_two_datasets_are_combined_when_relating_to_two_seperate_spectra() {
- auto data1 = getIndirectFitData(2, 3);
- auto data2 = getIndirectFitData(2, 3);
+ auto data1 = getIndirectFitData(2);
+ auto data2 = getIndirectFitData(2);
- data1.setExcludeRegionString("1,2,6,5", 0);
- data1.setExcludeRegionString("6,2", 1);
- auto const combinedData = data2.combine(data1);
+ data1->setExcludeRegionString("1,2,6,5", 0);
+ data1->setExcludeRegionString("6,2", 1);
+ auto const combinedData = data2->combine(*data1);
TS_ASSERT_EQUALS(combinedData.getExcludeRegion(0), "1.0,2.0,5.0,6.0");
TS_ASSERT_EQUALS(combinedData.getExcludeRegion(1), "2.0,6.0");
@@ -385,12 +365,12 @@ public:
void
test_that_the_spectra_pair_of_two_datasets_are_combined_correctly_when_spectra_do_not_overlap() {
- auto data1 = getIndirectFitData(10, 3);
- auto data2 = getIndirectFitData(10, 3);
+ auto data1 = getIndirectFitData(10);
+ auto data2 = getIndirectFitData(10);
- data1.setSpectra(std::make_pair(0u, 4u));
- data2.setSpectra(std::make_pair(5u, 9u));
- auto const combinedData = data2.combine(data1);
+ data1->setSpectra(std::make_pair(0u, 4u));
+ data2->setSpectra(std::make_pair(5u, 9u));
+ auto const combinedData = data2->combine(*data1);
Spectra const spec(std::make_pair(0u, 9u));
TS_ASSERT(
@@ -399,12 +379,12 @@ public:
void
test_that_the_spectra_pair_of_two_datasets_are_combined_correctly_when_spectra_are_discontinuous() {
- auto data1 = getIndirectFitData(10, 3);
- auto data2 = getIndirectFitData(10, 3);
+ auto data1 = getIndirectFitData(10);
+ auto data2 = getIndirectFitData(10);
- data1.setSpectra(std::make_pair(0u, 4u));
- data2.setSpectra(std::make_pair(8u, 9u));
- auto const combinedData = data2.combine(data1);
+ data1->setSpectra(std::make_pair(0u, 4u));
+ data2->setSpectra(std::make_pair(8u, 9u));
+ auto const combinedData = data2->combine(*data1);
Spectra const spec(DiscontinuousSpectra<std::size_t>("0-4,8-9"));
TS_ASSERT(
@@ -413,12 +393,12 @@ public:
void
test_that_the_spectra_pair_of_two_datasets_are_combined_correctly_when_spectra_overlap() {
- auto data1 = getIndirectFitData(10, 3);
- auto data2 = getIndirectFitData(10, 3);
+ auto data1 = getIndirectFitData(10);
+ auto data2 = getIndirectFitData(10);
- data1.setSpectra(std::make_pair(0u, 8u));
- data2.setSpectra(std::make_pair(4u, 9u));
- auto const combinedData = data2.combine(data1);
+ data1->setSpectra(std::make_pair(0u, 8u));
+ data2->setSpectra(std::make_pair(4u, 9u));
+ auto const combinedData = data2->combine(*data1);
Spectra const spec(DiscontinuousSpectra<std::size_t>("0-9"));
TS_ASSERT(
@@ -427,12 +407,12 @@ public:
void
test_that_the_DiscontinuousSpectra_of_two_datasets_are_combined_correctly_when_spectra_do_not_overlap() {
- auto data1 = getIndirectFitData(10, 3);
- auto data2 = getIndirectFitData(10, 3);
+ auto data1 = getIndirectFitData(10);
+ auto data2 = getIndirectFitData(10);
- data1.setSpectra(DiscontinuousSpectra<std::size_t>("0-4"));
- data2.setSpectra(DiscontinuousSpectra<std::size_t>("5-9"));
- auto const combinedData = data2.combine(data1);
+ data1->setSpectra(DiscontinuousSpectra<std::size_t>("0-4"));
+ data2->setSpectra(DiscontinuousSpectra<std::size_t>("5-9"));
+ auto const combinedData = data2->combine(*data1);
Spectra const spec(DiscontinuousSpectra<std::size_t>("0-9"));
TS_ASSERT(
@@ -441,12 +421,12 @@ public:
void
test_that_the_DiscontinuousSpectra_of_two_datasets_are_combined_correctly_when_spectra_overlap() {
- auto data1 = getIndirectFitData(10, 3);
- auto data2 = getIndirectFitData(10, 3);
+ auto data1 = getIndirectFitData(10);
+ auto data2 = getIndirectFitData(10);
- data1.setSpectra(DiscontinuousSpectra<std::size_t>("0-7"));
- data2.setSpectra(DiscontinuousSpectra<std::size_t>("2-9"));
- auto const combinedData = data2.combine(data1);
+ data1->setSpectra(DiscontinuousSpectra<std::size_t>("0-7"));
+ data2->setSpectra(DiscontinuousSpectra<std::size_t>("2-9"));
+ auto const combinedData = data2->combine(*data1);
Spectra const spec(DiscontinuousSpectra<std::size_t>("0-9"));
TS_ASSERT(
@@ -455,12 +435,12 @@ public:
void
test_that_a_Spectra_pair_and_DiscontinuousSpectra_dataset_are_combined_correctly_when_spectra_do_not_overlap() {
- auto data1 = getIndirectFitData(10, 3);
- auto data2 = getIndirectFitData(10, 3);
+ auto data1 = getIndirectFitData(10);
+ auto data2 = getIndirectFitData(10);
- data1.setSpectra(DiscontinuousSpectra<std::size_t>("0-4"));
- data2.setSpectra(std::make_pair(5u, 9u));
- auto const combinedData = data2.combine(data1);
+ data1->setSpectra(DiscontinuousSpectra<std::size_t>("0-4"));
+ data2->setSpectra(std::make_pair(5u, 9u));
+ auto const combinedData = data2->combine(*data1);
Spectra const spec(DiscontinuousSpectra<std::size_t>("0-9"));
TS_ASSERT(
@@ -469,12 +449,12 @@ public:
void
test_that_a_Spectra_pair_and_DiscontinuousSpectra_dataset_are_combined_correctly_when_spectra_overlap() {
- auto data1 = getIndirectFitData(10, 3);
- auto data2 = getIndirectFitData(10, 3);
+ auto data1 = getIndirectFitData(10);
+ auto data2 = getIndirectFitData(10);
- data1.setSpectra(DiscontinuousSpectra<std::size_t>("0-7"));
- data2.setSpectra(std::make_pair(4u, 9u));
- auto const combinedData = data2.combine(data1);
+ data1->setSpectra(DiscontinuousSpectra<std::size_t>("0-7"));
+ data2->setSpectra(std::make_pair(4u, 9u));
+ auto const combinedData = data2->combine(*data1);
Spectra const spec(DiscontinuousSpectra<std::size_t>("0-9"));
TS_ASSERT(
diff --git a/qt/scientific_interfaces/Indirect/test/IndirectFitOutputTest.h b/qt/scientific_interfaces/Indirect/test/IndirectFitOutputTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..6cb93ee3c83e5d07119bf73ba41fc57e1a50ebd1
--- /dev/null
+++ b/qt/scientific_interfaces/Indirect/test/IndirectFitOutputTest.h
@@ -0,0 +1,355 @@
+#ifndef MANTID_INDIRECTFITOUTPUTTEST_H_
+#define MANTID_INDIRECTFITOUTPUTTEST_H_
+
+#include <cxxtest/TestSuite.h>
+
+#include "IndirectFitOutput.h"
+#include "MantidAPI/AlgorithmManager.h"
+#include "MantidAPI/FrameworkManager.h"
+#include "MantidAPI/ITableWorkspace.h"
+#include "MantidAPI/MatrixWorkspace.h"
+#include "MantidAPI/TableRow.h"
+#include "MantidAPI/WorkspaceFactory.h"
+#include "MantidAPI/WorkspaceGroup.h"
+#include "MantidTestHelpers/IndirectFitDataCreationHelper.h"
+
+using namespace Mantid::API;
+using namespace Mantid::IndirectFitDataCreationHelper;
+using namespace MantidQt::CustomInterfaces::IDA;
+
+namespace {
+
+MatrixWorkspace_sptr
+createPopulatedworkspace(std::vector<double> const &xValues,
+ std::vector<double> const &yValues,
+ int const numberOfSpectra,
+ std::vector<std::string> const &verticalAxisNames) {
+ auto createWorkspaceAlgorithm =
+ AlgorithmManager::Instance().createUnmanaged("CreateWorkspace");
+ createWorkspaceAlgorithm->initialize();
+ createWorkspaceAlgorithm->setChild(true);
+ createWorkspaceAlgorithm->setLogging(false);
+ createWorkspaceAlgorithm->setProperty("DataX", xValues);
+ createWorkspaceAlgorithm->setProperty("DataY", yValues);
+ createWorkspaceAlgorithm->setProperty("NSpec", numberOfSpectra);
+ createWorkspaceAlgorithm->setProperty("VerticalAxisUnit", "Text");
+ createWorkspaceAlgorithm->setProperty("VerticalAxisValues",
+ verticalAxisNames);
+ createWorkspaceAlgorithm->setProperty("OutputWorkspace", "workspace");
+ createWorkspaceAlgorithm->execute();
+ return createWorkspaceAlgorithm->getProperty("OutputWorkspace");
+}
+
+MatrixWorkspace_sptr createPopulatedworkspace(int const &numberOfSpectra) {
+ std::vector<double> xValues{1.0, 2.0, 3.0, 4.0, 5.0};
+ std::vector<double> yValues{1.0, 2.0, 3.0, 4.0, 5.0};
+ std::vector<std::string> const verticalAxisNames{
+ "Height", "Height_Err", "Msd", "Msd_Err", "Chi_squared"};
+ return createPopulatedworkspace(xValues, yValues, numberOfSpectra,
+ verticalAxisNames);
+}
+
+IndirectFitData getIndirectFitData(int const &numberOfSpectra) {
+ auto const workspace = createWorkspace(numberOfSpectra);
+ Spectra const spec = std::make_pair(0u, workspace->getNumberHistograms() - 1);
+ IndirectFitData data(workspace, spec);
+ return data;
+}
+
+ITableWorkspace_sptr getEmptyTableWorkspace() {
+ auto table = WorkspaceFactory::Instance().createTable();
+ std::vector<std::string> columnHeadings{"Height", "Height_Err", "Msd",
+ "Msd_Err", "Chi_squared"};
+ for (auto i = 0u; i < columnHeadings.size(); ++i)
+ table->addColumn("double", columnHeadings[i]);
+ return table;
+}
+
+ITableWorkspace_sptr getPopulatedTable(std::size_t const &size) {
+ auto table = getEmptyTableWorkspace();
+ for (auto i = 0u; i < size; ++i) {
+ TableRow row = table->appendRow();
+ row << 14.675 << 0.047 << 0.001 << 0.514 << 0.0149;
+ }
+ return table;
+}
+
+WorkspaceGroup_sptr getPopulatedGroup(std::size_t const &size) {
+ WorkspaceGroup_sptr group = boost::make_shared<WorkspaceGroup>();
+ for (auto i = 0u; i < size; ++i)
+ group->addWorkspace(createPopulatedworkspace(5));
+ return group;
+}
+
+/// Store workspaces in ADS and won't destruct the ADS when leaving scope
+void storeWorkspacesInADS(WorkspaceGroup_sptr group,
+ ITableWorkspace_sptr table) {
+ SetUpADSWithWorkspace ads("ResultGroup", group);
+ ads.addOrReplace("ResultWorkspaces", group);
+ ads.addOrReplace("ParameterTable", table);
+}
+
+std::unique_ptr<IndirectFitOutput>
+createFitOutput(WorkspaceGroup_sptr resultGroup,
+ ITableWorkspace_sptr parameterTable,
+ WorkspaceGroup_sptr resultWorkspace, IndirectFitData *fitData,
+ std::size_t spectrum) {
+ return std::make_unique<IndirectFitOutput>(
+ resultGroup, parameterTable, resultWorkspace, fitData, spectrum);
+}
+
+/// This will return fit output with workspaces still stored in the ADS
+std::unique_ptr<IndirectFitOutput> getFitOutputData() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+
+ storeWorkspacesInADS(group, table);
+
+ return createFitOutput(group, table, group, data, 0);
+}
+
+std::unordered_map<std::string, std::string>
+getNewParameterNames(std::vector<std::string> const ¤tNames) {
+ std::unordered_map<std::string, std::string> newParameterNames;
+ newParameterNames[currentNames[0]] = "Width_Err";
+ newParameterNames[currentNames[1]] = "MSD_Err";
+ return newParameterNames;
+}
+
+} // namespace
+
+class IndirectFitOutputTest : public CxxTest::TestSuite {
+public:
+ /// WorkflowAlgorithms do not appear in the FrameworkManager without this line
+ IndirectFitOutputTest() { FrameworkManager::Instance(); }
+
+ static IndirectFitOutputTest *createSuite() {
+ return new IndirectFitOutputTest();
+ }
+
+ static void destroySuite(IndirectFitOutputTest *suite) { delete suite; }
+
+ void tearDown() override { AnalysisDataService::Instance().clear(); }
+
+ void
+ test_that_IndirectFitOutput_constructor_will_set_the_values_of_the_output_data() {
+ auto const output = getFitOutputData();
+
+ TS_ASSERT(output->getLastResultGroup());
+ TS_ASSERT(output->getLastResultWorkspace());
+ TS_ASSERT_EQUALS(output->getLastResultGroup()->getNumberOfEntries(), 2);
+ TS_ASSERT_EQUALS(output->getLastResultWorkspace()->getNumberOfEntries(), 2);
+ TS_ASSERT_EQUALS(output->getResultParameterNames().size(), 5);
+ }
+
+ void
+ test_that_the_group_workspaces_stored_are_equal_to_the_workspaces_inputed() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data, 0);
+
+ TS_ASSERT_EQUALS(output->getLastResultGroup(), group);
+ TS_ASSERT_EQUALS(output->getLastResultWorkspace(), group);
+ }
+
+ void
+ test_that_isSpectrumFit_returns_false_if_the_spectrum_has_not_been_previously_fit() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data, 0);
+
+ TS_ASSERT(!output->isSpectrumFit(data, 7));
+ }
+
+ void
+ test_that_isSpectrumFit_returns_true_if_the_spectrum_has_been_previously_fit() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data, 0);
+
+ TS_ASSERT(output->isSpectrumFit(data, 0));
+ }
+
+ void
+ test_that_getParameters_returns_an_empty_map_when_the_spectrum_number_provided_is_out_of_range() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data, 0);
+
+ TS_ASSERT(output->getParameters(data, 7).empty());
+ }
+
+ void
+ test_that_getParameters_returns_the_correct_parameter_values_when_the_spectrum_number_and_IndirectFitData_provided_is_valid() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data, 0);
+
+ auto const parameters = output->getParameters(data, 0);
+ TS_ASSERT_EQUALS(parameters.size(), 2);
+ TS_ASSERT_EQUALS(parameters.at("Height_Err").value, 0.047);
+ TS_ASSERT_EQUALS(parameters.at("Msd_Err").value, 0.514);
+ }
+
+ void
+ test_that_getResultLocation_returns_none_when_the_spectrum_number_provided_is_out_of_range() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data, 0);
+
+ TS_ASSERT(!output->getResultLocation(data, 7));
+ }
+
+ void
+ test_that_getResultLocation_returns_the_ResultLocation_when_the_spectrum_number_and_IndirectFitData_provided_is_valid() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data, 0);
+
+ auto const resultLocation = output->getResultLocation(data, 0);
+ TS_ASSERT(resultLocation);
+ TS_ASSERT_EQUALS(resultLocation->result.lock(), group);
+ }
+
+ void
+ test_that_getResultParameterNames_gets_the_parameter_names_which_were_provided_as_input_data() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data, 0);
+ std::vector<std::string> const expectedParameters{
+ "Height", "Height_Err", "Msd", "Msd_Err", "Chi_squared"};
+ auto const parameters = output->getResultParameterNames();
+
+ TS_ASSERT_EQUALS(parameters.size(), 5);
+ for (auto i = 0u; i < parameters.size(); ++i)
+ TS_ASSERT_EQUALS(parameters[i], expectedParameters[i]);
+ }
+
+ void
+ test_that_getResultParameterNames_returns_an_empty_vector_if_the_result_workspace_cannot_be_found() {
+ /// The fact that the result workspace has been removed from the ADS means
+ /// the parameter names won't be available any longer.
+ auto const output = getFitOutputData();
+
+ AnalysisDataService::Instance().clear();
+
+ TS_ASSERT(output->getResultParameterNames().empty());
+ }
+
+ void
+ test_that_mapParameterNames_will_remap_the_parameters_to_correspond_to_the_provided_parameter_names() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data, 0);
+ auto const newParameterNames =
+ getNewParameterNames({"Height_Err", "Msd_Err"});
+ output->mapParameterNames(newParameterNames, data);
+
+ auto const parameters = output->getParameters(data, 0);
+ TS_ASSERT_EQUALS(parameters.size(), 2);
+ TS_ASSERT_EQUALS(parameters.at("Width_Err").value, 0.047);
+ TS_ASSERT_EQUALS(parameters.at("MSD_Err").value, 0.514);
+ }
+
+ void
+ test_that_mapParameterNames_will_not_remap_the_parameters_when_the_provided_old_parameter_names_do_not_exist() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data, 0);
+ auto const newParameterNames = getNewParameterNames({"None1", "None2"});
+ output->mapParameterNames(newParameterNames, data);
+
+ auto const parameters = output->getParameters(data, 0);
+ TS_ASSERT(parameters.at("Height_Err").value);
+ TS_ASSERT(parameters.at("Msd_Err").value);
+ }
+
+ void
+ test_that_addOutput_will_add_new_fitData_without_overwriting_existing_data() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data1 = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data1, 0);
+ IndirectFitData const *data2 = new IndirectFitData(getIndirectFitData(2));
+ output->addOutput(group, table, group, data2, 0);
+
+ TS_ASSERT(!output->getParameters(data1, 0).empty());
+ TS_ASSERT(!output->getParameters(data2, 0).empty());
+ }
+
+ void test_that_removeOutput_will_erase_the_provided_fitData() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data, 0);
+ output->removeOutput(data);
+
+ TS_ASSERT(output->getParameters(data, 0).empty());
+ TS_ASSERT(!output->getResultLocation(data, 0));
+ }
+
+ void test_that_removeOutput_will_not_delete_fitData_which_is_not_specified() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data1 = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data1, 0);
+ IndirectFitData const *data2 = new IndirectFitData(getIndirectFitData(2));
+ output->addOutput(group, table, group, data2, 0);
+ output->removeOutput(data2);
+
+ TS_ASSERT(!output->getParameters(data1, 0).empty());
+ TS_ASSERT(output->getParameters(data2, 0).empty());
+ }
+
+ void
+ test_that_removeOutput_does_not_throw_when_provided_fitData_which_does_not_exist() {
+ auto const group = getPopulatedGroup(2);
+ auto const table = getPopulatedTable(2);
+ IndirectFitData *data1 = new IndirectFitData(getIndirectFitData(5));
+ storeWorkspacesInADS(group, table);
+
+ auto const output = createFitOutput(group, table, group, data1, 0);
+ IndirectFitData const *data2 = new IndirectFitData(getIndirectFitData(2));
+
+ TS_ASSERT_THROWS_NOTHING(output->removeOutput(data2));
+ }
+};
+
+#endif // MANTID_INDIRECTFITOUTPUTTEST_H
diff --git a/qt/scientific_interfaces/Indirect/test/IndirectFitPlotModelTest.h b/qt/scientific_interfaces/Indirect/test/IndirectFitPlotModelTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b501d3f8d28f22c452c4642d5fc047b600b50fc
--- /dev/null
+++ b/qt/scientific_interfaces/Indirect/test/IndirectFitPlotModelTest.h
@@ -0,0 +1,419 @@
+#ifndef MANTID_INDIRECTFITPLOTMODELTEST_H_
+#define MANTID_INDIRECTFITPLOTMODELTEST_H_
+
+#include <cxxtest/TestSuite.h>
+
+#include "IndirectFitPlotModel.h"
+#include "MantidAPI/FrameworkManager.h"
+#include "MantidAPI/FunctionFactory.h"
+#include "MantidAPI/TextAxis.h"
+#include "MantidCurveFitting/Algorithms/ConvolutionFit.h"
+#include "MantidCurveFitting/Algorithms/QENSFitSequential.h"
+#include "MantidTestHelpers/IndirectFitDataCreationHelper.h"
+
+using namespace Mantid::API;
+using namespace Mantid::CurveFitting;
+using namespace MantidQt::CustomInterfaces::IDA;
+using namespace Mantid::IndirectFitDataCreationHelper;
+
+using ConvolutionFitSequential =
+ Algorithms::ConvolutionFit<Algorithms::QENSFitSequential>;
+
+namespace {
+
+/// The name of the conjoined input and guess workspaces
+std::string const INPUT_AND_GUESS_NAME = "__QENSInputAndGuess";
+
+std::string getFittingFunctionString(std::string const &workspaceName) {
+ return "name=LinearBackground,A0=0,A1=0,ties=(A0=0.000000,A1=0.0);"
+ "(composite=Convolution,FixResolution=true,NumDeriv=true;"
+ "name=Resolution,Workspace=" +
+ workspaceName +
+ ",WorkspaceIndex=0;((composite=ProductFunction,NumDeriv="
+ "false;name=Lorentzian,Amplitude=1,PeakCentre=1,FWHM=0."
+ "0175)))";
+}
+
+IFunction_sptr getFunction(std::string const &functionString) {
+ return FunctionFactory::Instance().createInitialized(functionString);
+}
+
+/// A dummy class used to create a model to pass to IndirectFitPlotModel's
+/// constructor
+class DummyModel
+ : public MantidQt::CustomInterfaces::IDA::IndirectFittingModel {
+public:
+ ~DummyModel(){};
+
+private:
+ std::string sequentialFitOutputName() const override { return ""; };
+ std::string simultaneousFitOutputName() const override { return ""; };
+ std::string singleFitOutputName(std::size_t index,
+ std::size_t spectrum) const override {
+ (void)index;
+ (void)spectrum;
+ return "";
+ };
+};
+
+void setFittingFunction(IndirectFittingModel *model,
+ std::string const &functionString,
+ bool setFitFunction) {
+ if (setFitFunction)
+ model->setFitFunction(getFunction(functionString));
+}
+
+IndirectFittingModel *getEmptyDummyModel() { return new DummyModel(); }
+
+IndirectFittingModel *
+createModelWithSingleWorkspace(std::string const &workspaceName,
+ int const &numberOfSpectra,
+ bool setFitFunction) {
+ auto model = getEmptyDummyModel();
+ SetUpADSWithWorkspace ads(workspaceName, createWorkspace(numberOfSpectra));
+ model->addWorkspace(workspaceName);
+ setFittingFunction(model, getFittingFunctionString(workspaceName),
+ setFitFunction);
+ return model;
+}
+
+void addWorkspacesToModel(IndirectFittingModel *model,
+ int const &numberOfSpectra) {
+ (void)model;
+ (void)numberOfSpectra;
+}
+
+template <typename Name, typename... Names>
+void addWorkspacesToModel(IndirectFittingModel *model,
+ int const &numberOfSpectra, Name const &workspaceName,
+ Names const &... workspaceNames) {
+ Mantid::API::AnalysisDataService::Instance().addOrReplace(
+ workspaceName, createWorkspace(numberOfSpectra));
+ model->addWorkspace(workspaceName);
+ addWorkspacesToModel(model, numberOfSpectra, workspaceNames...);
+}
+
+template <typename Name, typename... Names>
+IndirectFittingModel *createModelWithMultipleWorkspaces(
+ int const &numberOfSpectra, bool setFitFunction, Name const &workspaceName,
+ Names const &... workspaceNames) {
+ auto model = createModelWithSingleWorkspace(workspaceName, numberOfSpectra,
+ setFitFunction);
+ addWorkspacesToModel(model, numberOfSpectra, workspaceNames...);
+ return model;
+}
+
+IndirectFittingModel *createModelWithSingleInstrumentWorkspace(
+ std::string const &workspaceName, int const &xLength, int const &yLength) {
+ auto model = getEmptyDummyModel();
+ SetUpADSWithWorkspace ads(workspaceName,
+ createWorkspaceWithInstrument(xLength, yLength));
+ model->addWorkspace(workspaceName);
+ return model;
+}
+
+IAlgorithm_sptr setupFitAlgorithm(MatrixWorkspace_sptr workspace,
+ std::string const &functionString) {
+ auto alg = boost::make_shared<ConvolutionFitSequential>();
+ alg->initialize();
+ alg->setProperty("InputWorkspace", workspace);
+ alg->setProperty("Function", functionString);
+ alg->setProperty("StartX", 0.0);
+ alg->setProperty("EndX", 3.0);
+ alg->setProperty("SpecMin", 0);
+ alg->setProperty("SpecMax", 5);
+ alg->setProperty("ConvolveMembers", true);
+ alg->setProperty("Minimizer", "Levenberg-Marquardt");
+ alg->setProperty("MaxIterations", 500);
+ alg->setProperty("OutputWorkspace", "output");
+ alg->setLogging(false);
+ return alg;
+}
+
+IAlgorithm_sptr getSetupFitAlgorithm(IndirectFittingModel *model,
+ MatrixWorkspace_sptr workspace,
+ std::string const &workspaceName) {
+ setFittingFunction(model, getFittingFunctionString(workspaceName), true);
+ auto alg =
+ setupFitAlgorithm(workspace, getFittingFunctionString(workspaceName));
+ return alg;
+}
+
+IAlgorithm_sptr getExecutedFitAlgorithm(IndirectFittingModel *model,
+ MatrixWorkspace_sptr workspace,
+ std::string const &workspaceName) {
+ auto const alg = getSetupFitAlgorithm(model, workspace, workspaceName);
+ alg->execute();
+ return alg;
+}
+
+IndirectFittingModel *getModelWithFitOutputData() {
+ auto model = createModelWithSingleInstrumentWorkspace("__ConvFit", 6, 5);
+ auto const modelWorkspace = model->getWorkspace(0);
+
+ auto const alg = getExecutedFitAlgorithm(model, modelWorkspace, "__ConvFit");
+ model->addOutput(alg);
+ return model;
+}
+
+IndirectFitPlotModel getFitPlotModel(bool setFitFunction = true) {
+ return IndirectFitPlotModel(createModelWithMultipleWorkspaces(
+ 10, setFitFunction, "Workspace1", "Workspace2"));
+}
+
+IndirectFitPlotModel getFitPlotModelWithFitData() {
+ return IndirectFitPlotModel(getModelWithFitOutputData());
+}
+
+} // namespace
+
+class IndirectFitPlotModelTest : public CxxTest::TestSuite {
+public:
+ /// WorkflowAlgorithms do not appear in the FrameworkManager without this line
+ IndirectFitPlotModelTest() { FrameworkManager::Instance(); }
+
+ static IndirectFitPlotModelTest *createSuite() {
+ return new IndirectFitPlotModelTest();
+ }
+
+ static void destroySuite(IndirectFitPlotModelTest *suite) { delete suite; }
+
+ void tearDown() override { AnalysisDataService::Instance().clear(); }
+
+ void
+ test_that_IndirectFittingModel_instantiates_a_model_with_the_correct_starting_member_variables() {
+ auto const model = getFitPlotModel();
+
+ TS_ASSERT_EQUALS(model.getActiveDataIndex(), 0);
+ TS_ASSERT_EQUALS(model.getActiveSpectrum(), 0);
+ TS_ASSERT_EQUALS(model.numberOfWorkspaces(), 2);
+ }
+
+ void
+ test_that_getWorkspace_returns_a_workspace_with_the_correct_number_of_spectra() {
+ auto const model = getFitPlotModel();
+ TS_ASSERT_EQUALS(model.getWorkspace()->getNumberHistograms(), 10);
+ }
+
+ void
+ test_that_getGuessWorkspace_will_create_and_then_return_a_guess_workspace_with_the_correct_number_of_spectra() {
+ /// Only creates a guess for the active spectra of the selected workspace
+ auto const model = getFitPlotModel();
+
+ TS_ASSERT(model.getGuessWorkspace());
+ TS_ASSERT_EQUALS(model.getGuessWorkspace()->getNumberHistograms(), 1);
+ }
+
+ void
+ test_that_getResultWorkspace_returns_a_nullptr_if_a_fit_has_not_yet_been_run() {
+ auto const model = getFitPlotModel();
+ TS_ASSERT(!model.getResultWorkspace());
+ }
+
+ void
+ test_that_getResultWorkspace_returns_a_workspace_when_data_has_been_fit() {
+ auto const model = getFitPlotModelWithFitData();
+ TS_ASSERT(model.getResultWorkspace());
+ }
+
+ void
+ test_that_getSpectra_returns_the_same_spectra_range_which_was_provided_as_input() {
+ auto const model = getFitPlotModel();
+
+ Spectra const spectra = std::make_pair(0u, 9u);
+ Spectra const storedSpectra = model.getSpectra();
+
+ TS_ASSERT(boost::apply_visitor(AreSpectraEqual(), storedSpectra, spectra));
+ }
+
+ void
+ test_that_appendGuessToInput_returns_a_workspace_that_is_the_combination_of_the_input_and_guess_workspaces() {
+ auto const model = getFitPlotModel();
+ auto const guess = model.getGuessWorkspace();
+
+ auto const resultWorkspace = model.appendGuessToInput(guess);
+
+ TS_ASSERT(AnalysisDataService::Instance().doesExist(INPUT_AND_GUESS_NAME));
+ TS_ASSERT_EQUALS(resultWorkspace->getAxis(1)->label(0), "Sample");
+ TS_ASSERT_EQUALS(resultWorkspace->getAxis(1)->label(1), "Guess");
+ /// Only two spectra because the guessWorkspace will only ever have one
+ /// spectra, and then spectra are extracted from the input workspace between
+ /// m_activeSpectrum and m_activeSpectrum and so only 1 spectrum is
+ /// extracted. 1 + 1 = 2
+ TS_ASSERT_EQUALS(resultWorkspace->getNumberHistograms(), 2);
+ }
+
+ void
+ test_that_getActiveDataIndex_returns_the_index_which_it_has_been_set_to() {
+ auto model = getFitPlotModel();
+
+ model.setActiveIndex(2);
+
+ TS_ASSERT_EQUALS(model.getActiveDataIndex(), 2);
+ }
+
+ void
+ test_that_getActiveSpectrum_returns_the_spectrum_which_it_has_been_set_to() {
+ auto model = getFitPlotModel();
+
+ model.setActiveSpectrum(3);
+
+ TS_ASSERT_EQUALS(model.getActiveSpectrum(), 3);
+ }
+
+ void test_that_getFitDataName_returns_the_correctly_calculated_name() {
+ auto const model = getFitPlotModel();
+
+ TS_ASSERT_EQUALS(model.getFitDataName(), "Workspace1 (0-9)");
+ TS_ASSERT_EQUALS(model.getFitDataName(1), "Workspace2 (0-9)");
+ }
+
+ void
+ test_that_getFitDataName_does_not_throw_when_provided_an_out_of_range_index() {
+ auto const model = getFitPlotModel();
+ TS_ASSERT_THROWS_NOTHING(model.getFitDataName(10000000));
+ }
+
+ void
+ test_that_getLastFitDataName_returns_the_name_for_the_last_workspace_in_the_model() {
+ auto const model = getFitPlotModel();
+ TS_ASSERT_EQUALS(model.getLastFitDataName(), "Workspace2 (0-9)");
+ }
+
+ void test_that_getRange_returns_the_range_which_is_set() {
+ auto model = getFitPlotModel();
+
+ model.setStartX(2.2);
+ model.setEndX(8.8);
+
+ TS_ASSERT_EQUALS(model.getRange().first, 2.2);
+ TS_ASSERT_EQUALS(model.getRange().second, 8.8);
+ }
+
+ void
+ test_that_setStartX_does_not_set_the_StartX_when_the_provided_value_is_larger_than_the_EndX() {
+ auto model = getFitPlotModel();
+
+ model.setEndX(2.2);
+ model.setStartX(8.8);
+
+ TS_ASSERT_EQUALS(model.getRange().first, 0.0);
+ TS_ASSERT_EQUALS(model.getRange().second, 2.2);
+ }
+
+ void
+ test_that_setEndX_does_not_set_the_EndX_when_the_provided_value_is_smaller_than_the_StartX() {
+ auto model = getFitPlotModel();
+
+ model.setStartX(8.8);
+ model.setEndX(2.2);
+
+ TS_ASSERT_EQUALS(model.getRange().first, 8.8);
+ TS_ASSERT_EQUALS(model.getRange().second, 10.0);
+ }
+
+ void test_that_getWorkspaceRange_returns_the_defaulted_values_before_a_fit() {
+ auto const model = getFitPlotModel();
+
+ TS_ASSERT_EQUALS(model.getWorkspaceRange().first, 0.0);
+ TS_ASSERT_EQUALS(model.getWorkspaceRange().second, 10.0);
+ }
+
+ void
+ test_that_getResultRange_returns_the_different_values_to_the_values_before_the_fit() {
+ auto const model = getFitPlotModelWithFitData();
+
+ TS_ASSERT_DIFFERS(model.getResultRange().first, 0.0);
+ TS_ASSERT_DIFFERS(model.getResultRange().second, 10.0);
+ }
+
+ void
+ test_that_getFirstHWHM_returns_half_the_value_of_the_FWHM_in_the_fitting_function() {
+ auto const model = getFitPlotModel();
+ TS_ASSERT_EQUALS(model.getFirstHWHM(), 0.0175 / 2);
+ }
+
+ void
+ test_that_getFirstPeakCentre_returns_the_value_of_the_first_PeakCentre_in_the_fitting_function() {
+ auto const model = getFitPlotModel();
+ TS_ASSERT_EQUALS(model.getFirstPeakCentre(), 1.0);
+ }
+
+ void
+ test_that_getFirstBackgroundLevel_returns_the_value_of_the_first_background_level_in_the_fitting_function() {
+ auto const model = getFitPlotModel();
+ TS_ASSERT_EQUALS(model.getFirstBackgroundLevel(), 0.0);
+ }
+
+ void test_that_calculateHWHMMaximum_returns_the_value_expected() {
+ auto const model = getFitPlotModel();
+
+ auto const hwhm = model.getFirstHWHM();
+ auto const peakCentre = model.getFirstPeakCentre().get_value_or(0.);
+
+ auto const minimum = peakCentre + *hwhm;
+ TS_ASSERT_EQUALS(model.calculateHWHMMaximum(minimum), 0.99125);
+ }
+
+ void test_that_calculateHWHMMinimum_returns_the_value_expected() {
+ auto const model = getFitPlotModel();
+
+ auto const hwhm = model.getFirstHWHM();
+ auto const peakCentre = model.getFirstPeakCentre().get_value_or(0.);
+
+ auto const maximum = peakCentre - *hwhm;
+ TS_ASSERT_EQUALS(model.calculateHWHMMinimum(maximum), 1.00875);
+ }
+
+ void
+ test_that_canCalculateGuess_returns_false_when_there_is_no_fitting_function() {
+ auto const model = getFitPlotModel(false);
+ TS_ASSERT(!model.canCalculateGuess());
+ }
+
+ void
+ test_that_canCalculateGuess_returns_true_when_there_is_a_fitting_function_and_a_model_with_a_workspace() {
+ auto const model = getFitPlotModel();
+ TS_ASSERT(model.canCalculateGuess());
+ }
+
+ void
+ test_that_setFWHM_will_change_the_value_of_the_FWHM_in_the_fitting_function() {
+ auto model = getFitPlotModel();
+
+ auto const fwhm = 1.1;
+ model.setFWHM(fwhm);
+
+ TS_ASSERT_EQUALS(model.getFirstHWHM(), fwhm / 2);
+ }
+
+ void
+ test_that_setBackground_will_change_the_value_of_A0_in_the_fitting_function() {
+ auto model = getFitPlotModel();
+
+ auto const background = 0.12;
+ model.setBackground(background);
+
+ TS_ASSERT_EQUALS(model.getFirstBackgroundLevel(), background);
+ }
+
+ void
+ test_that_deleteExternalGuessWorkspace_removes_the_guess_workspace_from_the_ADS() {
+ auto model = getFitPlotModel();
+
+ auto const guess = model.getGuessWorkspace();
+ (void)model.appendGuessToInput(guess);
+
+ TS_ASSERT(AnalysisDataService::Instance().doesExist(INPUT_AND_GUESS_NAME));
+ model.deleteExternalGuessWorkspace();
+ TS_ASSERT(!AnalysisDataService::Instance().doesExist(INPUT_AND_GUESS_NAME));
+ }
+
+ void
+ test_that_deleteExternalGuessWorkspace_does_not_throw_if_the_guess_workspace_does_not_exist() {
+ auto model = getFitPlotModel();
+ TS_ASSERT_THROWS_NOTHING(model.deleteExternalGuessWorkspace());
+ }
+};
+
+#endif
diff --git a/qt/scientific_interfaces/Indirect/test/IndirectFittingModelTest.h b/qt/scientific_interfaces/Indirect/test/IndirectFittingModelTest.h
index 0713690a4a8f871cc7a629a3bf59651c4c3af7e8..287a3f78cd1f5a773d7449a75fc3514235e7b207 100644
--- a/qt/scientific_interfaces/Indirect/test/IndirectFittingModelTest.h
+++ b/qt/scientific_interfaces/Indirect/test/IndirectFittingModelTest.h
@@ -10,109 +10,26 @@
#include "MantidCurveFitting/Algorithms/ConvolutionFit.h"
#include "MantidCurveFitting/Algorithms/QENSFitSequential.h"
#include "MantidDataObjects/Workspace2D.h"
-#include "MantidTestHelpers/WorkspaceCreationHelper.h"
-
-#include <iostream>
+#include "MantidTestHelpers/IndirectFitDataCreationHelper.h"
using namespace Mantid::API;
using namespace Mantid::CurveFitting;
using namespace Mantid::DataObjects;
using namespace MantidQt::CustomInterfaces::IDA;
+using namespace Mantid::IndirectFitDataCreationHelper;
using ConvolutionFitSequential =
Algorithms::ConvolutionFit<Algorithms::QENSFitSequential>;
namespace {
-MatrixWorkspace_sptr createWorkspace(int const &numberOfSpectra) {
- return WorkspaceCreationHelper::create2DWorkspace(numberOfSpectra, 10);
-}
-
-MatrixWorkspace_sptr setWorkspaceEFixed(MatrixWorkspace_sptr workspace,
- int const &xLength) {
- for (int i = 0; i < xLength; i++)
- workspace->setEFixed((i + 1), 0.50);
- return workspace;
-}
-
-MatrixWorkspace_sptr
-setWorkspaceBinEdges(MatrixWorkspace_sptr workspace, int const &yLength,
- Mantid::HistogramData::BinEdges const &binEdges) {
- for (int i = 0; i < yLength; i++)
- workspace->setBinEdges(i, binEdges);
- return workspace;
-}
-
-MatrixWorkspace_sptr setWorkspaceBinEdges(MatrixWorkspace_sptr workspace,
- int const &xLength,
- int const &yLength) {
- Mantid::HistogramData::BinEdges binEdges(xLength - 1, 0.0);
- int j = 0;
- std::generate(begin(binEdges), end(binEdges),
- [&j] { return 0.5 + 0.75 * j++; });
- setWorkspaceBinEdges(workspace, yLength, binEdges);
- return workspace;
-}
-
-MatrixWorkspace_sptr setWorkspaceProperties(MatrixWorkspace_sptr workspace,
- int const &xLength,
- int const &yLength) {
- setWorkspaceBinEdges(workspace, xLength, yLength);
- setWorkspaceEFixed(workspace, xLength);
- return workspace;
-}
-
-MatrixWorkspace_sptr createWorkspaceWithInstrument(int const &xLength,
- int const &yLength) {
- auto workspace = WorkspaceCreationHelper::create2DWorkspaceWithFullInstrument(
- xLength, yLength - 1, false, false, true, "testInst");
- workspace->initialize(yLength, xLength, xLength - 1);
- return setWorkspaceProperties(workspace, xLength, yLength);
-}
-
IFunction_sptr getFunction(std::string const &functionString) {
return FunctionFactory::Instance().createInitialized(functionString);
}
-/// Simple class to set up the ADS with the configuration required
-struct SetUpADSWithWorkspace {
-
- template <typename T>
- SetUpADSWithWorkspace(std::string const &inputWSName, T const &workspace) {
- AnalysisDataService::Instance().addOrReplace(inputWSName, workspace);
- }
-
- template <typename T>
- void addOrReplace(std::string const &workspaceName, T const &workspace) {
- AnalysisDataService::Instance().addOrReplace(workspaceName, workspace);
- }
-
- bool doesExist(std::string const &workspaceName) {
- return AnalysisDataService::Instance().doesExist(workspaceName);
- }
-
- MatrixWorkspace_sptr retrieveWorkspace(std::string const &workspaceName) {
- return boost::dynamic_pointer_cast<MatrixWorkspace>(
- AnalysisDataService::Instance().retrieve(workspaceName));
- }
-
- ~SetUpADSWithWorkspace() { AnalysisDataService::Instance().clear(); }
-};
-
-/// This is used to compare Spectra which is implemented as a boost::variant
-struct AreSpectraEqual : public boost::static_visitor<bool> {
-
- template <typename T, typename U>
- bool operator()(const T &, const U &) const {
- return false; // cannot compare different types
- }
-
- template <typename T> bool operator()(const T &lhs, const T &rhs) const {
- return lhs == rhs;
- }
-};
-
-class DummyModel : public IndirectFittingModel {
+/// A dummy model used to inherit the methods which need testing
+class DummyModel
+ : public MantidQt::CustomInterfaces::IDA::IndirectFittingModel {
public:
~DummyModel(){};
@@ -150,7 +67,8 @@ template <typename Name, typename... Names>
void addWorkspacesToModel(std::unique_ptr<DummyModel> &model,
int const &numberOfSpectra, Name const &workspaceName,
Names const &... workspaceNames) {
- SetUpADSWithWorkspace ads(workspaceName, createWorkspace(numberOfSpectra));
+ Mantid::API::AnalysisDataService::Instance().addOrReplace(
+ workspaceName, createWorkspace(numberOfSpectra));
model->addWorkspace(workspaceName);
addWorkspacesToModel(model, numberOfSpectra, workspaceNames...);
}
@@ -174,6 +92,62 @@ std::unique_ptr<DummyModel> createModelWithSingleInstrumentWorkspace(
return model;
}
+void setFittingFunction(std::unique_ptr<DummyModel> &model,
+ std::string const &functionString) {
+ model->setFitFunction(getFunction(functionString));
+}
+
+IAlgorithm_sptr setupFitAlgorithm(MatrixWorkspace_sptr workspace,
+ std::string const &functionString) {
+ auto alg = boost::make_shared<ConvolutionFitSequential>();
+ alg->initialize();
+ alg->setProperty("InputWorkspace", workspace);
+ alg->setProperty("Function", functionString);
+ alg->setProperty("StartX", 0.0);
+ alg->setProperty("EndX", 3.0);
+ alg->setProperty("SpecMin", 0);
+ alg->setProperty("SpecMax", 5);
+ alg->setProperty("ConvolveMembers", true);
+ alg->setProperty("Minimizer", "Levenberg-Marquardt");
+ alg->setProperty("MaxIterations", 500);
+ alg->setProperty("OutputWorkspace", "output");
+ alg->setLogging(false);
+ return alg;
+}
+
+IAlgorithm_sptr getSetupFitAlgorithm(std::unique_ptr<DummyModel> &model,
+ MatrixWorkspace_sptr workspace,
+ std::string const &workspaceName) {
+ std::string const function =
+ "name=LinearBackground,A0=0,A1=0,ties=(A0=0.000000,A1=0.0);"
+ "(composite=Convolution,FixResolution=true,NumDeriv=true;"
+ "name=Resolution,Workspace=" +
+ workspaceName +
+ ",WorkspaceIndex=0;((composite=ProductFunction,NumDeriv="
+ "false;name=Lorentzian,Amplitude=1,PeakCentre=0,FWHM=0."
+ "0175)))";
+ setFittingFunction(model, function);
+ auto alg = setupFitAlgorithm(workspace, function);
+ return alg;
+}
+
+IAlgorithm_sptr getExecutedFitAlgorithm(std::unique_ptr<DummyModel> &model,
+ MatrixWorkspace_sptr workspace,
+ std::string const &workspaceName) {
+ auto const alg = getSetupFitAlgorithm(model, workspace, workspaceName);
+ alg->execute();
+ return alg;
+}
+
+std::unique_ptr<DummyModel> getModelWithFitOutputData() {
+ auto model = createModelWithSingleInstrumentWorkspace("__ConvFit", 6, 5);
+ auto const modelWorkspace = model->getWorkspace(0);
+
+ auto const alg = getExecutedFitAlgorithm(model, modelWorkspace, "__ConvFit");
+ model->addOutput(alg);
+ return model;
+}
+
} // namespace
class IndirectFittingModelTest : public CxxTest::TestSuite {
@@ -187,6 +161,8 @@ public:
static void destroySuite(IndirectFittingModelTest *suite) { delete suite; }
+ void tearDown() override { AnalysisDataService::Instance().clear(); }
+
void test_model_is_instantiated_correctly() {
auto model = createModelWithSingleWorkspace("WorkspaceName", 3);
@@ -426,7 +402,6 @@ public:
void test_that_ConvolutionSequentialFit_algorithm_initializes() {
auto model = createModelWithSingleInstrumentWorkspace("Name", 6, 5);
auto const modelWorkspace = model->getWorkspace(0);
- SetUpADSWithWorkspace ads("Name", modelWorkspace);
auto const alg = getSetupFitAlgorithm(model, modelWorkspace, "Name");
@@ -436,7 +411,6 @@ public:
void test_that_ConvolutionSequentialFit_algorithm_executes_without_error() {
auto model = createModelWithSingleInstrumentWorkspace("Name", 6, 5);
auto const modelWorkspace = model->getWorkspace(0);
- SetUpADSWithWorkspace ads("Name", modelWorkspace);
auto const alg = getSetupFitAlgorithm(model, modelWorkspace, "Name");
@@ -447,7 +421,6 @@ public:
void test_that_addOutput_adds_the_output_of_a_fit_into_the_model() {
auto model = createModelWithSingleInstrumentWorkspace("__ConvFit", 6, 5);
auto const modelWorkspace = model->getWorkspace(0);
- SetUpADSWithWorkspace ads("__ConvFit", modelWorkspace);
auto const alg =
getExecutedFitAlgorithm(model, modelWorkspace, "__ConvFit");
@@ -504,7 +477,6 @@ public:
void test_isInvalidFunction_returns_none_if_the_activeFunction_is_valid() {
auto model = createModelWithSingleInstrumentWorkspace("Name", 6, 5);
auto const modelWorkspace = model->getWorkspace(0);
- SetUpADSWithWorkspace ads("Name", modelWorkspace);
(void)getSetupFitAlgorithm(model, modelWorkspace, "Name");
@@ -539,7 +511,6 @@ public:
test_that_getFitParameterNames_returns_a_vector_of_fit_parameters_if_the_fitOutput_contains_parameters() {
auto model = createModelWithSingleInstrumentWorkspace("__ConvFit", 6, 5);
auto const modelWorkspace = model->getWorkspace(0);
- SetUpADSWithWorkspace ads("__ConvFit", modelWorkspace);
auto const alg =
getExecutedFitAlgorithm(model, modelWorkspace, "__ConvFit");
@@ -645,7 +616,6 @@ public:
test_that_setDefaultParameterValue_will_set_the_value_of_the_provided_parameter() {
auto model = createModelWithSingleWorkspace("Name", 5);
auto const modelWorkspace = model->getWorkspace(0);
- SetUpADSWithWorkspace ads("Name", modelWorkspace);
(void)getSetupFitAlgorithm(model, modelWorkspace, "Name");
model->setDefaultParameterValue("Amplitude", 1.5, 0);
@@ -664,7 +634,6 @@ public:
test_that_getParameterValues_returns_the_default_parameters_if_there_are_no_fit_parameters() {
auto model = createModelWithSingleInstrumentWorkspace("__ConvFit", 6, 5);
auto const modelWorkspace = model->getWorkspace(0);
- SetUpADSWithWorkspace ads("__ConvFit", modelWorkspace);
(void)getSetupFitAlgorithm(model, modelWorkspace, "__ConvFit");
model->setDefaultParameterValue("Amplitude", 1.5, 0);
@@ -686,7 +655,6 @@ public:
void test_getFitParameters_returns_an_empty_map_when_there_is_no_fitOutput() {
auto model = createModelWithSingleInstrumentWorkspace("__ConvFit", 6, 5);
auto const modelWorkspace = model->getWorkspace(0);
- SetUpADSWithWorkspace ads("__ConvFit", modelWorkspace);
(void)getSetupFitAlgorithm(model, modelWorkspace, "__ConvFit");
@@ -762,66 +730,6 @@ public:
model->cleanFailedSingleRun(alg, 0);
TS_ASSERT(!ads.doesExist("__ConvolutionFitSequential_ws1"));
}
-
-private:
- void setFittingFunction(std::unique_ptr<DummyModel> &model,
- std::string const &functionString) const {
- model->setFitFunction(getFunction(functionString));
- }
-
- IAlgorithm_sptr setupFitAlgorithm(MatrixWorkspace_sptr workspace,
- std::string const &functionString) const {
- auto alg = boost::make_shared<ConvolutionFitSequential>();
- TS_ASSERT_THROWS_NOTHING(alg->initialize());
- alg->setProperty("InputWorkspace", workspace);
- alg->setProperty("Function", functionString);
- alg->setProperty("StartX", 0.0);
- alg->setProperty("EndX", 3.0);
- alg->setProperty("SpecMin", 0);
- alg->setProperty("SpecMax", 5);
- alg->setProperty("ConvolveMembers", true);
- alg->setProperty("Minimizer", "Levenberg-Marquardt");
- alg->setProperty("MaxIterations", 500);
- alg->setProperty("OutputWorkspace", "output");
- alg->setLogging(false);
- return alg;
- }
-
- IAlgorithm_sptr getSetupFitAlgorithm(std::unique_ptr<DummyModel> &model,
- MatrixWorkspace_sptr workspace,
- std::string const &workspaceName) const {
- std::string const function =
- "name=LinearBackground,A0=0,A1=0,ties=(A0=0.000000,A1=0.0);"
- "(composite=Convolution,FixResolution=true,NumDeriv=true;"
- "name=Resolution,Workspace=" +
- workspaceName +
- ",WorkspaceIndex=0;((composite=ProductFunction,NumDeriv="
- "false;name=Lorentzian,Amplitude=1,PeakCentre=0,FWHM=0."
- "0175)))";
- setFittingFunction(model, function);
- auto alg = setupFitAlgorithm(workspace, function);
- return alg;
- }
-
- IAlgorithm_sptr
- getExecutedFitAlgorithm(std::unique_ptr<DummyModel> &model,
- MatrixWorkspace_sptr workspace,
- std::string const &workspaceName) const {
- auto const alg = getSetupFitAlgorithm(model, workspace, workspaceName);
- alg->execute();
- return alg;
- }
-
- std::unique_ptr<DummyModel> getModelWithFitOutputData() {
- auto model = createModelWithSingleInstrumentWorkspace("__ConvFit", 6, 5);
- auto const modelWorkspace = model->getWorkspace(0);
- SetUpADSWithWorkspace ads("__ConvFit", modelWorkspace);
-
- auto const alg =
- getExecutedFitAlgorithm(model, modelWorkspace, "__ConvFit");
- model->addOutput(alg);
- return model;
- }
};
-#endif
+#endif // MANTID_INDIRECTFITTINGMODELTEST_H
diff --git a/qt/widgets/common/test/DataProcessorUI/GenericDataProcessorPresenterTest.h b/qt/widgets/common/test/DataProcessorUI/GenericDataProcessorPresenterTest.h
index ff0fde37d86509305921dd87ec0af606c8bf0ddb..4a9e06dcc03466a81752d89aeacda62b21e48ec6 100644
--- a/qt/widgets/common/test/DataProcessorUI/GenericDataProcessorPresenterTest.h
+++ b/qt/widgets/common/test/DataProcessorUI/GenericDataProcessorPresenterTest.h
@@ -261,7 +261,7 @@ private:
<< "1.6"
<< "0.04"
<< "1"
- << "ProcessingInstructions='0'";
+ << "ProcessingInstructions='1'";
row = ws->appendRow();
row << "0"
<< "12346"
@@ -271,7 +271,7 @@ private:
<< "2.9"
<< "0.04"
<< "1"
- << "ProcessingInstructions='0'";
+ << "ProcessingInstructions='1'";
row = ws->appendRow();
row << "1"
<< "24681"
@@ -281,7 +281,7 @@ private:
<< "1.6"
<< "0.04"
<< "1"
- << "ProcessingInstructions='0'";
+ << "ProcessingInstructions='1'";
row = ws->appendRow();
row << "1"
<< "24682"
@@ -291,7 +291,7 @@ private:
<< "2.9"
<< "0.04"
<< "1"
- << "ProcessingInstructions='0'";
+ << "ProcessingInstructions='1'";
return ws;
}
@@ -1652,7 +1652,7 @@ public:
<< "1.6"
<< "0.04"
<< "1"
- << "ProcessingInstructions='0'";
+ << "ProcessingInstructions='1'";
row = ws->appendRow();
row << "1"
<< "dataB"
@@ -1662,7 +1662,7 @@ public:
<< "2.9"
<< "0.04"
<< "1"
- << "ProcessingInstructions='0'";
+ << "ProcessingInstructions='1'";
createTOFWorkspace("dataA");
createTOFWorkspace("dataB");
@@ -2421,7 +2421,7 @@ public:
rowlist[0].insert(1);
const auto expected = QString(
- "0\t12346\t1.5\t\t1.4\t2.9\t0.04\t1\tProcessingInstructions='0'\t");
+ "0\t12346\t1.5\t\t1.4\t2.9\t0.04\t1\tProcessingInstructions='1'\t");
// The user hits "copy selected" with the second and third rows selected
EXPECT_CALL(mockDataProcessorView, setClipboard(expected));
@@ -2470,10 +2470,10 @@ public:
rowlist[1].insert(1);
const auto expected = QString(
- "0\t12345\t0.5\t\t0.1\t1.6\t0.04\t1\tProcessingInstructions='0'\t\n"
- "0\t12346\t1.5\t\t1.4\t2.9\t0.04\t1\tProcessingInstructions='0'\t\n"
- "1\t24681\t0.5\t\t0.1\t1.6\t0.04\t1\tProcessingInstructions='0'\t\n"
- "1\t24682\t1.5\t\t1.4\t2.9\t0.04\t1\tProcessingInstructions='0'\t");
+ "0\t12345\t0.5\t\t0.1\t1.6\t0.04\t1\tProcessingInstructions='1'\t\n"
+ "0\t12346\t1.5\t\t1.4\t2.9\t0.04\t1\tProcessingInstructions='1'\t\n"
+ "1\t24681\t0.5\t\t0.1\t1.6\t0.04\t1\tProcessingInstructions='1'\t\n"
+ "1\t24682\t1.5\t\t1.4\t2.9\t0.04\t1\tProcessingInstructions='1'\t");
// The user hits "copy selected" with the second and third rows selected
EXPECT_CALL(mockDataProcessorView, setClipboard(expected));
@@ -2501,7 +2501,7 @@ public:
rowlist[0].insert(1);
const auto expected = QString(
- "0\t12346\t1.5\t\t1.4\t2.9\t0.04\t1\tProcessingInstructions='0'\t");
+ "0\t12346\t1.5\t\t1.4\t2.9\t0.04\t1\tProcessingInstructions='1'\t");
// The user hits "copy selected" with the second and third rows selected
EXPECT_CALL(mockDataProcessorView, setClipboard(expected));
@@ -2542,9 +2542,9 @@ public:
rowlist[1].insert(0);
const auto expected = QString(
- "0\t12345\t0.5\t\t0.1\t1.6\t0.04\t1\tProcessingInstructions='0'\t\n"
- "0\t12346\t1.5\t\t1.4\t2.9\t0.04\t1\tProcessingInstructions='0'\t\n"
- "1\t24681\t0.5\t\t0.1\t1.6\t0.04\t1\tProcessingInstructions='0'\t");
+ "0\t12345\t0.5\t\t0.1\t1.6\t0.04\t1\tProcessingInstructions='1'\t\n"
+ "0\t12346\t1.5\t\t1.4\t2.9\t0.04\t1\tProcessingInstructions='1'\t\n"
+ "1\t24681\t0.5\t\t0.1\t1.6\t0.04\t1\tProcessingInstructions='1'\t");
// The user hits "copy selected" with the second and third rows selected
EXPECT_CALL(mockDataProcessorView, setClipboard(expected));
diff --git a/qt/widgets/instrumentview/inc/MantidQtWidgets/InstrumentView/BankTextureBuilder.h b/qt/widgets/instrumentview/inc/MantidQtWidgets/InstrumentView/BankTextureBuilder.h
index ac125e5c21e8ba2b00d0a485758fbe23d422a528..ece5631cc8c28369f7fb0af9d7f5b7fccf42af57 100644
--- a/qt/widgets/instrumentview/inc/MantidQtWidgets/InstrumentView/BankTextureBuilder.h
+++ b/qt/widgets/instrumentview/inc/MantidQtWidgets/InstrumentView/BankTextureBuilder.h
@@ -28,6 +28,7 @@ class BankTextureBuilder {
public:
BankTextureBuilder(const Mantid::Geometry::ComponentInfo &compInfo,
size_t index);
+ ~BankTextureBuilder();
void buildColorTextures(const std::vector<GLColor> &colors,
bool isUsingLayer = false, size_t layer = 0);
void buildPickTextures(const std::vector<GLColor> &colors,
diff --git a/qt/widgets/instrumentview/src/BankTextureBuilder.cpp b/qt/widgets/instrumentview/src/BankTextureBuilder.cpp
index 7cf1f565e89b7b7d289b2f52f2c3ffe8114e5e80..60c2cc28e9c81d9f969d7cafe89fc22ec2630255 100644
--- a/qt/widgets/instrumentview/src/BankTextureBuilder.cpp
+++ b/qt/widgets/instrumentview/src/BankTextureBuilder.cpp
@@ -71,7 +71,7 @@ void addColorsToTopAndBottomTextures(
}
void upload2DTexture(const std::pair<size_t, size_t> &textSizes,
- GLuint &textureID, std::vector<char> &texture) {
+ GLuint &textureID, const std::vector<char> &texture) {
auto w = textSizes.first;
auto h = textSizes.second;
@@ -127,6 +127,18 @@ BankTextureBuilder::BankTextureBuilder(
}
}
+BankTextureBuilder::~BankTextureBuilder() {
+ for (size_t i = 0; i < m_colorTextureIDs.size(); ++i) {
+ auto &colTextureID = m_colorTextureIDs[i];
+ auto &pickTextureID = m_pickTextureIDs[i];
+
+ if (colTextureID > 0)
+ glDeleteTextures(1, &colTextureID);
+ if (pickTextureID > 0)
+ glDeleteTextures(1, &pickTextureID);
+ }
+}
+
/** Generate and store color textures for bank. This method results in opengl
calls to
* register texture Ids and build textures in memory.
@@ -210,7 +222,7 @@ void BankTextureBuilder::buildTubeBankTextures(
texture.resize(children.size() * 3);
for (size_t i = 0; i < children.size(); ++i) {
- auto col = colors[children[i]];
+ const auto &col = colors[children[i]];
auto pos = i * 3;
texture[pos] = static_cast<unsigned char>(col.red());
texture[pos + 1] = static_cast<unsigned char>(col.green());
diff --git a/scripts/Diffraction/isis_powder/pearl_routines/pearl_output.py b/scripts/Diffraction/isis_powder/pearl_routines/pearl_output.py
index 5b08b81756e13d94b30cbaf4436b31b18f521073..2814850c728e20f35a274a6e878a548b74cabe6c 100644
--- a/scripts/Diffraction/isis_powder/pearl_routines/pearl_output.py
+++ b/scripts/Diffraction/isis_powder/pearl_routines/pearl_output.py
@@ -64,7 +64,8 @@ def _focus_mode_all(output_file_paths, processed_spectra, attenuation_filepath):
summed_spectra = mantid.ConvertUnits(InputWorkspace=summed_spectra, Target="dSpacing",
OutputWorkspace=summed_spectra_name)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=summed_spectra, Append=False)
-
+ mantid.SaveFocusedXYE(InputWorkspace=summed_spectra_name, Filename=output_file_paths["tof_xye_filename"],
+ Append=False, IncludeHeader=False)
output_list = [summed_spectra]
for i in range(0, 5):
spectra_index = (i + 9) # Compensate for 0 based index
@@ -73,6 +74,9 @@ def _focus_mode_all(output_file_paths, processed_spectra, attenuation_filepath):
ws_to_save = mantid.ConvertUnits(InputWorkspace=ws_to_save, OutputWorkspace=ws_to_save, Target="TOF")
mantid.SaveGSS(InputWorkspace=ws_to_save, Filename=output_file_paths["gss_filename"], Append=True, Bank=i + 2)
+ splits = output_file_paths["tof_xye_filename"].split(".")
+ tof_xye_name = splits[0] + "-" + str(i + 10) + "." + splits[1]
+ mantid.SaveFocusedXYE(InputWorkspace=ws_to_save, Filename=tof_xye_name, Append=False, IncludeHeader=False)
ws_to_save = mantid.ConvertUnits(InputWorkspace=ws_to_save, OutputWorkspace=output_name, Target="dSpacing")
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=ws_to_save, Append=True)
@@ -100,7 +104,8 @@ def _focus_mode_groups(output_file_paths, calibrated_spectra):
ws = mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=ws, Target="TOF")
mantid.SaveGSS(InputWorkspace=ws, Filename=output_file_paths["gss_filename"], Append=False,
Bank=index)
-
+ mantid.SaveFocusedXYE(InputWorkspace=ws, Filename=output_file_paths["tof_xye_filename"],
+ Append=False, IncludeHeader=False)
workspace_names = ws.name()
ws = mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=workspace_names, Target="dSpacing")
output_list.append(ws)
@@ -116,7 +121,10 @@ def _focus_mode_groups(output_file_paths, calibrated_spectra):
to_save = mantid.CloneWorkspace(InputWorkspace=monitor_ws, OutputWorkspace=monitor_ws_name)
to_save = mantid.ConvertUnits(InputWorkspace=to_save, OutputWorkspace=to_save, Target="TOF")
+ splits = output_file_paths["tof_xye_filename"].split(".")
+ tof_xye_name = splits[0] + "-" + str(i+10) + "." + splits[1]
mantid.SaveGSS(InputWorkspace=to_save, Filename=output_file_paths["gss_filename"], Append=True, Bank=i + 5)
+ mantid.SaveFocusedXYE(InputWorkspace=to_save, Filename=tof_xye_name, Append=False, IncludeHeader=False)
to_save = mantid.ConvertUnits(InputWorkspace=to_save, OutputWorkspace=monitor_ws_name, Target="dSpacing")
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=to_save, Append=True)
@@ -132,6 +140,8 @@ def _focus_mode_mods(output_file_paths, calibrated_spectra):
output_name = output_file_paths["output_name"] + "_mod" + str(index + 1)
tof_ws = mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=output_name,
Target=WORKSPACE_UNITS.tof)
+ mantid.SaveFocusedXYE(InputWorkspace=tof_ws, Filename=output_file_paths["tof_xye_filename"],
+ Append=False, IncludeHeader=False)
mantid.SaveGSS(InputWorkspace=tof_ws, Filename=output_file_paths["gss_filename"], Append=append, Bank=index + 1)
dspacing_ws = mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=output_name,
Target=WORKSPACE_UNITS.d_spacing)
@@ -155,6 +165,7 @@ def _focus_mode_trans(output_file_paths, attenuation_filepath, calibrated_spectr
summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws, Target="TOF")
mantid.SaveGSS(InputWorkspace=summed_ws, Filename=output_file_paths["gss_filename"], Append=False, Bank=1)
+
mantid.SaveFocusedXYE(InputWorkspace=summed_ws, Filename=output_file_paths["tof_xye_filename"],
Append=False, IncludeHeader=False)
diff --git a/scripts/Diffraction/isis_powder/routines/focus.py b/scripts/Diffraction/isis_powder/routines/focus.py
index d683467fb44605ff5f691add09ef3b3b06ac63f1..92014e2b090233e8c518675d0cb39428e353e8ae 100644
--- a/scripts/Diffraction/isis_powder/routines/focus.py
+++ b/scripts/Diffraction/isis_powder/routines/focus.py
@@ -126,7 +126,8 @@ def _divide_one_spectrum_by_spline(spectrum, spline, instrument):
if instrument.get_instrument_prefix() == "GEM":
divided = mantid.Divide(LHSWorkspace=spectrum, RHSWorkspace=rebinned_spline, OutputWorkspace=spectrum,
StoreInADS=False)
- return _crop_spline_to_percent_of_max(rebinned_spline, divided, spectrum)
+ # crop based off max between 1000 and 2000 tof as the vanadium peak on Gem will always occur here
+ return _crop_spline_to_percent_of_max(rebinned_spline, divided, spectrum, 1000, 2000)
divided = mantid.Divide(LHSWorkspace=spectrum, RHSWorkspace=rebinned_spline, OutputWorkspace=spectrum)
return divided
@@ -172,11 +173,17 @@ def _test_splined_vanadium_exists(instrument, run_details):
" \nHave you run the method to create a Vanadium spline with these settings yet?\n")
-def _crop_spline_to_percent_of_max(spline, input_ws, output_workspace):
+def _crop_spline_to_percent_of_max(spline, input_ws, output_workspace, min_value, max_value):
spline_spectrum = spline.readY(0)
- y_val = numpy.amax(spline_spectrum)
- y_val = y_val / 100
+ if not spline_spectrum.any():
+ return mantid.CloneWorkspace(inputWorkspace=input_ws, OutputWorkspace=output_workspace)
+
x_list = input_ws.readX(0)
+ min_index = x_list.searchsorted(min_value)
+ max_index = x_list.searchsorted(max_value)
+ sliced_spline_spectrum = spline_spectrum[min_index:max_index:1]
+ y_val = numpy.amax(sliced_spline_spectrum)
+ y_val = y_val / 100
small_spline_indecies = numpy.nonzero(spline_spectrum > y_val)[0]
x_max = x_list[small_spline_indecies[-1]]
x_min = x_list[small_spline_indecies[0]]
diff --git a/scripts/Inelastic/IndirectReductionCommon.py b/scripts/Inelastic/IndirectReductionCommon.py
index 1689bdc5434d8c74e5316d26082336cda0ea30e0..ca9a964e878f786f29aa5a604da7cad8c9fe78c8 100644
--- a/scripts/Inelastic/IndirectReductionCommon.py
+++ b/scripts/Inelastic/IndirectReductionCommon.py
@@ -592,12 +592,11 @@ def get_group_from_string(grouping_string):
return [int(grouping_string)]
-def create_group_from_string(input_workspace, grouping_string):
- from mantid.simpleapi import GroupDetectors
- return GroupDetectors(InputWorkspace=input_workspace,
- Behaviour='Average',
- SpectraList=get_group_from_string(grouping_string),
- StoreInADS=False)
+def create_group_from_string(group_detectors, grouping_string):
+ group_detectors.setProperty("WorkspaceIndexList", get_group_from_string(grouping_string))
+ group_detectors.setProperty("OutputWorkspace", "__temp")
+ group_detectors.execute()
+ return group_detectors.getProperty("OutputWorkspace").value
def conjoin_workspaces(*workspaces):
@@ -609,9 +608,9 @@ def conjoin_workspaces(*workspaces):
return conjoined
-def group_on_string(input_workspace, grouping_string):
+def group_on_string(group_detectors, grouping_string):
grouping_string.replace(' ', '')
- groups = [create_group_from_string(input_workspace, group) for group in grouping_string.split(',')]
+ groups = [create_group_from_string(group_detectors, group) for group in grouping_string.split(',')]
return conjoin_workspaces(*groups)
@@ -710,7 +709,7 @@ def group_spectra_of(workspace, masked_detectors, method, group_file=None, group
# Mask detectors if required
if len(masked_detectors) > 0:
_mask_detectors(workspace, masked_detectors)
- return group_on_string(workspace, group_string)
+ return group_on_string(group_detectors, group_string)
else:
raise RuntimeError('Invalid grouping method %s for workspace %s' % (grouping_method, workspace.getName()))
diff --git a/scripts/test/isis_powder/ISISPowderFocusCropTest.py b/scripts/test/isis_powder/ISISPowderFocusCropTest.py
index f05ab6f1889fd09c1eb8e8b7983ea3d47fee6552..db87ab54c890d0d839479e225344b122e7b962db 100644
--- a/scripts/test/isis_powder/ISISPowderFocusCropTest.py
+++ b/scripts/test/isis_powder/ISISPowderFocusCropTest.py
@@ -15,7 +15,8 @@ class ISISPowderFocusCropTest(unittest.TestCase):
x = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
y = [0, 0, 10, 30, 2000, 80, 50, 40, 30, 25, 30]
test_ws = mantid.CreateWorkspace(DataX=x, DataY=y)
- test_ws = focus._crop_spline_to_percent_of_max(test_ws, test_ws, test_ws)
+ # search entire range (0 to 100) for max
+ test_ws = focus._crop_spline_to_percent_of_max(test_ws, test_ws, test_ws, 0, 100)
y_compare = [30, 2000, 80, 50, 40, 30, 25, 30]
result = test_ws.readY(0)
for compare, val in zip(y_compare, result):
@@ -25,7 +26,8 @@ class ISISPowderFocusCropTest(unittest.TestCase):
x = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
y = [50, 100, 300, 500, 2000, 80, 50, 0, 0, 0, 0]
test_ws = mantid.CreateWorkspace(DataX=x, DataY=y)
- test_ws = focus._crop_spline_to_percent_of_max(test_ws, test_ws, test_ws)
+ # search entire range (0 to 100) for max
+ test_ws = focus._crop_spline_to_percent_of_max(test_ws, test_ws, test_ws, 0, 100)
y_compare = [50, 100, 300, 500, 2000, 80, 50]
result = test_ws.readY(0)
for compare, val in zip(y_compare, result):
@@ -35,7 +37,8 @@ class ISISPowderFocusCropTest(unittest.TestCase):
x = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
y = [0, 0, 10, 30, 2000, 80, 50, 0, 0, 0, 0]
test_ws = mantid.CreateWorkspace(DataX=x, DataY=y)
- test_ws = focus._crop_spline_to_percent_of_max(test_ws, test_ws, test_ws)
+ # search entire range (0 to 100) for max
+ test_ws = focus._crop_spline_to_percent_of_max(test_ws, test_ws, test_ws, 0, 100)
y_compare = [30, 2000, 80, 50]
result = test_ws.readY(0)
for compare, val in zip(y_compare, result):
@@ -45,12 +48,35 @@ class ISISPowderFocusCropTest(unittest.TestCase):
x = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
y = [1, 5, 10, 30, 20, 80, 50, 40, 20, 10, 1]
test_ws = mantid.CreateWorkspace(DataX=x, DataY=y)
- test_ws = focus._crop_spline_to_percent_of_max(test_ws, test_ws, test_ws)
+ # search entire range (0 to 100) for max
+ test_ws = focus._crop_spline_to_percent_of_max(test_ws, test_ws, test_ws, 0, 100)
y_compare = [1, 5, 10, 30, 20, 80, 50, 40, 20, 10, 1]
result = test_ws.readY(0)
for compare, val in zip(y_compare, result):
self.assertEqual(compare, val)
+ def test_no_crop_subrange(self):
+ x = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
+ y = [1, 5, 10, 30, 20, 80, 50, 40, 20, 10, 10000]
+ test_ws = mantid.CreateWorkspace(DataX=x, DataY=y)
+ # search from 0 to 20 x for max
+ test_ws = focus._crop_spline_to_percent_of_max(test_ws, test_ws, test_ws, 0, 20)
+ y_compare = [1, 5, 10, 30, 20, 80, 50, 40, 20, 10, 10000]
+ result = test_ws.readY(0)
+ for compare, val in zip(y_compare, result):
+ self.assertEqual(compare, val)
+
+ def test_crop_subrange(self):
+ x = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
+ y = [1, 50, 2000, 30, 20, 80, 50, 40, 20, 10, 1]
+ test_ws = mantid.CreateWorkspace(DataX=x, DataY=y)
+ # search from 0 to 30 x for max
+ test_ws = focus._crop_spline_to_percent_of_max(test_ws, test_ws, test_ws, 0, 30)
+ y_compare = [50, 2000, 30, 20, 80, 50, 40]
+ result = test_ws.readY(0)
+ for compare, val in zip(y_compare, result):
+ self.assertEqual(compare, val)
+
if __name__ == '__main__':
unittest.main()