def test_2d_scanning_workspace(self):
input_ws = CreateSampleWorkspace(NumMonitors=0,
NumBanks=3,
BankPixelWidth=2,
XMin=0,
XMax=5,
BinWidth=1,
NumScanPoints=7)
calibration_x = np.array([0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2])
calibration_y = np.arange(12)
calibration_ws = CreateWorkspace(DataX=calibration_x,
DataY=calibration_y,
Nspec=4)
calibrated_ws = ApplyDetectorScanEffCorr(input_ws, calibration_ws)
tmp = Transpose(calibration_ws)
tmp = tmp.extractY().flatten()
to_multiply = np.repeat(tmp, 5 * 7)
to_multiply = np.reshape(to_multiply, [7 * 12, 5])
for det in range(7 * 12):
for bin in range(5):
self.assertEquals(
calibrated_ws.readY(det)[bin],
input_ws.readY(det)[bin] * to_multiply[det][bin])
def test_sum_banks(self):
num_banks = 3
test_ws = CreateSampleWorkspace(StoreInADS=False, NumBanks=1, BankPixelWidth=num_banks)
summed_ws = ReflectometryISISSumBanks().sum_banks(test_ws)
self.assertIsInstance(summed_ws, MatrixWorkspace)
self.assertNotEqual(test_ws, summed_ws)
self.assertTrue(numpy.allclose(num_banks * test_ws.readY(0), summed_ws.readY(0)))
def test_non_scanning_case(self):
input_ws = CreateSampleWorkspace(NumMonitors=0, NumBanks=6, BankPixelWidth=1, XMin=0, XMax=1, BinWidth=1)
calibration_x = np.array([0, 0, 0, 0, 0, 0])
calibration_y = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
calibration_ws = CreateWorkspace(DataX=calibration_x, DataY=calibration_y, Nspec=calibration_y.size)
calibrated_ws = ApplyDetectorScanEffCorr(input_ws, calibration_ws)
for i in range(6):
self.assertEquals(calibrated_ws.readY(i), input_ws.readY(i) * (i+1))
self.assertEquals(calibrated_ws.readE(i), input_ws.readE(i) * (i+1))
def test_mask_and_sum_banks(self):
num_banks = 3
test_ws = CreateSampleWorkspace(StoreInADS=False, NumBanks=1, BankPixelWidth=num_banks)
# We have 3x3 pixels, so 9 detectors. Include the first 6, i.e. first 2 banks.
num_banks_included = 2
roi_detector_ids = '9-14'
masked_ws = ReflectometryISISSumBanks().mask_detectors(test_ws, roi_detector_ids)
summed_ws = ReflectometryISISSumBanks().sum_banks(masked_ws)
self.assertIsInstance(summed_ws, MatrixWorkspace)
self.assertNotEqual(test_ws, summed_ws)
self.assertTrue(numpy.allclose(num_banks_included * test_ws.readY(0), summed_ws.readY(0)))
def createPhononWS(self, T, en, e_units):
fn = 'name=Gaussian, PeakCentre='+str(en)+', Height=1, Sigma=0.5;'
fn +='name=Gaussian, PeakCentre=-'+str(en)+', Height='+str(np.exp(-en*11.6/T))+', Sigma=0.5;'
ws = CreateSampleWorkspace(binWidth = 0.1, XMin = -25, XMax = 25, XUnit = e_units, Function = 'User Defined', UserDefinedFunction=fn)
LoadInstrument(ws, InstrumentName='MARI', RewriteSpectraMap = True)
with self.assertRaises(RuntimeError):
ws_DOS = ComputeIncoherentDOS(ws)
ws = SofQW3(ws, [0, 0.05, 8], 'Direct', 25)
qq = np.arange(0, 8, 0.05)+0.025
for i in range(ws.getNumberHistograms()):
ws.setY(i, ws.readY(i)*qq[i]**2)
ws.setE(i, ws.readE(i)*qq[i]**2)
return ws
def createPhononWS(self, T, en, e_units):
fn = 'name=Gaussian, PeakCentre='+str(en)+', Height=1, Sigma=0.5;'
fn +='name=Gaussian, PeakCentre=-'+str(en)+', Height='+str(np.exp(-en*11.6/T))+', Sigma=0.5;'
ws = CreateSampleWorkspace(binWidth = 0.1, XMin = -25, XMax = 25, XUnit = e_units, Function = 'User Defined', UserDefinedFunction=fn)
LoadInstrument(ws, InstrumentName='MARI', RewriteSpectraMap = True)
with self.assertRaises(RuntimeError):
ws_DOS = ComputeIncoherentDOS(ws)
ws = SofQW3(ws, [0, 0.05, 8], 'Direct', 25)
qq = np.arange(0, 8, 0.05)+0.025
for i in range(ws.getNumberHistograms()):
ws.setY(i, ws.readY(i)*qq[i]**2)
ws.setE(i, ws.readE(i)*qq[i]**2)
return ws
def test_simple_scanning_case(self):
input_ws = CreateSampleWorkspace(NumMonitors=0, NumBanks=6, BankPixelWidth=1, XMin=0, XMax=1, BinWidth=1, NumScanPoints=2)
calibration_x = np.array([0, 0, 0, 0, 0, 0])
calibration_y = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
# Note the monitors are in the wrong place doing the test workspace creation like this - but it does not affect the test.
calibration_ws = CreateWorkspace(DataX=calibration_x, DataY=calibration_y, Nspec=calibration_y.size)
expected = np.repeat(calibration_y, 2)
calibrated_ws = ApplyDetectorScanEffCorr(input_ws, calibration_ws)
for i in range(12):
self.assertEquals(calibrated_ws.readY(i), input_ws.readY(i) * expected[i])
self.assertEquals(calibrated_ws.readE(i), input_ws.readE(i) * expected[i])
def test_2d_scanning_workspace(self):
input_ws = CreateSampleWorkspace(NumMonitors=0, NumBanks=3, BankPixelWidth=2, XMin=0, XMax=5, BinWidth=1, NumScanPoints=7)
calibration_x = np.array([0,1,2,0,1,2,0,1,2,0,1,2])
calibration_y = np.arange(12)
calibration_ws = CreateWorkspace(DataX=calibration_x, DataY=calibration_y, Nspec=4)
calibrated_ws = ApplyDetectorScanEffCorr(input_ws, calibration_ws)
tmp = Transpose(calibration_ws)
tmp = tmp.extractY().flatten()
to_multiply = np.repeat(tmp, 5*7)
to_multiply = np.reshape(to_multiply, [7*12,5])
for det in range(7*12):
for bin in range(5):
self.assertEquals(calibrated_ws.readY(det)[bin], input_ws.readY(det)[bin] * to_multiply[det][bin])
def test_non_scanning_case(self):
input_ws = CreateSampleWorkspace(NumMonitors=1,
NumBanks=6,
BankPixelWidth=1,
XMin=0,
XMax=1,
BinWidth=1)
calibration_x = np.array([0, 0, 0, 0, 0, 0])
calibration_y = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
# Note the monitors are in the wrong place doing the test workspace creation like this - but it does not affect the test.
calibration_ws = CreateWorkspace(DataX=calibration_x,
DataY=calibration_y,
Nspec=calibration_y.size)
calibrated_ws = ApplyDetectorScanEffCorr(input_ws, calibration_ws)
for i in range(1, 7):
self.assertEquals(calibrated_ws.readY(i), input_ws.readY(i) * i)
self.assertEquals(calibrated_ws.readE(i), input_ws.readE(i) * i)
def test_non_scanning_case(self):
input_ws = CreateSampleWorkspace(NumMonitors=0,
NumBanks=6,
BankPixelWidth=1,
XMin=0,
XMax=1,
BinWidth=1)
calibration_x = np.array([0, 0, 0, 0, 0, 0])
calibration_y = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
calibration_ws = CreateWorkspace(DataX=calibration_x,
DataY=calibration_y,
Nspec=calibration_y.size)
calibrated_ws = ApplyDetectorScanEffCorr(input_ws, calibration_ws)
for i in range(6):
self.assertEquals(calibrated_ws.readY(i),
input_ws.readY(i) * (i + 1))
self.assertEquals(calibrated_ws.readE(i),
input_ws.readE(i) * (i + 1))
def test_copy_cells(self):
"""Check that the data copied from cells is correct."""
ws = CreateSampleWorkspace()
table = MatrixWorkspaceDisplay(ws)
# Mock the copy_to_clipboard function with a side_effect that stores the clipboard content in a member variable.
table.copy_to_clipboard = Mock(side_effect=self._mock_clipboard)
# First tab is y values.
current_table = table.view.tabs[0]
selection = current_table.selectionModel()
histogram_index = 0
y_index = 0
model_index = current_table.model().createIndex(histogram_index, y_index)
selection.select(model_index, QItemSelectionModel.ClearAndSelect)
# Call copy_cells top copy the currently selected cell.
table.copy_cells(current_table)
# Value should be the same as that taken from the workspace.
y_from_ws = ws.readY(histogram_index)[y_index]
self.assertEqual(str(y_from_ws), self.mock_clip)
def test_binary_ops_with_workspaces_not_in_ADS(self):
ws = CreateSampleWorkspace(StoreInADS=False)
initialY = ws.readY(0)[0]
ws_ads = CreateSampleWorkspace(StoreInADS=True)
result1 = ws + ws
self.assertTrue(mtd.doesExist('result1'))
result2 = ws + ws_ads
self.assertTrue(mtd.doesExist('result2'))
result3 = ws_ads + ws
self.assertTrue(mtd.doesExist('result3'))
result4 = ws_ads + ws_ads
self.assertTrue(mtd.doesExist('result4'))
result5 = ws + 1
self.assertTrue(mtd.doesExist('result5'))
result6 = 1 + ws
self.assertTrue(mtd.doesExist('result6'))
result7 = ws_ads + 1
self.assertTrue(mtd.doesExist('result7'))
result8 = 1 + ws_ads
self.assertTrue(mtd.doesExist('result8'))
ws += 1
self.assertFalse(mtd.doesExist('ws'))
ws_ads += 1
self.assertTrue(mtd.doesExist('ws_ads'))
def test_binary_ops_with_workspaces_not_in_ADS(self):
ws = CreateSampleWorkspace(StoreInADS=False)
initialY = ws.readY(0)[0]
ws_ads = CreateSampleWorkspace(StoreInADS=True)
result1 = ws + ws
self.assertTrue(mtd.doesExist('result1'))
result2 = ws + ws_ads
self.assertTrue(mtd.doesExist('result2'))
result3 = ws_ads + ws
self.assertTrue(mtd.doesExist('result3'))
result4 = ws_ads + ws_ads
self.assertTrue(mtd.doesExist('result4'))
result5 = ws + 1
self.assertTrue(mtd.doesExist('result5'))
result6 = 1 + ws
self.assertTrue(mtd.doesExist('result6'))
result7 = ws_ads + 1
self.assertTrue(mtd.doesExist('result7'))
result8 = 1 + ws_ads
self.assertTrue(mtd.doesExist('result8'))
ws += 1
self.assertFalse(mtd.doesExist('ws'))
ws_ads += 1
self.assertTrue(mtd.doesExist('ws_ads'))
class CorrectTOFTest(unittest.TestCase):
def setUp(self):
# create sample workspace
self.xmin = 2123.33867005 + 4005.75
self.xmax = 2123.33867005 + 7995.75
self._input_ws = CreateSampleWorkspace(Function="User Defined", UserDefinedFunction="name=LinearBackground, \
A0=0.3;name=Gaussian, PeakCentre=8190, Height=5, Sigma=75", NumBanks=2,
BankPixelWidth=1, XMin=self.xmin, XMax=self.xmax, BinWidth=10.5,
BankDistanceFromSample=4.0, SourceDistanceFromSample=1.4, OutputWorkspace="ws")
lognames = "wavelength,TOF1"
logvalues = "6.0,2123.33867005"
AddSampleLogMultiple(self._input_ws, lognames, logvalues)
# create EPP table
self._table = CreateEmptyTableWorkspace(OutputWorkspace="epptable")
self._table.addColumn(type="double", name="PeakCentre")
table_row = {'PeakCentre': 8189.5}
for i in range(2):
self._table.addRow(table_row)
def tearDown(self):
for wsname in ['ws', 'epptable']:
if AnalysisDataService.doesExist(wsname):
run_algorithm("DeleteWorkspace", Workspace=wsname)
def testCorrection(self):
# tests that correction is done properly
OutputWorkspaceName = "outputws1"
alg_test = run_algorithm("CorrectTOF", InputWorkspace=self._input_ws, EPPTable=self._table, OutputWorkspace=OutputWorkspaceName)
self.assertTrue(alg_test.isExecuted())
wsoutput = AnalysisDataService.retrieve(OutputWorkspaceName)
velocity = h/(m_n*6.0e-10)
t_el = 4.0e+6/velocity
t_corr = np.arange(self.xmin, self.xmax + 1.0, 10.5) + t_el - (8189.5 - 2123.33867005)
self.assertTrue(np.allclose(t_corr, wsoutput.readX(0))) #sdd = 4
self.assertTrue(np.allclose(t_corr + t_el, wsoutput.readX(1))) #sdd = 8
run_algorithm("DeleteWorkspace", Workspace=wsoutput)
def testGroup(self):
# tests whether the group of workspaces is accepted as an input
ws2 = CloneWorkspace(self._input_ws)
group = GroupWorkspaces([self._input_ws, ws2])
OutputWorkspaceName = "output_wsgroup"
alg_test = run_algorithm("CorrectTOF", InputWorkspace='group', EPPTable=self._table, OutputWorkspace=OutputWorkspaceName)
self.assertTrue(alg_test.isExecuted())
wsoutput = AnalysisDataService.retrieve(OutputWorkspaceName)
self.assertTrue(isinstance(wsoutput, WorkspaceGroup))
self.assertEqual(2, wsoutput.getNumberOfEntries())
run_algorithm("DeleteWorkspace", Workspace=group)
run_algorithm("DeleteWorkspace", Workspace=wsoutput)
def testConvertUnits(self):
# test whether CorrectTof+ConvertUnits+ConvertToDistribution will give the same result as TOFTOFConvertTOFToDeltaE
OutputWorkspaceName = "outputws1"
alg_test = run_algorithm("CorrectTOF", InputWorkspace=self._input_ws, EPPTable=self._table, OutputWorkspace=OutputWorkspaceName)
self.assertTrue(alg_test.isExecuted())
wscorr = AnalysisDataService.retrieve(OutputWorkspaceName)
# convert units, convert to distribution
alg_cu = run_algorithm("ConvertUnits", InputWorkspace=wscorr, Target='DeltaE', EMode='Direct', EFixed=2.27, OutputWorkspace=OutputWorkspaceName+'_dE')
ws_dE = AnalysisDataService.retrieve(OutputWorkspaceName+'_dE')
alg_cd = run_algorithm("ConvertToDistribution", Workspace=ws_dE)
# create reference data for X axis
tof1 = 2123.33867005
dataX = self._input_ws.readX(0) - tof1
tel = 8189.5 - tof1
factor = m_n*1e+15/eV
newX = 0.5*factor*16.0*(1/tel**2 - 1/dataX**2)
# compare
# self.assertEqual(newX[0], ws_dE.readX(0)[0])
self.assertTrue(np.allclose(newX, ws_dE.readX(0), atol=0.01))
# create reference data for Y axis and compare to the output
tof = dataX[:-1] + 5.25
newY = self._input_ws.readY(0)*tof**3/(factor*10.5*16.0)
# compare
self.assertTrue(np.allclose(newY, ws_dE.readY(0), rtol=0.01))
run_algorithm("DeleteWorkspace", Workspace=ws_dE)
run_algorithm("DeleteWorkspace", Workspace=wscorr)
class CorrectTOFTest(unittest.TestCase):
def setUp(self):
# create sample workspace
self.xmin = 2123.33867005 + 4005.75
self.xmax = 2123.33867005 + 7995.75
self._input_ws = CreateSampleWorkspace(Function="User Defined", UserDefinedFunction="name=LinearBackground, \
A0=0.3;name=Gaussian, PeakCentre=8190, Height=5, Sigma=75", NumBanks=2,
BankPixelWidth=1, XMin=self.xmin, XMax=self.xmax, BinWidth=10.5,
BankDistanceFromSample=4.0, SourceDistanceFromSample=1.4, OutputWorkspace="ws")
lognames = "wavelength,TOF1"
logvalues = "6.0,2123.33867005"
AddSampleLogMultiple(self._input_ws, lognames, logvalues)
# create EPP table
self._table = CreateEmptyTableWorkspace(OutputWorkspace="epptable")
self._table.addColumn(type="double", name="PeakCentre")
table_row = {'PeakCentre': 8189.5}
for i in range(2):
self._table.addRow(table_row)
def tearDown(self):
for wsname in ['ws', 'epptable']:
if AnalysisDataService.doesExist(wsname):
run_algorithm("DeleteWorkspace", Workspace=wsname)
def testCorrection(self):
# tests that correction is done properly
OutputWorkspaceName = "outputws1"
alg_test = run_algorithm("CorrectTOF", InputWorkspace=self._input_ws, EPPTable=self._table, OutputWorkspace=OutputWorkspaceName)
self.assertTrue(alg_test.isExecuted())
wsoutput = AnalysisDataService.retrieve(OutputWorkspaceName)
velocity = h/(m_n*6.0e-10)
t_el = 4.0e+6/velocity
t_corr = np.arange(self.xmin, self.xmax + 1.0, 10.5) + t_el - (8189.5 - 2123.33867005)
self.assertTrue(np.allclose(t_corr, wsoutput.readX(0))) #sdd = 4
self.assertTrue(np.allclose(t_corr + t_el, wsoutput.readX(1))) #sdd = 8
run_algorithm("DeleteWorkspace", Workspace=wsoutput)
def testGroup(self):
# tests whether the group of workspaces is accepted as an input
ws2 = CloneWorkspace(self._input_ws)
group = GroupWorkspaces([self._input_ws, ws2])
OutputWorkspaceName = "output_wsgroup"
alg_test = run_algorithm("CorrectTOF", InputWorkspace='group', EPPTable=self._table, OutputWorkspace=OutputWorkspaceName)
self.assertTrue(alg_test.isExecuted())
wsoutput = AnalysisDataService.retrieve(OutputWorkspaceName)
self.assertTrue(isinstance(wsoutput, WorkspaceGroup))
self.assertEqual(2, wsoutput.getNumberOfEntries())
run_algorithm("DeleteWorkspace", Workspace=group)
run_algorithm("DeleteWorkspace", Workspace=wsoutput)
def testConvertUnits(self):
# test whether CorrectTof+ConvertUnits+ConvertToDistribution will give the same result as TOFTOFConvertTOFToDeltaE
OutputWorkspaceName = "outputws1"
alg_test = run_algorithm("CorrectTOF", InputWorkspace=self._input_ws, EPPTable=self._table, OutputWorkspace=OutputWorkspaceName)
self.assertTrue(alg_test.isExecuted())
wscorr = AnalysisDataService.retrieve(OutputWorkspaceName)
# convert units, convert to distribution
alg_cu = run_algorithm("ConvertUnits", InputWorkspace=wscorr, Target='DeltaE', EMode='Direct', EFixed=2.27, OutputWorkspace=OutputWorkspaceName+'_dE')
ws_dE = AnalysisDataService.retrieve(OutputWorkspaceName+'_dE')
alg_cd = run_algorithm("ConvertToDistribution", Workspace=ws_dE)
# create reference data for X axis
tof1 = 2123.33867005
dataX = self._input_ws.readX(0) - tof1
tel = 8189.5 - tof1
factor = m_n*1e+15/eV
newX = 0.5*factor*16.0*(1/tel**2 - 1/dataX**2)
# compare
# self.assertEqual(newX[0], ws_dE.readX(0)[0])
self.assertTrue(np.allclose(newX, ws_dE.readX(0), atol=0.01))
# create reference data for Y axis and compare to the output
tof = dataX[:-1] + 5.25
newY = self._input_ws.readY(0)*tof**3/(factor*10.5*16.0)
# compare
self.assertTrue(np.allclose(newY, ws_dE.readY(0), rtol=0.01))
run_algorithm("DeleteWorkspace", Workspace=ws_dE)
run_algorithm("DeleteWorkspace", Workspace=wscorr)