def test_reactor_sans_resolution_diff_output(self):
alt_ws = "_test_alt_output"
ReactorSANSResolution(InputWorkspace=self.test_ws, OutputWorkspace=alt_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)
if mtd.workspaceExists(alt_ws):
mtd.deleteWorkspace(alt_ws)
def test_reactor_sans_resolution_diff_output(self):
alt_ws = "_test_alt_output"
ReactorSANSResolution(InputWorkspace=self.test_ws, OutputWorkspace=alt_ws)
self.assertAlmostEqual(mantid[alt_ws].dataDx(0)[0], 0.0453773, 4)
self.assertAlmostEqual(mantid[alt_ws].dataDx(0)[1], 0.0840184, 4)
self.assertAlmostEqual(mantid[alt_ws].dataDx(0)[2], 0.124066, 4)
if mtd.workspaceExists(self.test_ws):
mtd.deleteWorkspace(self.test_ws)
if mtd.workspaceExists(alt_ws):
mtd.deleteWorkspace(alt_ws)
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"))
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_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_DynamicRebinning(self):
sv = self.sv
sv.setRebinThickness(2, 1.0)
sv.setRebinNumBins(50, 200)
sv.refreshRebin()
sv.setRebinMode(True, True)
time.sleep(1)
self.assertTrue(mtd.workspaceExists('uniform_rebinned'), 'Dynamically rebinned workspace was created.')
ws = mtd['uniform_rebinned']
self.assertEqual(ws.getNumDims(), 3)
self.assertEqual(ws.getNPoints(), 50*200*1)
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_generic_workspace_property(self):
"""
Tests whether a generic WorkspaceProperty<Workspace>
can be used from Python
"""
algm_par = mtd._createAlgProxy("CreateWorkspace")
algm_par.setPropertyValues(OutputWorkspace="test", DataX=1, DataY=1, DataE=1)
algm_par.execute()
ws = algm_par.getProperty("OutputWorkspace").value
algm = GenericWorkspacePropertyTest()
algm.initialize()
algm.setPropertyValue("InputWorkspace", "test")
algm.setPropertyValue("OutputWorkspace", "testout")
algm.execute()
self.assertTrue(algm.isExecuted())
self.assertTrue(mtd.workspaceExists("testout"))
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")
