Skip to content
Snippets Groups Projects
Commit 4d82c2d5 authored by Roman Tolchenov's avatar Roman Tolchenov
Browse files

Merge remote-tracking branch 'origin/feature/9765_Stitch1d_replace_python'

parents 3556ff35 b4436aa0
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/Stitch1D.h
+ 1
− 1
View file @ 4d82c2d5
......@@ -42,7 +42,7 @@ namespace Mantid
/// Algorithm's name for identification. @see Algorithm::name
virtual const std::string name() const {return "Stitch1D";}
/// Algorithm's version for identification. @see Algorithm::version
virtual int version() const {return 4;}
virtual int version() const {return 3;}
/// Algorithm's category for identification. @see Algorithm::category
virtual const std::string category() const {return "Reflectometry";}
///Summary of algorithm's purpose
......
Code/Mantid/Framework/PythonInterface/plugins/algorithms/Stitch1D.py deleted 100644 → 0
+ 0
− 217
View file @ 3556ff35
from mantid.simpleapi import *
from mantid.api import *
from mantid.kernel import *
import numpy as np
class Stitch1D(PythonAlgorithm):
def category(self):
return "Reflectometry\\ISIS;PythonAlgorithms"
def name(self):
return "Stitch1D"
def version(self):
return 3
def summary(self):
return "Stitches single histogram matrix workspaces together"
def PyInit(self):
histogram_validator = HistogramValidator()
self.declareProperty(MatrixWorkspaceProperty("LHSWorkspace", "", Direction.Input, validator=histogram_validator), "Input workspace")
self.declareProperty(MatrixWorkspaceProperty("RHSWorkspace", "", Direction.Input, validator=histogram_validator), "Input workspace")
self.declareProperty(MatrixWorkspaceProperty("OutputWorkspace", "", Direction.Output), "Output stitched workspace")
self.declareProperty(name="StartOverlap", defaultValue=-1.0, doc="Overlap x-value in units of x-axis. Optional.")
self.declareProperty(name="EndOverlap", defaultValue=-1.0, doc="End overlap x-value in units of x-value. Optional.")
self.declareProperty(FloatArrayProperty(name="Params", values=[0.1]), doc="Rebinning Parameters. See Rebin for format. If only a single value is provided, start and end are taken from input workspaces.")
self.declareProperty(name="ScaleRHSWorkspace", defaultValue=True, doc="Scaling either with respect to workspace 1 or workspace 2.")
self.declareProperty(name="UseManualScaleFactor", defaultValue=False, doc="True to use a provided value for the scale factor.")
self.declareProperty(name="ManualScaleFactor", defaultValue=1.0, doc="Provided value for the scale factor.")
self.declareProperty(name="OutScaleFactor", defaultValue=-2.0, direction = Direction.Output, doc="The actual used value for the scaling factor.")
def has_non_zero_errors(self, ws):
errors = ws.extractE()
count = len(errors.nonzero()[0])
return count > 0
def __run_as_child(self, name, **kwargs):
"""Run a named algorithm and return the
algorithm handle
Parameters:
name - The name of the algorithm
kwargs - A dictionary of property name:value pairs
"""
alg = AlgorithmManager.createUnmanaged(name)
alg.initialize()
alg.setChild(True)
if 'OutputWorkspace' in alg:
alg.setPropertyValue("OutputWorkspace","UNUSED_NAME_FOR_CHILD")
alg.setRethrows(True)
for key, value in kwargs.iteritems():
alg.setProperty(key, value)
alg.execute()
return alg.getProperty("OutputWorkspace").value
def __to_single_value_ws(self, value):
value_ws = self.__run_as_child("CreateSingleValuedWorkspace", DataValue=value)
return value_ws
def __find_indexes_start_end(self, startOverlap, endOverlap, workspace):
a1=workspace.binIndexOf(startOverlap)
a2=workspace.binIndexOf(endOverlap)
if a1 == a2:
raise RuntimeError("The Params you have provided for binning yield a workspace in which start and end overlap appear in the same bin. Make binning finer via input Params.")
return a1, a2
def __calculate_x_intersection(self):
lhs_ws = self.getProperty("LHSWorkspace").value
rhs_ws = self.getProperty("RHSWorkspace").value
lhs_x = lhs_ws.readX(0)
rhs_x = rhs_ws.readX(0)
return rhs_x[0], lhs_x[-1]
def __get_start_overlap(self, range_tolerance):
start_overlap_property = self.getProperty('StartOverlap')
start_overlap = start_overlap_property.value - range_tolerance
min, max = self.__calculate_x_intersection()
start_overlap_beyond_range = (start_overlap < min) or (start_overlap > max)
if start_overlap_property.isDefault or start_overlap_beyond_range:
if start_overlap_beyond_range and not start_overlap_property.isDefault:
logger.warning("StartOverlap is outside range at %0.4f, Min is %0.4f, Max is %0.4f . Forced to be: %0.4f" % (start_overlap, min, max, min))
start_overlap = min
logger.information("StartOverlap calculated to be: %0.4f" % start_overlap)
return start_overlap
def __get_end_overlap(self, range_tolerance):
end_overlap_property = self.getProperty('EndOverlap')
end_overlap = end_overlap_property.value + range_tolerance
min, max = self.__calculate_x_intersection()
end_overlap_beyond_range = (end_overlap < min) or (end_overlap > max)
if end_overlap_property.isDefault or end_overlap_beyond_range:
if end_overlap_beyond_range and not end_overlap_property.isDefault:
logger.warning("EndOverlap is outside range at %0.4f, Min is %0.4f, Max is %0.4f. Forced to be: %0.4f" % (end_overlap, min, max, max))
end_overlap = max
logger.information("EndOverlap calculated to be: %0.4f" % end_overlap)
return end_overlap
'''
Fetch and create rebin parameters.
If a single step is provided, then the min and max values are taken from the input workspaces.
'''
def __create_rebin_parameters(self):
params = None
user_params = self.getProperty("Params").value
if user_params.size >= 3:
params = user_params
else:
lhs_ws = self.getProperty("LHSWorkspace").value
rhs_ws = self.getProperty("RHSWorkspace").value
params = list()
params.append(np.min(lhs_ws.readX(0)))
params.append(user_params[0])
params.append(np.max(rhs_ws.readX(0)))
return params
def PyExec(self):
# Just forward the other properties on.
range_tolerance = 1e-9
startOverlap = self.__get_start_overlap(range_tolerance)
endOverlap = self.__get_end_overlap(range_tolerance)
scaleRHSWorkspace = self.getProperty('ScaleRHSWorkspace').value
useManualScaleFactor = self.getProperty('UseManualScaleFactor').value
manualScaleFactor = self.getProperty('ManualScaleFactor').value
outScaleFactor = self.getProperty('OutScaleFactor').value
params = self.__create_rebin_parameters()
lhs_rebinned = self.__run_as_child("Rebin", InputWorkspace=self.getProperty("LHSWorkspace").value, Params=params)
rhs_rebinned = self.__run_as_child("Rebin", InputWorkspace=self.getProperty("RHSWorkspace").value, Params=params)
xRange = lhs_rebinned.readX(0)
minX = xRange[0]
maxX = xRange[-1]
if(round(startOverlap, 9) < round(minX, 9)):
raise RuntimeError("Stitch1D StartOverlap is outside the X range after rebinning. StartOverlap: %0.9f, X min: %0.9f" % (startOverlap, minX))
if(round(endOverlap, 9) > round(maxX, 9)):
raise RuntimeError("Stitch1D EndOverlap is outside the X range after rebinning. EndOverlap: %0.9f, X max: %0.9f" % (endOverlap, maxX))
if(startOverlap > endOverlap):
raise RuntimeError("Stitch1D cannot have a StartOverlap > EndOverlap. StartOverlap: %0.9f, EndOverlap: %0.9f" % (startOverlap, endOverlap))
a1, a2 = self.__find_indexes_start_end(startOverlap, endOverlap, lhs_rebinned)
if not useManualScaleFactor:
lhsOverlapIntegrated = self.__run_as_child("Integration", InputWorkspace=lhs_rebinned, RangeLower=startOverlap, RangeUpper=endOverlap)
rhsOverlapIntegrated = self.__run_as_child("Integration", InputWorkspace=rhs_rebinned, RangeLower=startOverlap, RangeUpper=endOverlap)
y1=lhsOverlapIntegrated.readY(0)
y2=rhsOverlapIntegrated.readY(0)
if scaleRHSWorkspace:
ratio = self.__run_as_child("Divide", LHSWorkspace=lhsOverlapIntegrated, RHSWorkspace=rhsOverlapIntegrated)
rhs_rebinned = self.__run_as_child("Multiply", LHSWorkspace=rhs_rebinned, RHSWorkspace=ratio)
scalefactor = y1[0]/y2[0]
else:
ratio = self.__run_as_child("Divide", RHSWorkspace=lhsOverlapIntegrated, LHSWorkspace=rhsOverlapIntegrated)
lhs_rebinned = self.__run_as_child("Multiply", LHSWorkspace=lhs_rebinned, RHSWorkspace=ratio)
scalefactor = y2[0]/y1[0]
else:
manualScaleFactorWS = self.__to_single_value_ws(manualScaleFactor)
if scaleRHSWorkspace:
rhs_rebinned = self.__run_as_child("Multiply", LHSWorkspace=rhs_rebinned, RHSWorkspace=manualScaleFactorWS)
else:
lhs_rebinned = self.__run_as_child("Multiply", LHSWorkspace=lhs_rebinned, RHSWorkspace=manualScaleFactorWS)
scalefactor = manualScaleFactor
# Mask out everything BUT the overlap region as a new workspace.
overlap1 = self.__run_as_child("MultiplyRange", InputWorkspace=lhs_rebinned, StartBin=0,EndBin=a1,Factor=0)
overlap1 = self.__run_as_child("MultiplyRange", InputWorkspace=overlap1,StartBin=a2,Factor=0)
# Mask out everything BUT the overlap region as a new workspace.
overlap2 = self.__run_as_child("MultiplyRange", InputWorkspace=rhs_rebinned,StartBin=0,EndBin=a1,Factor=0)
overlap2 = self.__run_as_child("MultiplyRange", InputWorkspace=overlap2,StartBin=a2,Factor=0)
# Mask out everything AFTER the start of the overlap region
lhs_rebinned = self.__run_as_child("MultiplyRange", InputWorkspace=lhs_rebinned, StartBin=a1+1, Factor=0)
# Mask out everything BEFORE the end of the overlap region
rhs_rebinned = self.__run_as_child("MultiplyRange",InputWorkspace=rhs_rebinned,StartBin=0,EndBin=a2-1,Factor=0)
# Calculate a weighted mean for the overlap region
overlapave = None
if self.has_non_zero_errors(overlap1) and self.has_non_zero_errors(overlap2):
overlapave = self.__run_as_child("WeightedMean", InputWorkspace1=overlap1,InputWorkspace2=overlap2)
else:
self.log().information("Using un-weighted mean for Stitch1D overlap mean")
# Calculate the mean.
sum = self.__run_as_child("Plus", LHSWorkspace=overlap1, RHSWorkspace=overlap2)
denominator = self.__to_single_value_ws(2.0)
overlapave = self.__run_as_child("Divide", LHSWorkspace=sum, RHSWorkspace=denominator)
# Add the Three masked workspaces together to create a complete x-range
result = self.__run_as_child("Plus", LHSWorkspace=lhs_rebinned, RHSWorkspace=overlapave)
result = self.__run_as_child("Plus", LHSWorkspace=rhs_rebinned, RHSWorkspace=result)
#RenameWorkspace(InputWorkspace=result, OutputWorkspace=self.getPropertyValue("OutputWorkspace"))
self.setProperty('OutputWorkspace', result)
self.setProperty('OutScaleFactor', scalefactor)
return None
#############################################################################################
AlgorithmFactory.subscribe(Stitch1D())
Code/Mantid/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt
+ 0
− 1
View file @ 4d82c2d5
......@@ -31,7 +31,6 @@ set ( TEST_PY_FILES
SavePlot1DTest.py
SortDetectorsTest.py
SortXAxisTest.py
Stitch1DTest.py
Stitch1DManyTest.py
SuggestTibCNCSTest.py
SuggestTibHYSPECTest.py
......
Code/Mantid/Framework/PythonInterface/test/python/plugins/algorithms/Stitch1DTest.py deleted 100644 → 0
+ 0
− 242
View file @ 3556ff35
import unittest
import numpy
from mantid.simpleapi import *
from mantid.kernel import *
from mantid.api import *
class Stitch1DTest(unittest.TestCase):
a = None
b = None
x = None
e = None
def setUp(self):
x = numpy.arange(-1, 1.2, 0.2)
e = numpy.arange(-1, 1, 0.2)
e.fill(0)
self.e = e
self.x = x
a = CreateWorkspace(UnitX="1/q", DataX=x, DataY=[0,0,0,3,3,3,3,3,3,3], NSpec=1, DataE=e)
b = CreateWorkspace(UnitX="1/q", DataX=x, DataY=[2,2,2,2,2,2,2,0,0,0], NSpec=1, DataE=e)
self.a = a
self.b = b
def tearDown(self):
# Cleanup
DeleteWorkspace(self.a)
DeleteWorkspace(self.b)
def test_startoverap_greater_than_end_overlap_throws(self):
try:
stitched = Stitch1D(LHSWorkspace=self.b, RHSWorkspace=self.a, StartOverlap=self.x[-1], EndOverlap=self.x[0], Params='0.2')
self.assertTrue(False, "Should have thrown with StartOverlap < x max")
except RuntimeError:
pass
def test_lhsworkspace_must_be_histogram(self):
x = numpy.arange(-1, 1, 0.2)
e = numpy.arange(-1, 1, 0.2)
lhs_ws = CreateWorkspace(UnitX="1/q", DataX=x, DataY=[0,0,0,3,3,3,3,3,3,3], NSpec=1, DataE=e)
self.assertTrue(not lhs_ws.isHistogramData(), "Input LHS WS SHOULD NOT be histogram for this test")
self.assertTrue(self.a.isHistogramData(), "Input RHS WS should SHOULD be histogram for this test")
try:
stitched = Stitch1D(LHSWorkspace=lhs_ws, RHSWorkspace=self.a, StartOverlap=self.x[-1], EndOverlap=self.x[0], Params='0.2')
except ValueError:
pass
finally:
DeleteWorkspace(lhs_ws)
def test_rhsworkspace_must_be_histogram(self):
x = numpy.arange(-1, 1, 0.2)
e = numpy.arange(-1, 1, 0.2)
rhs_ws = CreateWorkspace(UnitX="1/q", DataX=x, DataY=[0,0,0,3,3,3,3,3,3,3], NSpec=1, DataE=e)
self.assertTrue(self.a.isHistogramData(), "Input LHS WS SHOULD be histogram for this test")
self.assertTrue(not rhs_ws.isHistogramData(), "Input RHS WS should SHOULD NOT be histogram for this test")
try:
stitched = Stitch1D(LHSWorkspace=self.a, RHSWorkspace=rhs_ws, StartOverlap=self.x[-1], EndOverlap=self.x[0], Params='0.2')
except ValueError:
pass
finally:
DeleteWorkspace(rhs_ws)
def test_stitching_uses_suppiled_params(self):
stitched, scale = Stitch1D(LHSWorkspace=self.b, RHSWorkspace=self.a, StartOverlap=-0.4, EndOverlap=0.4, Params='-0.8, 0.2, 1')
#Check the ranges on the output workspace against the param inputs.
out_x_values = stitched.readX(0)
x_min = numpy.min(out_x_values)
x_max = numpy.max(out_x_values)
self.assertEqual(x_min, -0.8)
self.assertEqual(x_max, 1)
DeleteWorkspace(stitched)
def test_stitching_determines_params(self):
x1 = numpy.arange(-1, 1, 0.2)
x2 = numpy.arange(0.4, 1.6, 0.2)
ws1 = CreateWorkspace(UnitX="1/q", DataX=x1, DataY=[1,1,1,1,1,1,1,1,1], NSpec=1)
ws2 = CreateWorkspace(UnitX="1/q", DataX=x2, DataY=[1,1,1,1,1,1], NSpec=1)
demanded_step_size = 0.2
stitched, scale = Stitch1D(LHSWorkspace=ws1, RHSWorkspace=ws2, StartOverlap=0.4, EndOverlap=1.0, Params=demanded_step_size)
#Check the ranges on the output workspace against the param inputs.
out_x_values = stitched.readX(0)
x_min = numpy.min(out_x_values)
x_max = numpy.max(out_x_values)
step_size = out_x_values[1] - out_x_values[0]
self.assertEqual(x_min, -1)
self.assertAlmostEqual(x_max-demanded_step_size, 1.4, places=6)
self.assertAlmostEqual(step_size, demanded_step_size, places=6)
DeleteWorkspace(stitched)
DeleteWorkspace(ws1)
DeleteWorkspace(ws2)
def test_stitching_determines_start_and_end_overlap(self):
x1 = numpy.arange(-1, 0.6, 0.2) # Produces x from -1 to 0.4 in steps of 0.2
x2 = numpy.arange(-0.4, 1.2, 0.2) # Produces x from -0.4 to 1 in steps of 0.2
ws1 = CreateWorkspace(UnitX="1/q", DataX=x1, DataY=[1,1,1,3,3,3,3], NSpec=1)
ws2 = CreateWorkspace(UnitX="1/q", DataX=x2, DataY=[1,1,1,1,3,3,3], NSpec=1)
stitched, scale = Stitch1D(LHSWorkspace=ws1, RHSWorkspace=ws2, Params=[-1, 0.2, 1]
)
stitched_y = stitched.readY(0)
stitched_x = stitched.readX(0)
overlap_indexes = numpy.where((stitched_y >= 1.0009) & (stitched_y <= 3.0001))[0]
start_overlap_determined = stitched_x[overlap_indexes[0]]
end_overlap_determined = stitched_x[overlap_indexes[-1]]
print start_overlap_determined, end_overlap_determined
self.assertAlmostEqual(start_overlap_determined, -0.4, places=9)
self.assertAlmostEqual(end_overlap_determined, 0.2, places=9)
def test_stitching_forces_start_overlap(self):
x1 = numpy.arange(-1, 0.6, 0.2) # Produces x from -1 to 0.4 in steps of 0.2
x2 = numpy.arange(-0.4, 1.2, 0.2) # Produces x from -0.4 to 1 in steps of 0.2
ws1 = CreateWorkspace(UnitX="1/q", DataX=x1, DataY=[1,1,1,3,3,3,3], NSpec=1)
ws2 = CreateWorkspace(UnitX="1/q", DataX=x2, DataY=[1,1,1,1,3,3,3], NSpec=1)
# Overlap region is only physically between -0.4 and 0.4
stitched, scale = Stitch1D(LHSWorkspace=ws1, RHSWorkspace=ws2, Params=[-1, 0.2, 1], StartOverlap=-0.5) # Start overlap is out of range!!
stitched_y = stitched.readY(0)
stitched_x = stitched.readX(0)
overlap_indexes = numpy.where((stitched_y >= 1.0009) & (stitched_y <= 3.0001))[0]
start_overlap_determined = stitched_x[overlap_indexes[0]]
end_overlap_determined = stitched_x[overlap_indexes[-1]]
print start_overlap_determined, end_overlap_determined
self.assertAlmostEqual(start_overlap_determined, -0.4, places=9)
self.assertAlmostEqual(end_overlap_determined, 0.2, places=9)
def test_stitching_forces_end_overlap(self):
x1 = numpy.arange(-1, 0.6, 0.2) # Produces x from -1 to 0.4 in steps of 0.2
x2 = numpy.arange(-0.4, 1.2, 0.2) # Produces x from -0.4 to 1 in steps of 0.2
ws1 = CreateWorkspace(UnitX="1/q", DataX=x1, DataY=[1,1,1,3,3,3,3], NSpec=1)
ws2 = CreateWorkspace(UnitX="1/q", DataX=x2, DataY=[1,1,1,1,3,3,3], NSpec=1)
# Overlap region is only physically between -0.4 and 0.4
stitched, scale = Stitch1D(LHSWorkspace=ws1, RHSWorkspace=ws2, Params=[-1, 0.2, 1], EndOverlap=0.5) # End overlap is out of range!!
stitched_y = stitched.readY(0)
stitched_x = stitched.readX(0)
overlap_indexes = numpy.where((stitched_y >= 1.0009) & (stitched_y <= 3.0001))[0]
start_overlap_determined = stitched_x[overlap_indexes[0]]
end_overlap_determined = stitched_x[overlap_indexes[-1]]
print start_overlap_determined, end_overlap_determined
self.assertAlmostEqual(start_overlap_determined, -0.4, places=9)
self.assertAlmostEqual(end_overlap_determined, 0.2, places=9)
def test_stitching_scale_right(self):
stitched = Stitch1D(LHSWorkspace=self.b, RHSWorkspace=self.a, StartOverlap=-0.4, EndOverlap=0.4, Params='0.2')
# Check the types returned
self.assertTrue(isinstance(stitched, tuple), "Output should be a tuple containing OuputWorkspace as well as the scale factor")
self.assertTrue(isinstance(stitched[0], MatrixWorkspace))
# Check the scale factor
self.assertAlmostEquals(stitched[1], 2.0/3.0, places=9)
# Fetch the arrays from the output workspace
yValues = numpy.around(stitched[0].readY(0), decimals=6)
eValues = numpy.around(stitched[0].readE(0), decimals=6)
xValues = numpy.around(stitched[0].readX(0), decimals=6)
# Check that the output Y-Values are correct.
self.assertEquals(1, len(numpy.unique(yValues)), "Output YVaues should all be 2")
self.assertEquals(2, yValues[0], "Output YValues should all be 2")
# Check that the output E-Values are correct.
self.assertEquals(0, len(eValues.nonzero()[0]), "Output Error values should all be non-zero")
# Check that the output X-Values are correct.
self.assertEquals(set(numpy.around(self.x, decimals=6)), set(xValues))
DeleteWorkspace(stitched[0])
def test_stitching_scale_left(self):
stitched = Stitch1D(LHSWorkspace=self.b, RHSWorkspace=self.a, StartOverlap=-0.4, EndOverlap=0.4, Params='0.2', ScaleRHSWorkspace=False)
# Check the types returned
self.assertTrue(isinstance(stitched, tuple), "Output should be a tuple containing OuputWorkspace as well as the scale factor")
self.assertTrue(isinstance(stitched[0], MatrixWorkspace))
# Check the scale factor
self.assertAlmostEquals(stitched[1], 3.0/2.0, places=9)
# Fetch the arrays from the output workspace
yValues = numpy.around(stitched[0].readY(0), decimals=6)
eValues = numpy.around(stitched[0].readE(0), decimals=6)
xValues = numpy.around(stitched[0].readX(0), decimals=6)
# Check that the output Y-Values are correct.
self.assertEquals(1, len(numpy.unique(yValues)), "Output YVaues should all be 2")
self.assertEquals(3, yValues[0], "Output YValues should all be 3")
# Check that the output E-Values are correct.
self.assertEquals(0, len(eValues.nonzero()[0]), "Output Error values should all be non-zero")
# Check that the output X-Values are correct.
self.assertEquals(set(numpy.around(self.x, decimals=6)), set(xValues))
DeleteWorkspace(stitched[0])
def test_stitching_manual_scale_factor_scale_right(self):
stitched = Stitch1D(LHSWorkspace=self.b, RHSWorkspace=self.a, ScaleRHSWorkspace=True, UseManualScaleFactor=True, StartOverlap=-0.4, EndOverlap=0.4, Params='0.2', ManualScaleFactor=2.0/3.0)
self.assertAlmostEquals(stitched[1], 2.0/3.0, places=9)
# Fetch the arrays from the output workspace
yValues = numpy.around(stitched[0].readY(0), decimals=6)
eValues = numpy.around(stitched[0].readE(0), decimals=6)
xValues = numpy.around(stitched[0].readX(0), decimals=6)
# Check that the output Y-Values are correct.
self.assertEquals(1, len(numpy.unique(yValues)), "Output YVaues should all be 2")
self.assertEquals(2, yValues[0], "Output YValues should all be 2")
# Check that the output E-Values are correct.
self.assertEquals(0, len(eValues.nonzero()[0]), "Output Error values should all be non-zero")
# Check that the output X-Values are correct.
self.assertEquals(set(numpy.around(self.x, decimals=6)), set(xValues))
DeleteWorkspace(stitched[0])
def test_stitching_manual_scale_factor_scale_left(self):
stitched = Stitch1D(LHSWorkspace=self.b, RHSWorkspace=self.a, StartOverlap=-0.4, EndOverlap=0.4, Params='0.2', ScaleRHSWorkspace=False, UseManualScaleFactor=True, ManualScaleFactor=3.0/2.0)
self.assertAlmostEquals(stitched[1], 3.0/2.0, places=9)
# Fetch the arrays from the output workspace
yValues = numpy.around(stitched[0].readY(0), decimals=6)
eValues = numpy.around(stitched[0].readE(0), decimals=6)
xValues = numpy.around(stitched[0].readX(0), decimals=6)
# Check that the output Y-Values are correct.
self.assertEquals(1, len(numpy.unique(yValues)), "Output YVaues should all be 2")
self.assertEquals(3, yValues[0], "Output YValues should all be 3")
# Check that the output E-Values are correct.
self.assertEquals(0, len(eValues.nonzero()[0]), "Output Error values should all be non-zero")
# Check that the output X-Values are correct.
self.assertEquals(set(numpy.around(self.x, decimals=6)), set(xValues))
DeleteWorkspace(stitched[0])
if __name__ == '__main__':
unittest.main()
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