def test_to_workspace_2d(param_dim):
from mantid.simpleapi import mtd
mtd.clear()
data_len = 2
expected_bins = data_len + 1
expected_number_spectra = 10
y = sc.Variable(dims=['spectrum', param_dim],
values=np.random.rand(expected_number_spectra, data_len),
variances=np.random.rand(expected_number_spectra,
data_len))
x = sc.Variable(dims=['spectrum', param_dim],
values=np.arange(expected_number_spectra * expected_bins,
dtype=np.float64).reshape(
(expected_number_spectra,
expected_bins)))
data = sc.DataArray(data=y, coords={param_dim: x})
ws = scn.to_mantid(data, param_dim)
assert len(ws.readX(0)) == expected_bins
assert ws.getNumberHistograms() == expected_number_spectra
# check that no workspaces have been leaked in the ADS
assert len(mtd) == 0, f"Workspaces present: {mtd.getObjectNames()}"
for i in range(expected_number_spectra):
np.testing.assert_array_equal(ws.readX(i), x['spectrum', i].values)
np.testing.assert_array_equal(ws.readY(i), y['spectrum', i].values)
np.testing.assert_array_equal(ws.readE(i),
np.sqrt(y['spectrum', i].variances))
def test_fit(self):
"""
Tests that the fit executes, and the outputs
are moved into the dataset. Does not check the fit values.
"""
from mantid.simpleapi import mtd
mtd.clear()
data = scn.load(scn.data.get_path("iris26176_graphite002_sqw.nxs"))
params, diff = scn.fit(data['Q', 0],
mantid_args={
'Function':
'name=LinearBackground,A0=0,A1=1',
'StartX': 0,
'EndX': 3
})
# check that no workspaces have been leaked in the ADS
assert len(mtd) == 0
assert 'data' in diff
assert 'calculated' in diff
assert 'diff' in diff
assert 'status' in params.coords
assert 'function' in params.coords
assert 'cost_function' in params.coords
assert 'chi^2/d.o.f.' in params.coords
def test_loader_option(self):
out6 = LoadAndMerge(Filename='967101',LoaderName='LoadILLDiffraction',
LoaderVersion=1,LoaderOptions=dict({'DataType':'Raw'}))
self.assertTrue(out6)
self.assertEquals(out6.name(), 'out6')
self.assertTrue(isinstance(out6, MatrixWorkspace))
mtd.clear()
def test_loader_option(self):
out6 = LoadAndMerge(Filename='967101',LoaderName='LoadILLDiffraction',
LoaderVersion=1,LoaderOptions=dict({'DataType':'Raw'}))
self.assertTrue(out6)
self.assertEqual(out6.name(), 'out6')
self.assertTrue(isinstance(out6, MatrixWorkspace))
mtd.clear()
def test_extract_energy_initial():
from mantid.simpleapi import mtd
mtd.clear()
ds = scn.load(scn.data.get_path("CNCS_51936_event.nxs"),
mantid_args={"SpectrumMax": 1})
assert sc.identical(ds.coords["incident_energy"],
sc.scalar(value=3.0, unit=sc.Unit("meV")))
def tearDown(self):
AbinsTestHelpers.remove_output_files(list_of_names=[
"explicit", "default", "total", "squaricn_sum_Abins",
"squaricn_scale", "benzene_exp", "benzene_Abins", "experimental",
"numbered"
])
mtd.clear()
def test_many_runs_summed(self):
out2 = LoadAndMerge(Filename='170257+170258',
LoaderName='LoadILLIndirect')
self.assertTrue(out2)
self.assertEqual(out2.name(), 'out2')
self.assertTrue(isinstance(out2, MatrixWorkspace))
mtd.clear()
def test_basic_load(self):
ws_name = 'test-sample'
actual = load(ws_name, self.sample_file_path,
**self.align_and_focus_args)
actual = mtd[actual]
self.assertEqual(actual.name(), ws_name)
self.assertEqual(actual.getNumberHistograms(), 5)
self.assertEqual(actual.getAxis(0).getUnit().caption(), 'q')
mtd.clear()
def test_specific_loader(self):
out5 = LoadAndMerge(
Filename='170257',
LoaderName='LoadILLIndirect',
)
self.assertTrue(out5)
self.assertEqual(out5.name(), 'out5')
self.assertTrue(isinstance(out5, MatrixWorkspace))
mtd.clear()
def test_non_ill_load(self):
out7 = LoadAndMerge(Filename='IRS26173,26174.RAW')
self.assertTrue(out7)
self.assertTrue(isinstance(out7, WorkspaceGroup))
self.assertEqual(out7.getNumberOfEntries(), 2)
self.assertTrue(isinstance(out7.getItem(0), MatrixWorkspace))
self.assertTrue(isinstance(out7.getItem(1), MatrixWorkspace))
self.assertEqual(out7.getItem(0).name(),'IRS26173')
self.assertEqual(out7.getItem(1).name(),'IRS26174')
mtd.clear()
def test_multi_period_loader_list(self):
out8 = LoadAndMerge(Filename='MUSR00015196,00015197.nxs')
self.assertTrue(out8)
self.assertTrue(isinstance(out8, WorkspaceGroup))
self.assertEquals(out8.getNumberOfEntries(), 4)
self.assertEquals(out8.getItem(0).name(),'MUSR00015196_1')
self.assertEquals(out8.getItem(1).name(),'MUSR00015196_2')
self.assertEquals(out8.getItem(2).name(),'MUSR00015197_1')
self.assertEquals(out8.getItem(3).name(),'MUSR00015197_2')
mtd.clear()
def test_multi_period_loader_list(self):
out8 = LoadAndMerge(Filename='MUSR00015196,00015197.nxs')
self.assertTrue(out8)
self.assertTrue(isinstance(out8, WorkspaceGroup))
self.assertEqual(out8.getNumberOfEntries(), 4)
self.assertEqual(out8.getItem(0).name(),'MUSR00015196_1')
self.assertEqual(out8.getItem(1).name(),'MUSR00015196_2')
self.assertEqual(out8.getItem(2).name(),'MUSR00015197_1')
self.assertEqual(out8.getItem(3).name(),'MUSR00015197_2')
mtd.clear()
def test_non_ill_load(self):
out7 = LoadAndMerge(Filename='IRS26173,26174.RAW')
self.assertTrue(out7)
self.assertTrue(isinstance(out7, WorkspaceGroup))
self.assertEquals(out7.getNumberOfEntries(), 2)
self.assertTrue(isinstance(out7.getItem(0), MatrixWorkspace))
self.assertTrue(isinstance(out7.getItem(1), MatrixWorkspace))
self.assertEquals(out7.getItem(0).name(),'IRS26173')
self.assertEquals(out7.getItem(1).name(),'IRS26174')
mtd.clear()
def test_output_hidden(self):
LoadAndMerge(Filename='170257+170258,170300+170302',LoaderName='LoadILLIndirect',
OutputWorkspace='__out')
self.assertTrue(mtd['__out'])
self.assertTrue(isinstance(mtd['__out'], WorkspaceGroup))
self.assertEqual(mtd['__out'].getNumberOfEntries(), 2)
self.assertTrue(isinstance(mtd['__out'].getItem(0), MatrixWorkspace))
self.assertTrue(isinstance(mtd['__out'].getItem(1), MatrixWorkspace))
self.assertEqual(mtd['__out'].getItem(0).name(),'__170257_170258')
self.assertEqual(mtd['__out'].getItem(1).name(),'__170300_170302')
mtd.clear()
def test_many_runs_mixed(self):
out4 = LoadAndMerge(Filename='170257+170258,170300+170302',LoaderName='LoadILLIndirect')
self.assertTrue(out4)
self.assertEquals(out4.name(), 'out4')
self.assertTrue(isinstance(out4, WorkspaceGroup))
self.assertEquals(out4.getNumberOfEntries(), 2)
self.assertTrue(isinstance(out4.getItem(0), MatrixWorkspace))
self.assertTrue(isinstance(out4.getItem(1), MatrixWorkspace))
self.assertEquals(out4.getItem(0).name(),'170257_170258')
self.assertEquals(out4.getItem(1).name(),'170300_170302')
mtd.clear()
def test_to_workspace_2d(param_dim):
from mantid.simpleapi import mtd
mtd.clear()
data_len = 2
expected_bins = data_len + 1
expected_number_spectra = 10
y = sc.Variable([Dim.Spectrum, param_dim],
values=np.random.rand(expected_number_spectra, data_len),
variances=np.random.rand(expected_number_spectra,
data_len))
x = sc.Variable([Dim.Spectrum, param_dim],
values=np.arange(expected_number_spectra * expected_bins,
dtype=np.float64).reshape(
(expected_number_spectra,
expected_bins)))
ws = sc.compat.mantid.to_workspace_2d(x.values, y.values, y.variances,
param_dim)
assert len(ws.readX(0)) == expected_bins
assert ws.getNumberHistograms() == expected_number_spectra
# check that no workspaces have been leaked in the ADS
assert len(mtd) == 0, f"Workspaces present: {mtd.getObjectNames()}"
for i in range(expected_number_spectra):
np.testing.assert_array_equal(ws.readX(i), x[Dim.Spectrum, i])
np.testing.assert_array_equal(ws.readY(i), y[Dim.Spectrum, i])
np.testing.assert_array_equal(ws.readE(i), y[Dim.Spectrum,
i].variances)
def test_set_run(self):
import mantid.simpleapi as mantid
target = mantid.CloneWorkspace(self.base_event_ws)
d = mantidcompat.convert_EventWorkspace_to_data_array(target, False)
d.attrs["run"].value.addProperty("test_property", 1, True)
# before
self.assertFalse(target.run().hasProperty("test_property"))
target.setRun(d.attrs["run"].value)
# after
self.assertTrue(target.run().hasProperty("test_property"))
def test_set_sample(self):
import mantid.simpleapi as mantid
target = mantid.CloneWorkspace(self.base_event_ws)
d = mantidcompat.convert_EventWorkspace_to_data_array(target, False)
d.attrs["sample"].value.setThickness(3)
# before
self.assertNotEqual(3, target.sample().getThickness())
target.setSample(d.attrs["sample"].value)
# after
self.assertEqual(3, target.sample().getThickness())
def test_many_runs_mixed(self):
out4 = LoadAndMerge(Filename='170257+170258,170300+170302',LoaderName='LoadILLIndirect')
self.assertTrue(out4)
self.assertEqual(out4.name(), 'out4')
self.assertTrue(isinstance(out4, WorkspaceGroup))
self.assertEqual(out4.getNumberOfEntries(), 2)
self.assertTrue(isinstance(out4.getItem(0), MatrixWorkspace))
self.assertTrue(isinstance(out4.getItem(1), MatrixWorkspace))
self.assertEqual(out4.getItem(0).name(),'170257_170258')
self.assertEqual(out4.getItem(1).name(),'170300_170302')
mtd.clear()
def test_output_hidden(self):
LoadAndMerge(Filename='170257+170258,170300+170302',LoaderName='LoadILLIndirect',
OutputWorkspace='__out')
self.assertTrue(mtd['__out'])
self.assertTrue(isinstance(mtd['__out'], WorkspaceGroup))
self.assertEquals(mtd['__out'].getNumberOfEntries(), 2)
self.assertTrue(isinstance(mtd['__out'].getItem(0), MatrixWorkspace))
self.assertTrue(isinstance(mtd['__out'].getItem(1), MatrixWorkspace))
self.assertEquals(mtd['__out'].getItem(0).name(),'__170257_170258')
self.assertEquals(mtd['__out'].getItem(1).name(),'__170300_170302')
mtd.clear()
def test_many_runs_listed(self):
out3 = LoadAndMerge(Filename='170257,170258',LoaderName='LoadILLIndirect')
self.assertTrue(out3)
self.assertEqual(out3.name(), 'out3')
self.assertTrue(isinstance(out3, WorkspaceGroup))
self.assertEqual(out3.getNumberOfEntries(), 2)
self.assertTrue(isinstance(out3.getItem(0), MatrixWorkspace))
self.assertTrue(isinstance(out3.getItem(1), MatrixWorkspace))
self.assertEqual(out3.getItem(0).name(),'170257')
self.assertEqual(out3.getItem(1).name(),'170258')
mtd.clear()
def test_multi_period_loader_sum(self):
out9 = LoadAndMerge(Filename='MUSR00015196+00015197.nxs')
self.assertTrue(out9)
self.assertTrue(isinstance(out9, MatrixWorkspace))
self.assertTrue('MUSR00015196' not in mtd)
self.assertTrue('MUSR00015197' not in mtd)
self.assertTrue('MUSR00015196_1' not in mtd)
self.assertTrue('MUSR00015196_2' not in mtd)
self.assertTrue('MUSR00015197_1' not in mtd)
self.assertTrue('MUSR00015197_2' not in mtd)
mtd.clear()
def test_many_runs_listed(self):
out3 = LoadAndMerge(Filename='170257,170258',LoaderName='LoadILLIndirect')
self.assertTrue(out3)
self.assertEquals(out3.name(), 'out3')
self.assertTrue(isinstance(out3, WorkspaceGroup))
self.assertEquals(out3.getNumberOfEntries(), 2)
self.assertTrue(isinstance(out3.getItem(0), MatrixWorkspace))
self.assertTrue(isinstance(out3.getItem(1), MatrixWorkspace))
self.assertEquals(out3.getItem(0).name(),'170257')
self.assertEquals(out3.getItem(1).name(),'170258')
mtd.clear()
def test_multi_period_loader_sum(self):
out9 = LoadAndMerge(Filename='MUSR00015196+00015197.nxs')
self.assertTrue(out9)
self.assertTrue(isinstance(out9, MatrixWorkspace))
self.assertTrue('MUSR00015196' not in mtd)
self.assertTrue('MUSR00015197' not in mtd)
self.assertTrue('MUSR00015196_1' not in mtd)
self.assertTrue('MUSR00015196_2' not in mtd)
self.assertTrue('MUSR00015197_1' not in mtd)
self.assertTrue('MUSR00015197_2' not in mtd)
mtd.clear()
def testD17SlitWidthLogEntry(self):
ws = illhelpers.create_poor_mans_d17_workspace()
mtd.add('ws', ws)
illhelpers.add_slit_configuration_D17(ws, 0.03, 0.02)
run = ws.run()
instrName = common.instrumentName(ws)
slit2width = run.get(common.slitSizeLogEntry(instrName, 1))
slit3width = run.get(common.slitSizeLogEntry(instrName, 2))
common.slitSizes(ws)
self.assertEquals(slit2width.value, run.getProperty(common.SampleLogs.SLIT2WIDTH).value)
self.assertEquals(slit3width.value, run.getProperty(common.SampleLogs.SLIT3WIDTH).value)
mtd.clear()
def __del__(self):
"""
Destructor removes output files after tests and workspaces.
:return:
"""
try:
AbinsTestHelpers.remove_output_files(list_of_names=[self._system_name])
except TypeError:
# nothing to remove but it is OK
pass
mtd.clear()
def __del__(self):
"""
Destructor removes output files after tests and workspaces.
:return:
"""
try:
AbinsTestHelpers.remove_output_files(list_of_names=[self._system_name])
except TypeError:
# nothing to remove but it is OK
pass
mtd.clear()
def test_load_component_info(self):
from mantid.simpleapi import mtd
mtd.clear()
ds = sc.Dataset()
sc.compat.mantid.load_component_info(
ds, MantidDataHelper.find_file("iris26176_graphite002_sqw.nxs"))
# check that no workspaces have been leaked in the ADS
assert len(mtd) == 0, f"Workspaces present: {mtd.getObjectNames()}"
self.assertTrue("source_position" in ds.coords)
self.assertTrue("sample_position" in ds.coords)
self.assertTrue("position" in ds.coords)
def test_Workspace2D_with_include_monitors(self):
from mantid.simpleapi import mtd
mtd.clear()
filename = MantidDataHelper.find_file("WISH00016748.raw")
ds = mantidcompat.load(filename,
mantid_args={"LoadMonitors": "Include"})
self.assertEqual(len(mtd), 0, mtd.getObjectNames())
attrs = ds.attrs.keys()
expected_monitor_attrs = set(
["monitor1", "monitor2", "monitor3", "monitor4", "monitor5"])
assert expected_monitor_attrs.issubset(attrs)
for monitor_name in expected_monitor_attrs:
monitors = ds.attrs[monitor_name].values
assert isinstance(monitors, sc.DataArray)
assert monitors.shape == [4471]
def test_WorkspaceGroup_parsed_correctly(self):
from mantid.simpleapi import (mtd, CreateSampleWorkspace,
GroupWorkspaces)
CreateSampleWorkspace(OutputWorkspace="ws1")
CreateSampleWorkspace(OutputWorkspace="ws2")
CreateSampleWorkspace(OutputWorkspace="ws3")
GroupWorkspaces(InputWorkspaces="ws1,ws2,ws3",
OutputWorkspace="NewGroup")
converted_group = scn.from_mantid(mtd["NewGroup"])
converted_single = scn.from_mantid(mtd["ws1"])
assert len(converted_group) == 3
assert sc.identical(converted_group['ws1'], converted_single)
mtd.clear()
def test_EventWorkspace_with_monitors(self):
from mantid.simpleapi import mtd
mtd.clear()
ds = scn.load(scn.data.get_path("CNCS_51936_event.nxs"),
mantid_args={
"LoadMonitors": True,
"SpectrumMax": 1
})
self.assertEqual(len(mtd), 0, mtd.getObjectNames())
attrs = [str(key) for key in ds.attrs.keys()]
expected_monitor_attrs = {"monitor2", "monitor3"}
assert expected_monitor_attrs.issubset(attrs)
for monitor_name in expected_monitor_attrs:
monitor = ds.attrs[monitor_name].value
assert isinstance(monitor, sc.DataArray)
assert monitor.shape == [200001]
self.check_monitor_metadata(monitor)
def test_load_with_material(self):
ws_name = 'test-sample'
geometry = {
'Shape': 'Cylinder',
'Radius': 0.3175,
'Center': [0.0, 0.0, 0.0],
'Height': 4.0
}
formula = 'Si'
mass_density = 2.328
actual = load(ws_name=ws_name,
input_files=self.sample_file_path,
geometry=geometry,
chemical_formula=formula,
mass_density=mass_density,
**self.align_and_focus_args)
actual = mtd[actual]
self.assertEqual(actual.sample().getMaterial().name(), 'Si')
mtd.clear()
def test_to_workspace_2d_handles_single_spectra():
from mantid.simpleapi import mtd
mtd.clear()
expected_x = [0., 1., 2.]
expected_y = [10., 20., 30.]
expected_e = [4., 4., 4.]
x = sc.Variable(dims=['tof'], values=expected_x)
y = sc.Variable(dims=['tof'], values=expected_y, variances=expected_e)
data = sc.DataArray(data=y, coords={'tof': x})
ws = scn.to_mantid(data, "tof")
assert ws.getNumberHistograms() == 1
assert np.equal(ws.readX(0), expected_x).all()
assert np.equal(ws.readY(0), expected_y).all()
assert np.equal(ws.readE(0), np.sqrt(expected_e)).all()
def test_Workspace2D_with_include_monitors(self):
from mantid.simpleapi import mtd
mtd.clear()
# This test would use 20 GB of memory if "SpectrumMax" was not set
ds = scn.load(scn.data.get_path("WISH00016748.raw"),
mantid_args={
"LoadMonitors": "Include",
"SpectrumMax": 100
})
self.assertEqual(len(mtd), 0, mtd.getObjectNames())
attrs = [str(key) for key in ds.attrs.keys()]
expected_monitor_attrs = {
"monitor1", "monitor2", "monitor3", "monitor4", "monitor5"
}
assert expected_monitor_attrs.issubset(attrs)
for monitor_name in expected_monitor_attrs:
monitor = ds.attrs[monitor_name].value
assert isinstance(monitor, sc.DataArray)
assert monitor.shape == [4471]
self.check_monitor_metadata(monitor)
def test_fit_executes(self):
"""
Tests that the fit executes, and the outputs
are moved into the dataset. Does not check the fit values.
"""
from mantid.simpleapi import Load, mtd
mtd.clear()
ws = Load(MantidDataHelper.find_file("iris26176_graphite002_sqw.nxs"),
StoreInADS=False)
fit_ds = sc.compat.mantid.fit(ws, 'name=LinearBackground,A0=0,A1=1', 0,
0, 3)
# check that no workspaces have been leaked in the ADS
self.assertEqual(len(mtd), 0, mtd.getObjectNames())
self.assertTrue("workspace" in fit_ds)
self.assertTrue("normalised_covariance_matrix" in fit_ds)
self.assertTrue("parameters" in fit_ds)
self.assertTrue("cost_function" in fit_ds.attrs)
self.assertTrue("function" in fit_ds.attrs)
self.assertTrue("status" in fit_ds.attrs)
self.assertTrue("chi2_over_DoF" in fit_ds.attrs)
def test_EventWorkspace_with_monitors(self):
from mantid.simpleapi import mtd
mtd.clear()
filename = MantidDataHelper.find_file("CNCS_51936_event.nxs")
ds = mantidcompat.load(filename, mantid_args={"LoadMonitors": True})
self.assertEqual(len(mtd), 0, mtd.getObjectNames())
attrs = ds.attrs.keys()
expected_monitor_attrs = set(["monitor2", "monitor3"])
assert expected_monitor_attrs.issubset(attrs)
for monitor_name in expected_monitor_attrs:
monitor = ds.attrs[monitor_name].value
assert isinstance(monitor, sc.DataArray)
assert monitor.shape == [200001]
assert 'position' in monitor.coords
assert 'source_position' in monitor.coords
# This is essential, otherwise unit conversion assumes scattering
# from sample:
assert 'sample_position' not in monitor.coords
# Absence of the following is not crucial, but currently there is
# no need for these, and it avoid duplication:
assert 'detector_info' not in monitor.coords
assert 'run' not in monitor.attrs
assert 'sample' not in monitor.attrs
def test_to_workspace_2d_handles_single_x_array():
from mantid.simpleapi import mtd
mtd.clear()
expected_x = [0., 1., 2.]
expected_y = [[10., 20., 30.], [40., 50., 60.]]
expected_e = [[4., 4., 4.], [4., 4., 4.]]
x = sc.Variable(dims=['tof'], values=expected_x)
y = sc.Variable(dims=['spectrum', 'tof'],
values=np.array(expected_y),
variances=np.array(expected_e))
data = sc.DataArray(data=y, coords={'tof': x})
ws = scn.to_mantid(data, "tof")
assert ws.getNumberHistograms() == 2
assert np.equal(ws.readX(0), expected_x).all()
assert np.equal(ws.readX(1), expected_x).all()
for i, (y_vals, e_vals) in enumerate(zip(expected_y, expected_e)):
assert np.equal(ws.readY(i), y_vals).all()
assert np.equal(ws.readE(i), np.sqrt(e_vals)).all()
def test_to_workspace_2d_no_error(self):
from mantid.simpleapi import mtd
mtd.clear()
# All Dims for which support is expected are
# tested in the parametrized test.
# Just set this one to a working one to avoid
# generating many repetitive tests.
param_dim = Dim.Tof
data_len = 2
expected_bins = data_len + 1
expected_number_spectra = 10
y = sc.Variable([Dim.Spectrum, param_dim],
values=np.random.rand(expected_number_spectra,
data_len))
x = sc.Variable([Dim.Spectrum, param_dim],
values=np.arange(
expected_number_spectra * expected_bins,
dtype=np.float64).reshape(
(expected_number_spectra, expected_bins)))
ws = sc.compat.mantid.to_workspace_2d(x.values, y.values, None,
param_dim)
assert len(ws.readX(0)) == expected_bins
assert ws.getNumberHistograms() == expected_number_spectra
# check that no workspaces have been leaked in the ADS
assert len(mtd) == 0, f"Workspaces present: {mtd.getObjectNames()}"
for i in range(expected_number_spectra):
np.testing.assert_array_equal(ws.readX(i), x[Dim.Spectrum, i])
np.testing.assert_array_equal(ws.readY(i), y[Dim.Spectrum, i])
np.testing.assert_array_equal(ws.readE(i),
np.sqrt(y[Dim.Spectrum, i].values))
def tearDown(self):
mtd.clear()
def tearDown(self):
AbinsTestHelpers.remove_output_files(list_of_names=["explicit", "default", "total", "squaricn_sum_Abins",
"squaricn_scale", "benzene_exp", "benzene_Abins",
"experimental"])
mtd.clear()
def tearDown(self):
AbinsTestHelpers.remove_output_files(list_of_names=["AbinsAdvanced"])
mtd.clear()
def tearDown(self):
config['default.facility'] = self._facility
mtd.clear()
def test_specific_loader(self):
out5 = LoadAndMerge(Filename='170257',LoaderName='LoadILLIndirect',)
self.assertTrue(out5)
self.assertEquals(out5.name(), 'out5')
self.assertTrue(isinstance(out5, MatrixWorkspace))
mtd.clear()
def cleanup(self):
mtd.clear()
def test_many_runs_summed(self):
out2 = LoadAndMerge(Filename='170257+170258',LoaderName='LoadILLIndirect')
self.assertTrue(out2)
self.assertEquals(out2.name(), 'out2')
self.assertTrue(isinstance(out2, MatrixWorkspace))
mtd.clear()
def tearDown(self):
mtd.clear()
def test_single_run_load(self):
out1 = LoadAndMerge(Filename='170257')
self.assertTrue(out1)
self.assertEquals(out1.name(), 'out1')
self.assertTrue(isinstance(out1, MatrixWorkspace))
mtd.clear()
