Skip to content
Snippets Groups Projects
Commit eac26e44 authored by Martyn Gigg's avatar Martyn Gigg
Browse files

Improve IndexPeaks test coverage significantly 

Remove file loading in tests to vastly improve performance
Refs #26829
parent 363864f4
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Framework/Crystal/src/IndexPeaks.cpp
+ 21
− 21
View file @ eac26e44
...@@ -47,17 +47,13 @@ void IndexPeaks::init() { ...@@ -47,17 +47,13 @@ void IndexPeaks::init() {
this->declareProperty("CommonUBForAll", false, this->declareProperty("CommonUBForAll", false,
"Index all orientations with a common UB"); "Index all orientations with a common UB");
this->declareProperty(std::make_unique<PropertyWithValue<int>>(
"NumIndexed", 0, Direction::Output),
"Gets set with the number of indexed peaks.");
this->declareProperty(std::make_unique<PropertyWithValue<double>>( this->declareProperty(std::make_unique<PropertyWithValue<double>>(
"AverageError", 0.0, Direction::Output), "AverageError", 0.0, Direction::Output),
"Gets set with the average HKL indexing error."); "Gets set with the average HKL indexing error.");
this->declareProperty(std::make_unique<PropertyWithValue<int>>( this->declareProperty(std::make_unique<PropertyWithValue<int>>(
"TotalNumIndexed", 0, Direction::Output), "NumIndexed", 0, Direction::Output),
"Gets set with the number of Total indexed peaks."); "Gets set with the number of indexed peaks.");
this->declareProperty(std::make_unique<PropertyWithValue<int>>( this->declareProperty(std::make_unique<PropertyWithValue<int>>(
"MainNumIndexed", 0, Direction::Output), "MainNumIndexed", 0, Direction::Output),
...@@ -82,10 +78,6 @@ void IndexPeaks::init() { ...@@ -82,10 +78,6 @@ void IndexPeaks::init() {
*/ */
void IndexPeaks::exec() { void IndexPeaks::exec() {
PeaksWorkspace_sptr ws = this->getProperty("PeaksWorkspace"); PeaksWorkspace_sptr ws = this->getProperty("PeaksWorkspace");
if (!ws) {
throw std::runtime_error("Could not read the peaks workspace");
}
OrientedLattice o_lattice = ws->mutableSample().getOrientedLattice(); OrientedLattice o_lattice = ws->mutableSample().getOrientedLattice();
const Matrix<double> &UB = o_lattice.getUB(); const Matrix<double> &UB = o_lattice.getUB();
...@@ -118,6 +110,8 @@ void IndexPeaks::exec() { ...@@ -118,6 +110,8 @@ void IndexPeaks::exec() {
total_indexed = IndexingUtils::CalculateMillerIndices( total_indexed = IndexingUtils::CalculateMillerIndices(
UB, q_vectors, tolerance, miller_indices, average_error); UB, q_vectors, tolerance, miller_indices, average_error);
if (round_hkls)
IndexingUtils::RoundHKLs(miller_indices);
for (size_t i = 0; i < n_peaks; i++) { for (size_t i = 0; i < n_peaks; i++) {
peaks[i].setHKL(miller_indices[i]); peaks[i].setHKL(miller_indices[i]);
...@@ -204,11 +198,10 @@ void IndexPeaks::exec() { ...@@ -204,11 +198,10 @@ void IndexPeaks::exec() {
iteration++; iteration++;
} }
if (o_lattice.getMaxOrder() == // If data not modulated, recalculate fractional HKL
0) // If data not modulated, recalculate fractional HKL if (o_lattice.getMaxOrder() == 0) {
{ // If user wants fractional hkls, recalculate them
if (!round_hkls) // If user wants fractional hkls, recalculate them if (!round_hkls) {
{
num_indexed = IndexingUtils::CalculateMillerIndices( num_indexed = IndexingUtils::CalculateMillerIndices(
tempUB, q_vectors, tolerance, miller_indices, average_error); tempUB, q_vectors, tolerance, miller_indices, average_error);
} }
...@@ -264,11 +257,14 @@ void IndexPeaks::exec() { ...@@ -264,11 +257,14 @@ void IndexPeaks::exec() {
if (peak.getRunNumber() == run) { if (peak.getRunNumber() == run) {
peak.setHKL(miller_indices[miller_index_counter]); peak.setHKL(miller_indices[miller_index_counter]);
miller_index_counter++; miller_index_counter++;
auto hkl = peak.getHKL(); auto hkl = peak.getHKL();
bool peak_main_indexed{false}, peak_sat_indexed{false}; bool peak_main_indexed{false}, peak_sat_indexed{false};
if (IndexingUtils::ValidIndex(hkl, tolerance)) { if (IndexingUtils::ValidIndex(hkl, tolerance)) {
if (round_hkls) {
IndexingUtils::RoundHKL(hkl);
peak.setHKL(hkl);
}
peak.setIntHKL(hkl); peak.setIntHKL(hkl);
peak.setIntMNP(V3D(0, 0, 0)); peak.setIntMNP(V3D(0, 0, 0));
peak_main_indexed = true; peak_main_indexed = true;
...@@ -422,7 +418,11 @@ void IndexPeaks::exec() { ...@@ -422,7 +418,11 @@ void IndexPeaks::exec() {
// Save output properties // Save output properties
this->setProperty("NumIndexed", total_indexed); this->setProperty("NumIndexed", total_indexed);
this->setProperty("MainNumIndexed", total_indexed);
this->setProperty("SateNumIndexed", 0);
this->setProperty("AverageError", average_error); this->setProperty("AverageError", average_error);
this->setProperty("MainError", average_error);
this->setProperty("SatelliteError", 0.);
// Show the lattice parameters // Show the lattice parameters
g_log.notice() << o_lattice << "\n"; g_log.notice() << o_lattice << "\n";
} else { } else {
...@@ -440,11 +440,11 @@ void IndexPeaks::exec() { ...@@ -440,11 +440,11 @@ void IndexPeaks::exec() {
<< average_sate_error << '\n'; << average_sate_error << '\n';
// Save output properties // Save output properties
setProperty("TotalNumIndexed", total_indexed); this->setProperty("NumIndexed", total_indexed);
setProperty("MainNumIndexed", total_main); this->setProperty("MainNumIndexed", total_main);
setProperty("SateNumIndexed", total_sate); this->setProperty("SateNumIndexed", total_sate);
setProperty("MainError", average_main_error); this->setProperty("MainError", average_main_error);
setProperty("SatelliteError", average_sate_error); this->setProperty("SatelliteError", average_sate_error);
// Show the lattice parameters // Show the lattice parameters
g_log.notice() << o_lattice << "\n"; g_log.notice() << o_lattice << "\n";
} }
......
Framework/Crystal/test/IndexPeaksTest.h
+ 258
− 112
View file @ eac26e44
...@@ -7,25 +7,109 @@ ...@@ -7,25 +7,109 @@
#ifndef MANTID_CRYSTAL_INDEX_PEAKS_TEST_H_ #ifndef MANTID_CRYSTAL_INDEX_PEAKS_TEST_H_
#define MANTID_CRYSTAL_INDEX_PEAKS_TEST_H_ #define MANTID_CRYSTAL_INDEX_PEAKS_TEST_H_
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/Sample.h" #include "MantidAPI/Sample.h"
#include "MantidKernel/System.h"
#include "MantidKernel/Timer.h"
#include <cxxtest/TestSuite.h>
#include "MantidCrystal/IndexPeaks.h" #include "MantidCrystal/IndexPeaks.h"
#include "MantidCrystal/LoadIsawUB.h"
#include "MantidDataHandling/LoadNexusProcessed.h"
#include "MantidDataObjects/PeaksWorkspace.h" #include "MantidDataObjects/PeaksWorkspace.h"
#include "MantidGeometry/Crystal/IndexingUtils.h" #include "MantidGeometry/Crystal/IndexingUtils.h"
#include "MantidGeometry/Crystal/OrientedLattice.h" #include "MantidGeometry/Crystal/OrientedLattice.h"
#include "MantidTestHelpers/WorkspaceCreationHelper.h"
#include <cxxtest/TestSuite.h>
using Mantid::API::Workspace_sptr;
using Mantid::Crystal::IndexPeaks;
using Mantid::DataObjects::PeaksWorkspace_sptr;
using Mantid::Geometry::IndexingUtils;
using Mantid::Geometry::OrientedLattice;
using Mantid::Kernel::V3D;
namespace {
// run number, det pos, q_sample
using MinimalPeak = std::tuple<int, V3D>;
template <int NPeaks> using MinimalPeaksList = std::array<MinimalPeak, NPeaks>;
template <int NPeaks>
PeaksWorkspace_sptr
createPeaksWorkspace(const MinimalPeaksList<NPeaks> &testPeaksInfo,
const std::vector<double> &ub, const int maxOrder = -1,
const std::vector<V3D> &modVectors = std::vector<V3D>()) {
auto peaksWS = WorkspaceCreationHelper::createPeaksWorkspace(NPeaks);
OrientedLattice lattice;
lattice.setUB(ub);
if (maxOrder > 0) {
lattice.setMaxOrder(maxOrder);
if (modVectors.empty() || modVectors.size() > 3)
throw std::runtime_error("Only <= 3 modulation vectors can be provided.");
auto modVecOrDefault = [&modVectors](const size_t index) {
if (index < modVectors.size())
return modVectors[index];
else
return V3D();
};
lattice.setModVec1(modVecOrDefault(0));
lattice.setModVec2(modVecOrDefault(1));
lattice.setModVec3(modVecOrDefault(2));
}
peaksWS->mutableSample().setOrientedLattice(&lattice);
int peakCount{0};
for (const auto &testPeakInfo : testPeaksInfo) {
auto &wsPeak = peaksWS->getPeak(peakCount);
wsPeak.setRunNumber(std::get<0>(testPeakInfo));
wsPeak.setQSampleFrame(std::get<1>(testPeakInfo));
++peakCount;
}
return peaksWS;
}
PeaksWorkspace_sptr createTestPeaksWorkspaceMainReflOnly() {
constexpr int npeaks{5};
const std::vector<double> ub = {-0.0122354, 0.00480056, -0.0860404,
0.1165450, 0.00178145, 0.0045884,
0.0273738, -0.08973560, 0.0252595};
// peaks from TOPAZ_3007.peaks: 0, 1, 2, 10, 42 with sign for Q swapped
// as we don't use the crystallographic convention
constexpr std::array<MinimalPeak, npeaks> testPeaksInfo = {
MinimalPeak{3007, V3D(-3.52961, 3.13589, 1.0899)},
MinimalPeak{3007, V3D(-2.42456, 2.29581, 1.71147)},
MinimalPeak{3007, V3D(-3.04393, 3.05739, 2.03727)},
MinimalPeak{3007, V3D(-4.02271, 2.4073, 1.62228)},
MinimalPeak{3007, V3D(-4.04552, 1.59916, 3.71776)}};
return createPeaksWorkspace<npeaks>(testPeaksInfo, ub);
}
PeaksWorkspace_sptr
createTestPeaksWorkspaceWithSatellites(const int maxOrder,
const std::vector<V3D> &modVectors) {
constexpr int npeaks{5};
const std::vector<double> ub = {0.269, -0.01, 0.033, 0.081, -0.191,
-0.039, 0.279, 0.347, -0.02};
constexpr std::array<MinimalPeak, npeaks> testPeaksInfo = {
MinimalPeak{1, V3D(-3.691, -0.694, 3.762)}, // main
MinimalPeak{1, V3D(-1.234, -0.225, 1.25212)}, // satellite
MinimalPeak{1, V3D(-3.824, 0.728, 1.711)}, // main
MinimalPeak{1, V3D(0.872, -0.1998, 2.7476)}, // satellite
MinimalPeak{1, V3D(-1.54093, 0.129343, 1.445)}, // satellite
};
return createPeaksWorkspace<npeaks>(testPeaksInfo, ub, maxOrder, modVectors);
}
std::unique_ptr<IndexPeaks>
indexPeaks(PeaksWorkspace_sptr peaksWS,
const std::unordered_map<std::string, std::string> &arguments) {
auto alg = std::make_unique<IndexPeaks>();
alg->setChild(true);
alg->initialize();
alg->setProperty("PeaksWorkspace", peaksWS);
for (const auto &argument : arguments) {
alg->setPropertyValue(argument.first, argument.second);
}
alg->execute();
return alg;
}
using namespace Mantid::Crystal; } // namespace
using namespace Mantid::API;
using namespace Mantid::DataObjects;
using Mantid::DataHandling::LoadNexusProcessed;
using namespace Mantid::Kernel;
using namespace Mantid::Geometry;
class IndexPeaksTest : public CxxTest::TestSuite { class IndexPeaksTest : public CxxTest::TestSuite {
public: public:
...@@ -35,143 +119,205 @@ public: ...@@ -35,143 +119,205 @@ public:
TS_ASSERT(alg.isInitialized()) TS_ASSERT(alg.isInitialized())
} }
void test_exec() { void test_empty_peaks_workspace_indexes_nothing() {
// Name of the output workspace. auto peaksWS = WorkspaceCreationHelper::createPeaksWorkspace(0);
std::string WSName("peaks"); OrientedLattice lattice;
LoadNexusProcessed loader; peaksWS->mutableSample().setOrientedLattice(&lattice);
TS_ASSERT_THROWS_NOTHING(loader.initialize());
TS_ASSERT(loader.isInitialized()); auto alg = indexPeaks(peaksWS, {{"Tolerance", "0.1"}});
loader.setPropertyValue("Filename", "TOPAZ_3007.peaks.nxs");
loader.setPropertyValue("OutputWorkspace", WSName);
TS_ASSERT(loader.execute());
TS_ASSERT(loader.isExecuted());
PeaksWorkspace_sptr ws;
TS_ASSERT_THROWS_NOTHING(
ws = boost::dynamic_pointer_cast<PeaksWorkspace>(
AnalysisDataService::Instance().retrieve(WSName)));
TS_ASSERT(ws);
// clear all the peak indexes
std::vector<Peak> &peaks = ws->getPeaks();
size_t n_peaks = ws->getNumberPeaks();
for (size_t i = 0; i < n_peaks; i++) {
peaks[i].setHKL(V3D(0, 0, 0));
}
// now set a proper UB in the
// oriented lattice
V3D row_0(-0.0122354, 0.00480056, -0.0860404);
V3D row_1(0.1165450, 0.00178145, 0.0045884);
V3D row_2(0.0273738, -0.08973560, 0.0252595);
Matrix<double> UB(3, 3, false);
UB.setRow(0, row_0);
UB.setRow(1, row_1);
UB.setRow(2, row_2);
OrientedLattice o_lattice;
o_lattice.setUB(UB);
ws->mutableSample().setOrientedLattice(&o_lattice);
// index the peaks with the new UB
IndexPeaks alg;
TS_ASSERT_THROWS_NOTHING(alg.initialize())
TS_ASSERT(alg.isInitialized())
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("PeaksWorkspace", WSName));
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Tolerance", "0.1"));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("RoundHKLs", false));
TS_ASSERT_THROWS_NOTHING(alg.execute(););
TS_ASSERT(alg.isExecuted());
double tolerance = alg.getProperty("Tolerance"); TS_ASSERT(alg->isExecuted())
assertNumberPeaksIndexed(*alg, 0, 0, 0);
}
void test_no_roundHKLS_leaves_peaks_as_found() {
const auto ws = createTestPeaksWorkspaceMainReflOnly();
const auto mainToleranceAsStr = "0.1";
auto alg =
indexPeaks(ws, {{"Tolerance", mainToleranceAsStr}, {"RoundHKLs", "0"}});
// Check that the peaks were all indexed // Check that the peaks were all indexed
for (size_t i = 0; i < n_peaks; i++) { const double mainTolerance{std::stod(mainToleranceAsStr)};
TS_ASSERT(IndexingUtils::ValidIndex(peaks[i].getHKL(), tolerance)); auto &peaks = ws->getPeaks();
for (const auto &peak : peaks) {
TS_ASSERT(IndexingUtils::ValidIndex(peak.getHKL(), mainTolerance))
} }
// Check the output properties // Check the output properties
int numIndexed = alg.getProperty("NumIndexed"); assertNumberPeaksIndexed(*alg, 5, 5, 0);
TS_ASSERT_EQUALS(numIndexed, 43);
double averageError = alg.getProperty("AverageError"); const double averageError = alg->getProperty("AverageError");
TS_ASSERT_DELTA(averageError, 0.0097, 1e-3); TS_ASSERT_DELTA(averageError, 0.00639, 1e-4)
// spot check a few peaks for // spot check a few peaks for
// fractional Miller indices // fractional Miller indices
V3D peak_0_hkl_d(-4.03065, -0.9885090, -6.01095); // first peak const V3D peak_0_hkl_d(4.00682, 0.97956, 5.99368); // first peak
V3D peak_1_hkl_d(-2.99276, 0.9955220, -4.00375); const V3D peak_1_hkl_d(2.99838, -0.99760, 4.00141);
V3D peak_2_hkl_d(-3.99311, 0.9856010, -5.00772); const V3D peak_2_hkl_d(3.99737, -0.99031, 5.00250);
V3D peak_10_hkl_d(-3.01107, -0.0155531, -7.01377); const V3D peak_3_hkl_d(2.99419, 0.01736, 7.00538);
V3D peak_42_hkl_d(-1.97065, 4.0283600, -6.97828); // last peak const V3D peak_4_hkl_d(2.00277, -4.00813, 6.99744); // last peak
V3D error = peak_0_hkl_d - peaks[0].getHKL(); V3D error = peak_0_hkl_d - peaks[0].getHKL();
TS_ASSERT_DELTA(error.norm(), 0.0, 2e-4); TS_ASSERT_DELTA(error.norm(), 0.0, 2e-4)
error = peak_1_hkl_d - peaks[1].getHKL(); error = peak_1_hkl_d - peaks[1].getHKL();
TS_ASSERT_DELTA(error.norm(), 0.0, 1e-4); TS_ASSERT_DELTA(error.norm(), 0.0, 1e-4)
error = peak_2_hkl_d - peaks[2].getHKL(); error = peak_2_hkl_d - peaks[2].getHKL();
TS_ASSERT_DELTA(error.norm(), 0.0, 1e-4); TS_ASSERT_DELTA(error.norm(), 0.0, 1e-4)
error = peak_10_hkl_d - peaks[10].getHKL(); error = peak_3_hkl_d - peaks[3].getHKL();
TS_ASSERT_DELTA(error.norm(), 0.0, 1e-4); TS_ASSERT_DELTA(error.norm(), 0.0, 1e-4)
error = peak_42_hkl_d - peaks[42].getHKL(); error = peak_4_hkl_d - peaks[4].getHKL();
TS_ASSERT_DELTA(error.norm(), 0.0, 2e-4); TS_ASSERT_DELTA(error.norm(), 0.0, 2e-4)
}
// clear all the peak indexes then void test_roundHKLS_gives_integer_miller_indices() {
// re-run the algorithm, rounding the HKLs const auto ws = createTestPeaksWorkspaceMainReflOnly();
// this time, and again check a few peaks const auto mainToleranceAsStr = "0.1";
for (size_t i = 0; i < n_peaks; i++) { auto alg =
peaks[i].setHKL(V3D(0, 0, 0)); indexPeaks(ws, {{"Tolerance", mainToleranceAsStr}, {"RoundHKLs", "1"}});
// Check that the peaks were all indexed
const double mainTolerance{std::stod(mainToleranceAsStr)};
auto &peaks = ws->getPeaks();
for (const auto &peak : peaks) {
TS_ASSERT(IndexingUtils::ValidIndex(peak.getHKL(), mainTolerance))
} }
TS_ASSERT_THROWS_NOTHING(alg.initialize())
TS_ASSERT(alg.isInitialized())
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("PeaksWorkspace", WSName));
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Tolerance", "0.1"));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("RoundHKLs", true));
TS_ASSERT_THROWS_NOTHING(alg.execute(););
TS_ASSERT(alg.isExecuted());
// Check that the peaks were all indexed // Check that the peaks were all indexed
for (size_t i = 0; i < n_peaks; i++) { for (const auto &peak : peaks) {
TS_ASSERT(IndexingUtils::ValidIndex(peaks[i].getHKL(), tolerance)); TS_ASSERT(IndexingUtils::ValidIndex(peak.getHKL(), mainTolerance))
} }
// Check the output properties // Check the output properties
numIndexed = alg.getProperty("NumIndexed"); assertNumberPeaksIndexed(*alg, 5, 5, 0);
TS_ASSERT_EQUALS(numIndexed, 43);
averageError = alg.getProperty("AverageError"); const double averageError = alg->getProperty("AverageError");
TS_ASSERT_DELTA(averageError, 0.0097, 1e-3); TS_ASSERT_DELTA(averageError, 0.00673, 1e-3)
// spot check a few peaks for // spot check a few peaks for
// integer Miller indices // integer Miller indices
V3D peak_0_hkl(-4, -1, -6); V3D peak_0_hkl(4, 1, 6);
V3D peak_1_hkl(-3, 1, -4); V3D peak_1_hkl(3, -1, 4);
V3D peak_2_hkl(-4, 1, -5); V3D peak_2_hkl(4, -1, 5);
V3D peak_10_hkl(-3, 0, -7); V3D peak_3_hkl(3, 0, 7);
V3D peak_42_hkl(-2, 4, -7); // last peak V3D peak_4_hkl(2, -4, 7); // last peak
error = peak_0_hkl - peaks[0].getHKL(); auto error = peak_0_hkl - peaks[0].getHKL();
TS_ASSERT_DELTA(error.norm(), 0.0, 1e-10); TS_ASSERT_DELTA(error.norm(), 0.0, 1e-10)
error = peak_1_hkl - peaks[1].getHKL(); error = peak_1_hkl - peaks[1].getHKL();
TS_ASSERT_DELTA(error.norm(), 0.0, 1e-10); TS_ASSERT_DELTA(error.norm(), 0.0, 1e-10)
error = peak_2_hkl - peaks[2].getHKL(); error = peak_2_hkl - peaks[2].getHKL();
TS_ASSERT_DELTA(error.norm(), 0.0, 1e-10); TS_ASSERT_DELTA(error.norm(), 0.0, 1e-10)
error = peak_3_hkl - peaks[3].getHKL();
TS_ASSERT_DELTA(error.norm(), 0.0, 1e-10)
error = peak_4_hkl - peaks[4].getHKL();
TS_ASSERT_DELTA(error.norm(), 0.0, 1e-10)
}
error = peak_10_hkl - peaks[10].getHKL(); void
TS_ASSERT_DELTA(error.norm(), 0.0, 1e-10); test_zero_satellite_tol_only_indexes_main_refl_with_modvectors_on_from_ub() {
const auto peaksWS =
createTestPeaksWorkspaceWithSatellites(1, {V3D(0.333, -0.667, 0.333)});
const auto mainTolerance{"0.1"}, sateTolerance{"0."};
error = peak_42_hkl - peaks[42].getHKL(); const auto alg =
TS_ASSERT_DELTA(error.norm(), 0.0, 1e-10); indexPeaks(peaksWS, {{"Tolerance", mainTolerance},
{"ToleranceForSatellite", sateTolerance}});
assertNumberPeaksIndexed(*alg, 2, 2, 0);
assertIndexesAsExpected(*peaksWS,
{V3D(-1, 2, -9), V3D(0, 0, 0), V3D(-1, 1, -10),
V3D(0, 0, 0), V3D(0, 0, 0)});
}
void test_zero_maxorder_on_ub_indexes_main_refl_only() {
const auto peaksWS =
createTestPeaksWorkspaceWithSatellites(0, std::vector<V3D>());
const auto mainTolerance{"0.1"}, sateTolerance{"1."};
const auto alg =
indexPeaks(peaksWS, {{"Tolerance", mainTolerance},
{"ToleranceForSatellite", sateTolerance}});
assertNumberPeaksIndexed(*alg, 2, 2, 0);
assertIndexesAsExpected(*peaksWS,
{V3D(-1, 2, -9), V3D(0, 0, 0), V3D(-1, 1, -10),
V3D(0, 0, 0), V3D(0, 0, 0)});
}
void test_exec_with_common_ub_indexes_main_reflections_only() {
const auto peaksWS =
createTestPeaksWorkspaceWithSatellites(0, std::vector<V3D>());
const auto sateTolerance{"1."};
const auto alg =
indexPeaks(peaksWS, {{"CommonUBForAll", "1"},
{"ToleranceForSatellite", sateTolerance}});
assertNumberPeaksIndexed(*alg, 2, 2, 0);
assertIndexesAsExpected(*peaksWS,
{V3D(-1, 2, -9), V3D(0, 0, 0), V3D(-1, 1, -10),
V3D(0, 0, 0), V3D(0, 0, 0)});
assertErrorsAsExpected(*alg, 0.0140447, 0.0140447, 0.);
}
// --------------------------- Failure tests -----------------------------
void test_workspace_with_no_oriented_lattice_gives_validateInputs_error() {
const auto peaksWS = WorkspaceCreationHelper::createPeaksWorkspace(1);
IndexPeaks alg;
alg.initialize();
alg.setProperty("PeaksWorkspace", peaksWS);
auto helpMsgs = alg.validateInputs();
const auto valueIter = helpMsgs.find("PeaksWorkspace");
TS_ASSERT(valueIter != helpMsgs.cend())
if (valueIter != helpMsgs.cend()) {
const auto msg = valueIter->second;
TS_ASSERT(msg.find("OrientedLattice") != std::string::npos)
}
}
private:
void assertIndexesAsExpected(const PeaksWorkspace_sptr::element_type &peaksWS,
const std::vector<V3D> &expectedIndexes) {
assert(static_cast<size_t>(peaksWS.getNumberPeaks()) ==
expectedIndexes.size());
for (auto i = 0u; i < expectedIndexes.size(); ++i) {
TS_ASSERT_EQUALS(expectedIndexes[i], peaksWS.getPeak(i).getHKL())
}
}
void assertNumberPeaksIndexed(const IndexPeaks &alg,
const int numIndexedExpected,
const int mainNumIndexedExpected,
const int sateNumIndexedExpected) {
TS_ASSERT_EQUALS(numIndexedExpected,
static_cast<int>(alg.getProperty("NumIndexed")))
TS_ASSERT_EQUALS(mainNumIndexedExpected,
static_cast<int>(alg.getProperty("MainNumIndexed")))
TS_ASSERT_EQUALS(sateNumIndexedExpected,
static_cast<int>(alg.getProperty("SateNumIndexed")))
}
// Remove workspace from the data service. void assertErrorsAsExpected(const IndexPeaks &alg,
AnalysisDataService::Instance().remove(WSName); const double expectedAverageError,
const double expectedMainError,
const double expectedSatError) {
TS_ASSERT_DELTA(expectedAverageError,
static_cast<double>(alg.getProperty("AverageError")), 1e-5);
TS_ASSERT_DELTA(expectedMainError,
static_cast<double>(alg.getProperty("MainError")), 1e-5);
TS_ASSERT_DELTA(expectedSatError,
static_cast<double>(alg.getProperty("SatelliteError")),
1e-5);
} }
}; };
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment