Skip to content

Commit 137e855

Browse files
rboston628rboston628
authored
Merge pull request #37943 from mantidproject/ewm5044-compare-uncertainty-ornl
Add CheckUncertainty property to `CompareWorkspaces` to turn off error-comparison - `ornl-next`
2 parents 569c348 + 86fe32f commit 137e855

File tree

5 files changed

+201
-36
lines changed

5 files changed

+201
-36
lines changed

‎Framework/Algorithms/inc/MantidAlgorithms/CompareWorkspaces.h‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -123,6 +123,9 @@ class MANTID_ALGORITHMS_DLL CompareWorkspaces final : public API::Algorithm {
123123
/// Result of comparison (true if equal, false otherwise)
124124
bool m_result{false};
125125

126+
/// The comparison method to use (true if equal, false otherwise)
127+
std::function<bool(const double, const double)> m_compare;
128+
126129
/// Mismatch messages that resulted from comparison
127130
API::ITableWorkspace_sptr m_messages;
128131

‎Framework/Algorithms/src/CompareWorkspaces.cpp‎

Lines changed: 45 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -78,13 +78,13 @@ int compareEventLists(Kernel::Logger &logger, const EventList &el1, const EventL
7878
diffpulse = true;
7979
++numdiffpulse;
8080
}
81-
if (std::fabs(e1.tof() - e2.tof()) > tolTof) {
81+
if (std::abs(e1.tof() - e2.tof()) > tolTof) {
8282
difftof = true;
8383
++numdifftof;
8484
}
8585
if (diffpulse && difftof)
8686
++numdiffboth;
87-
if (std::fabs(e1.weight() - e2.weight()) > tolWeight) {
87+
if (std::abs(e1.weight() - e2.weight()) > tolWeight) {
8888
diffweight = true;
8989
++numdiffweight;
9090
}
@@ -122,6 +122,9 @@ void CompareWorkspaces::init() {
122122

123123
declareProperty("Tolerance", 1e-10, "The maximum amount by which values may differ between the workspaces.");
124124

125+
declareProperty("CheckUncertainty", true,
126+
"Whether to check that the y-value uncertainties (E) match "
127+
"(only for matrix workspaces). ");
125128
declareProperty("CheckType", true,
126129
"Whether to check that the data types "
127130
"(Workspace2D vs EventWorkspace) match.");
@@ -168,6 +171,17 @@ void CompareWorkspaces::exec() {
168171
if (g_log.is(Logger::Priority::PRIO_DEBUG))
169172
m_parallelComparison = false;
170173

174+
double const tolerance = getProperty("Tolerance");
175+
if (getProperty("ToleranceRelErr")) {
176+
this->m_compare = [tolerance](double const x1, double const x2) -> bool {
177+
return CompareWorkspaces::withinRelativeTolerance(x1, x2, tolerance);
178+
};
179+
} else {
180+
this->m_compare = [tolerance](double const x1, double const x2) -> bool {
181+
return CompareWorkspaces::withinAbsoluteTolerance(x1, x2, tolerance);
182+
};
183+
}
184+
171185
this->doComparison();
172186

173187
if (!m_result) {
@@ -600,18 +614,7 @@ bool CompareWorkspaces::checkData(const API::MatrixWorkspace_const_sptr &ws1,
600614
}
601615
const bool histogram = ws1->isHistogramData();
602616
const bool checkAllData = getProperty("CheckAllData");
603-
const bool isRelErr = getProperty("ToleranceRelErr");
604-
const double tolerance = getProperty("Tolerance");
605-
std::function<bool(double const, double const)> compare;
606-
if (isRelErr) {
607-
compare = [tolerance](double const x1, double const x2) -> bool {
608-
return CompareWorkspaces::withinRelativeTolerance(x1, x2, tolerance);
609-
};
610-
} else {
611-
compare = [tolerance](double const x1, double const x2) -> bool {
612-
return CompareWorkspaces::withinAbsoluteTolerance(x1, x2, tolerance);
613-
};
614-
}
617+
const bool checkError = getProperty("CheckUncertainty");
615618

616619
// First check that the workspace are the same size
617620
if (numHists != ws2->getNumberHistograms() ||
@@ -653,22 +656,27 @@ bool CompareWorkspaces::checkData(const API::MatrixWorkspace_const_sptr &ws1,
653656
} else {
654657

655658
for (int j = 0; j < static_cast<int>(Y1.size()); ++j) {
656-
bool err = (!compare(X1[j], X2[j]) || !compare(Y1[j], Y2[j]) || !compare(E1[j], E2[j]));
659+
bool err = (!m_compare(X1[j], X2[j]) || !m_compare(Y1[j], Y2[j]));
660+
// if CheckUncertianty flag is set, also compare the uncertainties
661+
// only need to do this if not already a mismatch (err == false)
662+
// then, there is a mismatch only if the uncertainties don't match
663+
if (checkError && !err)
664+
err = !m_compare(E1[j], E2[j]);
657665
if (err) {
658666
if (logDebug) {
659667
g_log.debug() << "Data mismatch at cell (hist#,bin#): (" << i << "," << j << ")\n";
660668
g_log.debug() << " Dataset #1 (X,Y,E) = (" << X1[j] << "," << Y1[j] << "," << E1[j] << ")\n";
661669
g_log.debug() << " Dataset #2 (X,Y,E) = (" << X2[j] << "," << Y2[j] << "," << E2[j] << ")\n";
662-
g_log.debug() << " Difference (X,Y,E) = (" << std::fabs(X1[j] - X2[j]) << "," << std::fabs(Y1[j] - Y2[j])
663-
<< "," << std::fabs(E1[j] - E2[j]) << ")\n";
670+
g_log.debug() << " Difference (X,Y,E) = (" << std::abs(X1[j] - X2[j]) << "," << std::abs(Y1[j] - Y2[j])
671+
<< "," << std::abs(E1[j] - E2[j]) << ")\n";
664672
}
665673
PARALLEL_CRITICAL(resultBool)
666674
resultBool = false;
667675
}
668676
}
669677

670678
// Extra one for histogram data
671-
if (histogram && !compare(X1.back(), X2.back())) {
679+
if (histogram && !m_compare(X1.back(), X2.back())) {
672680
if (logDebug) {
673681
g_log.debug() << " Data ranges mismatch for spectra N: (" << i << ")\n";
674682
g_log.debug() << " Last bin ranges (X1_end vs X2_end) = (" << X1.back() << "," << X2.back() << ")\n";
@@ -1040,7 +1048,6 @@ void CompareWorkspaces::doPeaksComparison(PeaksWorkspace_sptr tws1, PeaksWorkspa
10401048
tws2 = std::dynamic_pointer_cast<PeaksWorkspace>(tmp2);
10411049
}
10421050

1043-
const double tolerance = getProperty("Tolerance");
10441051
const bool isRelErr = getProperty("ToleranceRelErr");
10451052
for (int i = 0; i < tws1->getNumberPeaks(); i++) {
10461053
const Peak &peak1 = tws1->getPeak(i);
@@ -1105,13 +1112,13 @@ void CompareWorkspaces::doPeaksComparison(PeaksWorkspace_sptr tws1, PeaksWorkspa
11051112
}
11061113
bool mismatch = false;
11071114
if (isRelErr) {
1108-
mismatch = !withinRelativeTolerance(s1, s2, tolerance);
1109-
// Q: whould we not also compare the vectors?
1115+
mismatch = !m_compare(s1, s2);
1116+
// Q: why should we not also compare the vectors?
11101117
} else {
1111-
mismatch = !withinAbsoluteTolerance(s1, s2, tolerance) || //
1112-
!withinAbsoluteTolerance(v1[0], v2[0], tolerance) || //
1113-
!withinAbsoluteTolerance(v1[1], v2[1], tolerance) || //
1114-
!withinAbsoluteTolerance(v1[2], v2[2], tolerance); //
1118+
mismatch = !m_compare(s1, s2) || //
1119+
!m_compare(v1[0], v2[0]) || //
1120+
!m_compare(v1[1], v2[1]) || //
1121+
!m_compare(v1[2], v2[2]); //
11151122
}
11161123
if (mismatch) {
11171124
g_log.notice(name);
@@ -1218,6 +1225,9 @@ void CompareWorkspaces::doLeanElasticPeaksComparison(const LeanElasticPeaksWorks
12181225
}
12191226
bool mismatch = false;
12201227
// Q: why does it not perform the user-specified operation for QLab and QSample?
1228+
// if this is not necessary, then
1229+
// bool mismatch = !m_compare(s1, s2)
1230+
// can replace this if/else, and isRelErr and tolerance can be deleted
12211231
if (isRelErr && name != "QLab" && name != "QSample") {
12221232
if (!withinRelativeTolerance(s1, s2, tolerance)) {
12231233
mismatch = true;
@@ -1274,7 +1284,7 @@ void CompareWorkspaces::doTableComparison(const API::ITableWorkspace_const_sptr
12741284
const bool checkAllData = getProperty("CheckAllData");
12751285
const bool isRelErr = getProperty("ToleranceRelErr");
12761286
const double tolerance = getProperty("Tolerance");
1277-
bool mismatch = false;
1287+
bool mismatch;
12781288
for (size_t i = 0; i < numCols; ++i) {
12791289
const auto c1 = tws1->getColumn(i);
12801290
const auto c2 = tws2->getColumn(i);
@@ -1351,7 +1361,7 @@ this error is within the limits requested.
13511361
*/
13521362
bool CompareWorkspaces::withinAbsoluteTolerance(double const x1, double const x2, double const atol) {
13531363
// NOTE !(|x1-x2| > atol) is not the same as |x1-x2| <= atol
1354-
return !(std::fabs(x1 - x2) > atol);
1364+
return !(std::abs(x1 - x2) > atol);
13551365
}
13561366

13571367
//------------------------------------------------------------------------------------------------
@@ -1367,12 +1377,17 @@ this error is within the limits requested.
13671377
*/
13681378
bool CompareWorkspaces::withinRelativeTolerance(double const x1, double const x2, double const rtol) {
13691379
// calculate difference
1370-
double const num = std::fabs(x1 - x2);
1380+
double const num = std::abs(x1 - x2);
13711381
// return early if the values are equal
13721382
if (num == 0.0)
13731383
return true;
1374-
// compare the difference to the midpoint value -- could lead to issues for negative values
1375-
double const den = 0.5 * std::fabs(x1 + x2);
1384+
// create the average magnitude for comparison
1385+
double const den = 0.5 * (std::abs(x1) + std::abs(x2));
1386+
// return early, possibly avoids a multiplication
1387+
// NOTE if den<1, then divsion will only make num larger
1388+
// NOTE if den<1 but num<=rtol, we cannot conclude anything
1389+
if (den <= 1.0 && num > rtol)
1390+
return false;
13761391
// NOTE !(num > rtol*den) is not the same as (num <= rtol*den)
13771392
return !(num > (rtol * den));
13781393
}

‎Framework/Algorithms/test/CompareWorkspacesTest.h‎

Lines changed: 152 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -38,16 +38,19 @@ using namespace Mantid::Geometry;
3838
using Mantid::MantidVec;
3939
using Mantid::Kernel::V3D;
4040

41+
namespace {
42+
std::string const PROPERTY_VALUE_TRUE("1");
43+
std::string const PROPERTY_VALUE_FALSE("0");
44+
} // namespace
45+
4146
class CompareWorkspacesTest : public CxxTest::TestSuite {
4247
public:
4348
// This pair of boilerplate methods prevent the suite being created statically
4449
// This means the constructor isn't called when running other tests
4550
static CompareWorkspacesTest *createSuite() { return new CompareWorkspacesTest(); }
4651
static void destroySuite(CompareWorkspacesTest *suite) { delete suite; }
4752

48-
CompareWorkspacesTest() : ws1(WorkspaceCreationHelper::create2DWorkspace123(2, 2)), PROPERTY_VALUE_TRUE("1") {
49-
FrameworkManager::Instance();
50-
}
53+
CompareWorkspacesTest() : ws1(WorkspaceCreationHelper::create2DWorkspace123(2, 2)) { FrameworkManager::Instance(); }
5154

5255
void testName() { TS_ASSERT_EQUALS(checker.name(), "CompareWorkspaces"); }
5356

@@ -73,6 +76,146 @@ class CompareWorkspacesTest : public CxxTest::TestSuite {
7376
TS_ASSERT(Mantid::API::equals(ws, ws));
7477
}
7578

79+
void testNotMatches() {
80+
if (!checker.isInitialized())
81+
checker.initialize();
82+
83+
WorkspaceSingleValue_sptr ws1 = WorkspaceCreationHelper::createWorkspaceSingleValue(1.0);
84+
WorkspaceSingleValue_sptr ws2 = WorkspaceCreationHelper::createWorkspaceSingleValue(2.0);
85+
//
86+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace1", ws1));
87+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace2", ws2));
88+
89+
TS_ASSERT(checker.execute());
90+
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_FALSE);
91+
// Same, using the Mantid::API::equals() function
92+
TS_ASSERT(!Mantid::API::equals(ws1, ws2));
93+
// cleanup
94+
checker.resetProperties();
95+
}
96+
97+
void testMatchesRelative_large() {
98+
if (!checker.isInitialized())
99+
checker.initialize();
100+
101+
WorkspaceSingleValue_sptr wks1 = WorkspaceCreationHelper::createWorkspaceSingleValue(100000.0);
102+
WorkspaceSingleValue_sptr wks2 = WorkspaceCreationHelper::createWorkspaceSingleValue(100001.0);
103+
104+
// Ensure they are NOT equal within absolute tolerance
105+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace1", wks1));
106+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace2", wks2));
107+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Tolerance", 0.01));
108+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("ToleranceRelErr", false));
109+
TS_ASSERT_THROWS_NOTHING(checker.execute());
110+
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_FALSE);
111+
// Ensure they ARE equal within relative tolerance
112+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace1", wks1));
113+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace2", wks2));
114+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Tolerance", 0.01));
115+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("ToleranceRelErr", true));
116+
TS_ASSERT_THROWS_NOTHING(checker.execute());
117+
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_TRUE);
118+
}
119+
120+
void testMatchesRelative_small() {
121+
if (!checker.isInitialized())
122+
checker.initialize();
123+
124+
WorkspaceSingleValue_sptr ws1 = WorkspaceCreationHelper::createWorkspaceSingleValue(0.000001);
125+
WorkspaceSingleValue_sptr ws2 = WorkspaceCreationHelper::createWorkspaceSingleValue(0.000002);
126+
WorkspaceSingleValue_sptr ws3 = WorkspaceCreationHelper::createWorkspaceSingleValue(0.00000201);
127+
128+
// Ensure ws1, ws2 ARE equal within absolute tolerance
129+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace1", ws1));
130+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace2", ws2));
131+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Tolerance", 0.1));
132+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("ToleranceRelErr", false));
133+
TS_ASSERT_THROWS_NOTHING(checker.execute());
134+
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_TRUE);
135+
// Ensure ws1, ws2 ARE NOT equal within relative tolerance
136+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace1", ws1));
137+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace2", ws2));
138+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Tolerance", 0.1));
139+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("ToleranceRelErr", true));
140+
TS_ASSERT_THROWS_NOTHING(checker.execute());
141+
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_FALSE);
142+
// Ensure ws2, ws3 ARE equal within absolute tolerance
143+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace1", ws2));
144+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace2", ws3));
145+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Tolerance", 0.1));
146+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("ToleranceRelErr", false));
147+
TS_ASSERT_THROWS_NOTHING(checker.execute());
148+
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_TRUE);
149+
// Ensure ws2, ws3 ARE equal within relative tolerance
150+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace1", ws2));
151+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace2", ws3));
152+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Tolerance", 0.1));
153+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("ToleranceRelErr", true));
154+
TS_ASSERT_THROWS_NOTHING(checker.execute());
155+
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_TRUE);
156+
// cleanup
157+
checker.resetProperties();
158+
}
159+
160+
void testNotMatchesRelative() {
161+
if (!checker.isInitialized())
162+
checker.initialize();
163+
164+
WorkspaceSingleValue_sptr ws1 = WorkspaceCreationHelper::createWorkspaceSingleValue(1.1);
165+
WorkspaceSingleValue_sptr ws2 = WorkspaceCreationHelper::createWorkspaceSingleValue(2.2);
166+
//
167+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace1", ws1));
168+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace2", ws2));
169+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Tolerance", 0.1));
170+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("ToleranceRelErr", true));
171+
//
172+
TS_ASSERT_THROWS_NOTHING(checker.execute());
173+
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_FALSE);
174+
// cleanup
175+
checker.resetProperties();
176+
}
177+
178+
void testCheckErrorMatches() {
179+
if (!checker.isInitialized())
180+
checker.initialize();
181+
182+
WorkspaceSingleValue_sptr ws1 = WorkspaceCreationHelper::createWorkspaceSingleValueWithError(1.1, 2.0);
183+
WorkspaceSingleValue_sptr ws2 = WorkspaceCreationHelper::createWorkspaceSingleValueWithError(1.1, 2.0);
184+
//
185+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("CheckUncertainty", true));
186+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace1", ws1));
187+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace2", ws2));
188+
//
189+
TS_ASSERT(checker.execute());
190+
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_TRUE);
191+
// Same, using the Mantid::API::equals() function
192+
TS_ASSERT(Mantid::API::equals(ws1, ws2));
193+
// cleanup
194+
checker.resetProperties();
195+
}
196+
197+
void testCheckErrorNotMatches() {
198+
if (!checker.isInitialized())
199+
checker.initialize();
200+
201+
WorkspaceSingleValue_sptr ws1 = WorkspaceCreationHelper::createWorkspaceSingleValueWithError(1.1, 2.0);
202+
WorkspaceSingleValue_sptr ws2 = WorkspaceCreationHelper::createWorkspaceSingleValueWithError(1.1, 4.0);
203+
// make sure ARE equal if errors NOT checked
204+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("CheckUncertainty", false));
205+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace1", ws1));
206+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace2", ws2));
207+
TS_ASSERT(checker.execute());
208+
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_TRUE);
209+
// make sure are NOT equal if errors ARE checked
210+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("CheckUncertainty", true));
211+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace1", ws1));
212+
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Workspace2", ws2));
213+
TS_ASSERT(checker.execute());
214+
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_FALSE);
215+
// cleanup
216+
checker.resetProperties();
217+
}
218+
76219
void testPeaks_matches() {
77220
if (!checker.isInitialized())
78221
checker.initialize();
@@ -165,6 +308,8 @@ class CompareWorkspacesTest : public CxxTest::TestSuite {
165308
TS_ASSERT_THROWS_NOTHING(checker.setProperty("ToleranceRelErr", true));
166309
TS_ASSERT(checker.execute());
167310
TS_ASSERT_EQUALS(checker.getPropertyValue("Result"), PROPERTY_VALUE_TRUE);
311+
// cleanup
312+
checker.resetProperties();
168313
}
169314

170315
void testPeaks_extrapeak() {
@@ -501,6 +646,8 @@ class CompareWorkspacesTest : public CxxTest::TestSuite {
501646
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Tolerance", 1.0e-5));
502647
TS_ASSERT(checker.execute());
503648
TS_ASSERT_DIFFERS(checker.getPropertyValue("Result"), PROPERTY_VALUE_TRUE);
649+
// cleanup
650+
checker.resetProperties();
504651
}
505652

506653
void testMDHist_different_error() {
@@ -513,6 +660,8 @@ class CompareWorkspacesTest : public CxxTest::TestSuite {
513660
TS_ASSERT_THROWS_NOTHING(checker.setProperty("Tolerance", 1.0e-5));
514661
TS_ASSERT(checker.execute());
515662
TS_ASSERT_DIFFERS(checker.getPropertyValue("Result"), PROPERTY_VALUE_TRUE);
663+
// cleanup
664+
checker.resetProperties();
516665
}
517666

518667
void testDifferentSize() {
@@ -1302,6 +1451,4 @@ class CompareWorkspacesTest : public CxxTest::TestSuite {
13021451
private:
13031452
Mantid::Algorithms::CompareWorkspaces checker;
13041453
const Mantid::API::MatrixWorkspace_sptr ws1;
1305-
1306-
const std::string PROPERTY_VALUE_TRUE;
13071454
};

‎buildconfig/CMake/CppCheck_Suppressions.txt.in‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1653,4 +1653,3 @@ returnByReference:${CMAKE_SOURCE_DIR}/qt/scientific_interfaces/Indirect/Reductio
16531653
returnByReference:${CMAKE_SOURCE_DIR}/qt/scientific_interfaces/Indirect/Reduction/ISISEnergyTransferData.h:193
16541654
returnByReference:${CMAKE_SOURCE_DIR}/qt/scientific_interfaces/Indirect/Reduction/ISISEnergyTransferData.h:199
16551655
returnByReference:${CMAKE_SOURCE_DIR}/qt/scientific_interfaces/Indirect/Reduction/ISISEnergyTransferData.h:218
1656-
unreadVariable:${CMAKE_SOURCE_DIR}/Framework/Algorithms/src/CompareWorkspaces.cpp:1277

‎docs/source/release/v6.11.0/Framework/Algorithms/New_features/37933.rst‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
- add flag "CheckUncertainty" to :ref:`CompareWorkspaces <algm-CompareWorkspaces>` to turn off comparing the y-value uncertainties.

0 commit comments

Comments
 (0)