def test_reactor_sans_resolution(self):
ReactorSANSResolution(InputWorkspace=self.test_ws, OutputWorkspace=self.test_ws)
self.assertAlmostEqual(mantid[self.test_ws].dataDx(0)[0], 0.0052567, 4)
self.assertAlmostEqual(mantid[self.test_ws].dataDx(0)[1], 0.0088109, 4)
self.assertAlmostEqual(mantid[self.test_ws].dataDx(0)[2], 0.0126872, 4)
if mtd.workspaceExists(self.test_ws):
mtd.deleteWorkspace(self.test_ws)
def test_reactor_sans_resolution(self):
ReactorSANSResolution(InputWorkspace=self.test_ws, OutputWorkspace=self.test_ws)
self.assertAlmostEqual(mantid[self.test_ws].dataDx(0)[0], 0.0453773, 4)
self.assertAlmostEqual(mantid[self.test_ws].dataDx(0)[1], 0.0840184, 4)
self.assertAlmostEqual(mantid[self.test_ws].dataDx(0)[2], 0.124066, 4)
if mtd.workspaceExists(self.test_ws):
mtd.deleteWorkspace(self.test_ws)
def test_child_alg_variation(self):
"""
Call signature variation for Child Algorithm execution
"""
algm = DummyAlg2()
algm.initialize()
algm.setPropertyValue("OutputWorkspace", "ChildAlgtest2")
algm.setRethrows(True)
algm.execute()
self.assertTrue(mtd.workspaceExists("ChildAlgtest2"))
mtd.deleteWorkspace("ChildAlgtest2")
def test_child_alg_wksp_transfer(self):
"""
Check that we can execute a Child Algorithm and pass
ownership of an output workspace to the parent algo.
"""
algm = DummyAlg2()
algm.initialize()
algm.setPropertyValue("OutputWorkspace", "ChildAlgtest")
algm.setRethrows(True)
algm.execute()
self.assertTrue(mtd.workspaceExists("ChildAlgtest"))
mtd.deleteWorkspace("ChildAlgtest")
def test_parameter_variation(self):
"""
Similar to previous test, but the algo function is passed as a string
"""
r = Reducer()
r.append_step("LoadAscii", "AsciiExample.txt", None)
for item in r._reduction_steps:
result = item.execute(r, "test2")
# Check that the workspace was created
self.assertNotEqual(mtd["test2"], None)
mtd.deleteWorkspace("test2")
def test_python_alg_property_using_python_alg(self):
"""
Declare, set and get an algorithm property from a python algorithm
"""
algm_par = DummyAlg2()
algm_par.initialize()
algm = DummyAlg()
algm.initialize()
algm.setPropertyValue("OutputWorkspace", "ChildAlgtest")
algm._setAlgorithmProperty("Algo", algm_par)
algm.execute()
self.assertEqual(str(algm._getAlgorithmProperty("Algo")), "DummyAlg2.1()")
self.assertTrue(mtd.workspaceExists("ChildAlgtest"))
mtd.deleteWorkspace("ChildAlgtest")
def test_pars_variation(self):
"""
Variations for parameter specification
"""
r = Reducer()
# An algorithm with a mandatory property that is NOT InputWorkspace or OutputWorkspace
r.append_step(LoadAscii, Filename="AsciiExample.txt", OutputWorkspace=None)
# Algorithm with InputWorkspace and OutputWorkspace
r.append_step(ConvertToHistogram, None, None)
for item in r._reduction_steps:
result = item.execute(r, "test2")
# Check that the workspace was created
self.assertNotEqual(mtd["test2"], None)
mtd.deleteWorkspace("test2")
def test_append_step(self):
"""
Test that a Mantid algorithm function can be added to a Reducer object
"""
r = Reducer()
# An algorithm with a mandatory property that is NOT InputWorkspace or OutputWorkspace
r.append_step(LoadAscii, "AsciiExample.txt", None)
# Algorithm with InputWorkspace and OutputWorkspace
r.append_step(ConvertToHistogram, None, None)
for item in r._reduction_steps:
result = item.execute(r, "test2")
# Check that the workspace was created
self.assertNotEqual(mtd["test2"], None)
mtd.deleteWorkspace("test2")
def setUp(self):
self.test_ws = "sans_workflow_ws"
if mtd.workspaceExists(self.test_ws):
mtd.deleteWorkspace(self.test_ws)
CreateWorkspace(self.test_ws, DataX=[0.1,0.2,0.3], DataY=[1.0,1.0,1.0], DataE=[0.1,0.1,0.1], NSpec=1, UnitX="MomentumTransfer")
LoadInstrument(Filename="BIOSANS_Definition.xml", Workspace=self.test_ws)
mantid[self.test_ws].getRun().addProperty_dbl("wavelength", 6.0, True)
mantid[self.test_ws].getRun().addProperty_dbl("wavelength-spread", 0.1, True)
mantid[self.test_ws].getRun().addProperty_dbl("source-aperture-diameter", 40, True)
mantid[self.test_ws].getRun().addProperty_dbl("sample-aperture-diameter", 40, True)
mantid[self.test_ws].getRun().addProperty_dbl("source-sample-distance", 11000, True)
mantid[self.test_ws].getRun().addProperty_dbl("sample_detector_distance", 6000, True)
self.assertEqual(mantid[self.test_ws].dataDx(0)[0], 0)
self.assertEqual(mantid[self.test_ws].dataDx(0)[1], 0)
self.assertEqual(mantid[self.test_ws].dataDx(0)[2], 0)
def test_cpp_alg_property_using_python_alg(self):
"""
Declare, set and get a C++ algorithm from a python algorithm
"""
algm_par = mtd._createAlgProxy("CreateWorkspace")
algm_par.setPropertyValues(OutputWorkspace="test", DataX=1, DataY=1, DataE=1)
algm_par.initialize()
algm = DummyAlg()
algm.initialize()
algm.setPropertyValue("OutputWorkspace", "ChildAlgtest")
algm._setAlgorithmProperty("Algo", algm_par._getHeldObject())
algm.execute()
self.assertEqual(str(algm._getAlgorithmProperty("Algo")),
"CreateWorkspace.1(OutputWorkspace=test,DataX=1,DataY=1,DataE=1)")
self.assertTrue(mtd.workspaceExists("ChildAlgtest"))
mtd.deleteWorkspace("ChildAlgtest")
def test_algp_property_using_public_API(self):
"""
Declare, set and get an algorithm property from a python algorithm
using the public API. Only works if the algorithm owning the AlgorithmProperty
is a PythonAlgorithm.
"""
algm_par = mtd._createAlgProxy("CreateWorkspace")
algm_par.setPropertyValues(OutputWorkspace="test", DataX=1, DataY=1, DataE=1)
algm_par.initialize()
algm = DummyAlg()
algm.initialize()
algm.setPropertyValue("OutputWorkspace", "ChildAlgtest")
algm.setProperty("Algo", algm_par._getHeldObject())
algm.execute()
self.assertEqual(str(algm._getAlgorithmProperty("Algo")),
"CreateWorkspace.1(OutputWorkspace=test,DataX=1,DataY=1,DataE=1)")
self.assertTrue(mtd.workspaceExists("ChildAlgtest"))
mtd.deleteWorkspace("ChildAlgtest")
def test_output_wksp(self):
"""
Similar to previous test, but we specify the output workspace
"""
r = Reducer()
# An algorithm with a mandatory property that is NOT InputWorkspace or OutputWorkspace
r.append_step(LoadAscii, "AsciiExample.txt", None)
# Algorithm with InputWorkspace and OutputWorkspace
r.append_step(ConvertToHistogram, None, None)
r._reduction_steps[0].execute(r, "test2")
r._reduction_steps[1].execute(r, "test2", "test3")
# Check that the workspace was created
self.assertNotEqual(mtd["test2"], None)
self.assertNotEqual(mtd["test3"], None)
mtd.deleteWorkspace("test2")
mtd.deleteWorkspace("test3")
def test_cpp_alg_property_using_python_alg_and_execute_the_propertied_algorithm(self):
"""
Declare, seta C++ algorithm from a python algorithm.
Then, in the "super" python algorithm, run the "sub" algorithm that
was passed as a parameter
"""
algm_par = mtd._createAlgProxy("CreateWorkspace")
algm_par.setPropertyValues(OutputWorkspace="test", DataX=1, DataY=1, DataE=1)
algm_par.initialize()
algm = DummyAlg3()
algm.initialize()
algm.setPropertyValue("OutputWorkspace", "ChildAlgtest")
algm._setAlgorithmProperty("Algo", algm_par._getHeldObject())
algm.execute()
# THe algorithm created the workspace name given in the PROPERTY ...
self.assertTrue(mtd.workspaceExists("test"))
mtd.deleteWorkspace("test")
# ... not the one given as a parameter of DummyAlg3, because that's not the way that algo was written
self.assertFalse(mtd.workspaceExists("ChildAlgtest"))
OutputWorkspace=weighted_MDEW,
LorentzCorrection='1',
OutputDimensions='Q (sample frame)',
SplitInto='2',
SplitThreshold='50',
MaxRecursionDepth='11')
#
# Find the requested number of peaks. Once the peaks are found, we no longer
# need the weighted MD event workspace, so delete it.
#
distance_threshold = 0.9 * 6.28 / float(max_d)
FindPeaksMD(InputWorkspace=weighted_MDEW,
MaxPeaks=num_peaks_to_find,
OutputWorkspace=peaks_ws,
PeakDistanceThreshold=distance_threshold)
mtd.deleteWorkspace(weighted_MDEW)
#
# Find a Niggli UB matrix that indexes the peaks in this run
#
FindUBUsingFFT(PeaksWorkspace=peaks_ws,
MinD=min_d,
MaxD=max_d,
Tolerance=tolerance)
IndexPeaks(PeaksWorkspace=peaks_ws, Tolerance=tolerance)
#
# Save UB and peaks file, so if something goes wrong latter, we can at least
# see these partial results
#
SaveIsawUB(InputWorkspace=peaks_ws, Filename=run_niggli_matrix_file)