def testWaterWorkspace(self): inWSName = 'ReflectometryILLPreprocess_test_ws' self.create_sample_workspace(inWSName) # Add a peak to the sample workspace. ws = mtd[inWSName] for i in range(ws.getNumberHistograms()): ys = ws.dataY(i) ys.fill(10.27) args = { 'InputWorkspace': inWSName, 'OutputWorkspace': 'unused_for_child', 'WaterWorkspace': inWSName, 'FluxNormalisation': 'Normalisation OFF', 'FlatBackground': 'Background OFF', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEqual(outWS.getNumberHistograms(), 100) ysSize = outWS.blocksize() for i in range(outWS.getNumberHistograms()): ys = outWS.readY(i) numpy.testing.assert_equal(ys, [1.0] * ysSize) self.assertEqual(mtd.getObjectNames(), ['ReflectometryILLPreprocess_test_ws'])
def _backgroundSubtraction(self, subtractionType): inWSName = 'ReflectometryILLPreprocess_test_ws' self.create_sample_workspace(inWSName) # Add a peak to the sample workspace. ws = mtd[inWSName] ys = ws.dataY(49) ys += 10.0 args = { 'InputWorkspace': inWSName, 'OutputWorkspace': 'unused_for_child', 'LinePosition': 49, 'FluxNormalisation': 'Normalisation OFF', 'FlatBackground': subtractionType, 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEquals(outWS.getNumberHistograms(), 100) ysSize = outWS.blocksize() for i in range(outWS.getNumberHistograms()): ys = outWS.readY(i) if i != 49: numpy.testing.assert_almost_equal(ys, [0.0] * ysSize) else: numpy.testing.assert_almost_equal(ys, [10.0] * ysSize) self.assertEquals(mtd.getObjectNames(), ['ReflectometryILLPreprocess_test_ws'])
def create_sample_workspace(self, name, numMonitors=0): args = { 'OutputWorkspace': name, 'Function': 'Flat background', 'NumMonitors': numMonitors, 'NumBanks': 1, } alg = create_algorithm('CreateSampleWorkspace', **args) alg.setLogging(False) alg.execute() loadInstrArgs = { 'Workspace': name, 'InstrumentName': 'FIGARO', 'RewriteSpectraMap': False } loadInstrument = create_algorithm('LoadInstrument', **loadInstrArgs) loadInstrument.setLogging(False) loadInstrument.execute() addSampleLogArgs = { 'Workspace': name, 'LogType': 'Number', 'LogName': common.SampleLogs.TWO_THETA, 'NumberType': 'Double', 'LogText': '5.6', 'LogUnit': 'degree' } addSampleLog = create_algorithm('AddSampleLog', **addSampleLogArgs) addSampleLog.setLogging(False) addSampleLog.execute() self.assertEqual(mtd.getObjectNames(), [name])
def testDefaultRunD17(self): args = { 'Run': 'ILL/D17/317370.nxs', 'OutputWorkspace': 'outWS', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEqual(outWS.getAxis(0).getUnit().caption(), 'Wavelength') det122 = outWS.getDetector(122) twoTheta122 = outWS.detectorTwoTheta(det122) self.assertAlmostEquals(twoTheta122, 0.057659886309975004, delta=1.e-13) twoTheta = outWS.run().getProperty(common.SampleLogs.TWO_THETA).value self.assertAlmostEquals(twoTheta, 3.182191848754883, delta=1.e-13) peakPosition = outWS.run().getProperty( common.SampleLogs.FOREGROUND_CENTRE).value twoTheta2 = numpy.rad2deg(outWS.spectrumInfo().twoTheta(peakPosition)) self.assertAlmostEquals(twoTheta2, 1.5371900428796088, delta=1.e-13) self.assertEqual(mtd.getObjectNames(), [])
def create_sample_workspace(self, name, numMonitors=0): args = { 'OutputWorkspace': name, 'Function': 'Flat background', 'NumMonitors': numMonitors, 'NumBanks': 1, } alg = create_algorithm('CreateSampleWorkspace', **args) alg.setLogging(False) alg.execute() loadInstrArgs = { 'Workspace': name, 'InstrumentName': 'FIGARO', 'RewriteSpectraMap': False } loadInstrument = create_algorithm('LoadInstrument', **loadInstrArgs) loadInstrument.setLogging(False) loadInstrument.execute() addSampleLogArgs = { 'Workspace': name, 'LogType': 'Number', 'LogName': common.SampleLogs.TWO_THETA, 'NumberType': 'Double', 'LogText': '5.6', 'LogUnit': 'degree' } addSampleLog = create_algorithm('AddSampleLog', **addSampleLogArgs) addSampleLog.setLogging(False) addSampleLog.execute() self.assertEquals(mtd.getObjectNames(), [name])
def test_load_valid_added_event_data_and_monitor_file_produces_group_ws(self): # Arrange names = ['event_data', 'monitor'] file_names = self._prepare_workspaces(names = names) self._cleanup_workspaces(names = names) # Act group_ws_name = 'g_ws' output_group_file_name = su.bundle_added_event_data_as_group(file_names[0], file_names[1]) Load(Filename = output_group_file_name, OutputWorkspace = group_ws_name) group_ws = mtd[group_ws_name] # Assert self.assertTrue(isinstance(group_ws, WorkspaceGroup)) self.assertEqual(group_ws.size(), 2) self.assertTrue(os.path.exists(file_names[0])) # File for group workspace exists self.assertFalse(os.path.exists(file_names[1])) # File for monitors is deleted # Clean up ws_names_to_delete = [] for ws_name in mtd.getObjectNames(): if ws_name != group_ws_name: ws_names_to_delete.append(str(ws_name)) self._cleanup_workspaces(names = ws_names_to_delete) if os.path.exists(file_names[0]): os.remove(file_names[0])
def testDisableFlatBackgroundSubtraction(self): inWSName = 'ReflectometryILLPreprocess_test_ws' self.create_sample_workspace(inWSName) # Add a peak to the sample workspace. ws = mtd[inWSName] bkgLevel = ws.readY(0)[0] self.assertGreater(bkgLevel, 0.1) args = { 'InputWorkspace': inWSName, 'OutputWorkspace': 'unused_for_child', 'LinePosition': 49, 'FluxNormalisation': 'Normalisation OFF', 'FlatBackground': 'Background OFF', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEqual(outWS.getNumberHistograms(), 100) for i in range(outWS.getNumberHistograms()): ys = outWS.readY(i) numpy.testing.assert_equal(ys, bkgLevel) self.assertEqual(mtd.getObjectNames(), ['ReflectometryILLPreprocess_test_ws'])
def testWaterWorkspace(self): inWSName = 'ReflectometryILLPreprocess_test_ws' self.create_sample_workspace(inWSName) # Add a peak to the sample workspace. ws = mtd[inWSName] for i in range(ws.getNumberHistograms()): ys = ws.dataY(i) ys.fill(10.27) args = { 'InputWorkspace': inWSName, 'OutputWorkspace': 'unused_for_child', 'WaterWorkspace': inWSName, 'FluxNormalisation': 'Normalisation OFF', 'FlatBackground': 'Background OFF', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEquals(outWS.getNumberHistograms(), 100) ysSize = outWS.blocksize() for i in range(outWS.getNumberHistograms()): ys = outWS.readY(i) numpy.testing.assert_equal(ys, [1.0] * ysSize) self.assertEquals(mtd.getObjectNames(), ['ReflectometryILLPreprocess_test_ws'])
def _backgroundSubtraction(self, subtractionType): inWSName = 'ReflectometryILLPreprocess_test_ws' self.create_sample_workspace(inWSName) # Add a peak to the sample workspace. ws = mtd[inWSName] ys = ws.dataY(49) ys += 10.0 args = { 'InputWorkspace': inWSName, 'OutputWorkspace': 'unused_for_child', 'LinePosition': 49, 'FluxNormalisation': 'Normalisation OFF', 'FlatBackground': subtractionType, 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEqual(outWS.getNumberHistograms(), 100) ysSize = outWS.blocksize() for i in range(outWS.getNumberHistograms()): ys = outWS.readY(i) if i != 49: numpy.testing.assert_almost_equal(ys, [0.0] * ysSize) else: numpy.testing.assert_almost_equal(ys, [10.0] * ysSize) self.assertEqual(mtd.getObjectNames(), ['ReflectometryILLPreprocess_test_ws'])
def test_monitors_are_renamed_correctly(self): #Arrange ws_1 = CreateSampleWorkspace() ws_2 = CreateSampleWorkspace() ws_3 = CreateSampleWorkspace() ws_mon_1 = CreateSampleWorkspace() ws_mon_2 = CreateSampleWorkspace() ws_mon_3 = CreateSampleWorkspace() ws_group = GroupWorkspaces(InputWorkspaces=[ws_1, ws_2, ws_3]) ws_mon_group = GroupWorkspaces(InputWorkspaces=[ws_mon_1, ws_mon_2, ws_mon_3]) # Act su.rename_monitors_for_multiperiod_event_data(ws_mon_group, ws_group, self.monitor_appendix) # Assert self.assertTrue(ws_mon_1.name() == ws_1.name() + self.monitor_appendix, "Monitors should be renamed to xxxx_monitors") self.assertTrue(ws_mon_2.name() == ws_2.name() + self.monitor_appendix, "Monitors should be renamed to xxxx_monitors") self.assertTrue(ws_mon_3.name() == ws_3.name() + self.monitor_appendix, "Monitors should be renamed to xxxx_monitors") # Clean up for element in mtd.getObjectNames(): if element in mtd: DeleteWorkspace(element)
def _assert_run_algorithm_succeeds(self, args, expected): """Run the algorithm with the given args and check it succeeds, and that the additional workspaces produced match the expected list. Clear these additional workspaces from the ADS""" alg = create_algorithm('ReflectometryISISLoadAndProcess', **args) assertRaisesNothing(self, alg.execute) actual = mtd.getObjectNames() self.assertEquals(set(actual), set(expected))
def _assert_run_algorithm_succeeds(self, args, expected): """Run the algorithm with the given args and check it succeeds, and that the additional workspaces produced match the expected list. Clear these additional workspaces from the ADS""" alg = create_algorithm('ReflectometryISISLoadAndProcess', **args) assertRaisesNothing(self, alg.execute) actual = mtd.getObjectNames() self.assertEquals(set(actual), set(expected))
def testTwoInputFiles(self): outWSName = 'outWS' args = { 'Run': 'ILL/D17/317369, ILL/D17/317370.nxs', 'OutputWorkspace': outWSName, 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEquals(outWS.getAxis(0).getUnit().caption(), 'Wavelength') self.assertEquals(mtd.getObjectNames(), [])
def testTwoInputFiles(self): outWSName = 'outWS' args = { 'Run': 'ILL/D17/317369, ILL/D17/317370.nxs', 'OutputWorkspace': outWSName, 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEqual(outWS.getAxis(0).getUnit().caption(), 'Wavelength') self.assertEqual(mtd.getObjectNames(), [])
def testDefaultRunFIGARO(self): args = { 'Run': 'ILL/Figaro/000002.nxs', 'OutputWorkspace': 'outWS', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEquals(outWS.getAxis(0).getUnit().caption(), 'Wavelength') det122 = outWS.getDetector(122) twoTheta122 = outWS.detectorTwoTheta(det122) self.assertAlmostEquals(twoTheta122, 0.03060663990053301, delta=1.e-13) self.assertEquals(mtd.getObjectNames(), [])
def testDefaultRunFIGARO(self): args = { 'Run': 'ILL/Figaro/000002.nxs', 'OutputWorkspace': 'outWS', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEqual(outWS.getAxis(0).getUnit().caption(), 'Wavelength') det122 = outWS.getDetector(122) twoTheta122 = outWS.detectorTwoTheta(det122) self.assertAlmostEquals(twoTheta122, 0.03060663990053301, delta=1.e-13) self.assertEqual(mtd.getObjectNames(), [])
def testTwoThetaFit(self): args = { 'Run': 'ILL/D17/317369', 'OutputWorkspace': 'outWS', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertAlmostEquals(outWS.getRun().getProperty(common.SampleLogs.LINE_POSITION).value, 202.1773407538167, delta=1.e-13) self.assertEquals(outWS.getRun().getProperty(common.SampleLogs.FOREGROUND_CENTRE).value, 202) self.assertEquals(outWS.getAxis(0).getUnit().caption(), 'Wavelength') print(mtd.getObjectNames())
def testLinePositionTwoThetaInput(self): args = { 'Run': 'ILL/D17/317369', 'LinePosition': 10.23, 'TwoTheta': 40.66, 'OutputWorkspace': 'outWS', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEquals(outWS.getRun().getProperty(common.SampleLogs.LINE_POSITION).value, 10.23) self.assertEquals(outWS.getRun().getProperty(common.SampleLogs.FOREGROUND_CENTRE).value, 10) self.assertEquals(outWS.getRun().getProperty(common.SampleLogs.TWO_THETA).value, 1.5885926485061646) self.assertEquals(outWS.getAxis(0).getUnit().caption(), 'Wavelength') self.assertEquals(mtd.getObjectNames(), [])
def testTwoThetaFit(self): args = { 'Run': 'ILL/D17/317369', 'OutputWorkspace': 'outWS', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertAlmostEquals(outWS.getRun().getProperty( common.SampleLogs.LINE_POSITION).value, 202.1773407538167, delta=1.e-13) self.assertEqual( outWS.getRun().getProperty( common.SampleLogs.FOREGROUND_CENTRE).value, 202) self.assertEqual(outWS.getAxis(0).getUnit().caption(), 'Wavelength') print(mtd.getObjectNames())
def testAsymmetricForegroundRanges(self): inWSName = 'ReflectometryILLPreprocess_test_ws' self.create_sample_workspace(inWSName) ws = mtd[inWSName] # Add special background fitting zones around the exclude zones. foregroundIndices = [21, 22, 23, 24] for i in range(ws.getNumberHistograms()): ys = ws.dataY(i) es = ws.dataE(i) if i in foregroundIndices: ys.fill(1000.0) es.fill(numpy.sqrt(1000.0)) else: ys.fill(-100) es.fill(numpy.sqrt(100)) args = { 'InputWorkspace': inWSName, 'OutputWorkspace': 'unused_for_child', 'LinePosition': 23, 'TwoTheta': 0.6, 'ForegroundHalfWidth': [2, 1], 'FlatBackground': 'Background OFF', 'FluxNormalisation': 'Normalisation OFF', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEqual(outWS.getNumberHistograms(), 100) logs = outWS.run() properties = [ common.SampleLogs.FOREGROUND_START, common.SampleLogs.FOREGROUND_CENTRE, common.SampleLogs.FOREGROUND_END ] values = [21, 23, 24] for p, val in zip(properties, values): self.assertTrue(logs.hasProperty(p)) self.assertEqual(logs.getProperty(p).value, val) self.assertEqual(mtd.getObjectNames(), ['ReflectometryILLPreprocess_test_ws'])
def testCleanupOFF(self): # test if intermediate workspaces exist: # normalise_to_slits, normalise_to_monitor, '_normalised_to_time_','transposed_flat_background' outWSName = 'outWS' ws = illhelpers.create_poor_mans_d17_workspace() ws = illhelpers.refl_add_line_position(ws, 3.0) self.assertEquals(ws.run().getProperty(common.SampleLogs.LINE_POSITION).value, 3.0) # Add a peak to the workspace. for i in range(33, 100): ys = ws.dataY(i) ys += 10.0 args = { 'InputWorkspace': ws, 'OutputWorkspace': outWSName, 'TwoTheta': 0.6, 'Cleanup': 'Cleanup OFF', 'WaterWorkspace': ws, 'ForegroundHalfWidth': [1, 2], 'FluxNormalisation': 'Normalisation OFF', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) wsInADS = mtd.getObjectNames() self.assertEquals(len(wsInADS), 13) self.assertEquals(wsInADS, [ 'outWS_cloned_for_flat_bkg_', 'outWS_detectors_', 'outWS_detectors_moved_', 'outWS_flat_background_', 'outWS_flat_background_subtracted_', 'outWS_in_wavelength_', 'outWS_monitors_', 'outWS_peak_', 'outWS_transposed_clone_', 'outWS_transposed_flat_background_', 'outWS_water_calibrated_', 'outWS_water_detectors_', 'outWS_water_rebinned_'] ) mtd.clear()
def test_expection_is_raised_when_workspaec_and_monitor_mismatch(self): #Arrange ws_1 = CreateSampleWorkspace() ws_2 = CreateSampleWorkspace() ws_3 = CreateSampleWorkspace() ws_mon_1 = CreateSampleWorkspace() ws_mon_2 = CreateSampleWorkspace() ws_group = GroupWorkspaces(InputWorkspaces=[ws_1, ws_2, ws_3]) ws_mon_group = GroupWorkspaces(InputWorkspaces=[ws_mon_1, ws_mon_2]) # Act + Assert args = {'monitor_worksapce': ws_mon_group, 'workspace':ws_group, 'appendix':self.monitor_appendix} self.assertRaises(RuntimeError, su.rename_monitors_for_multiperiod_event_data, *args) # Clean up for element in mtd.getObjectNames(): if element in mtd: DeleteWorkspace(element)
def exec_command_refresh(self): """ Refresh workspace in the memory :return: """ workspace_names = mtd.getObjectNames() self.ui.tableWidget_dataStructure.remove_all_rows() error_message = '' for ws_name in workspace_names: try: # get workspace and its type workspace = mtd.retrieve(ws_name) ws_type = workspace.id() # find out workspace information ws_info = '' if ws_type == 'EventWorkspace': num_events = workspace.getNumberEvents() num_hist = workspace.getNumberHistograms() num_bins = len(workspace.readY(0)) ws_info = '{}/{}/{}'.format(num_events, num_hist, num_bins) elif ws_type == 'Workspace2D': num_hist = workspace.getNumberHistograms() num_bins = len(workspace.readY(0)) ws_info = '{}/{}'.format(num_hist, num_bins) elif ws_type == 'TableWorkspace': num_rows = workspace.rowCount() num_cols = workspace.columnCount() ws_info = '{}/{}'.format(num_rows, num_cols) self.ui.tableWidget_dataStructure.add_workspace(ws_name, ws_type, ws_info) except Exception as ex: error_message += 'Unable to add %s to table due to %s.\n' % (ws_name, str(ex)) # END-FOR # switch to table tab self.ui.tabWidget_table_view.setCurrentIndex(0) if len(error_message) == 0: return True, '' return False, error_message
def testAsymmetricForegroundRanges(self): inWSName = 'ReflectometryILLPreprocess_test_ws' self.create_sample_workspace(inWSName) ws = mtd[inWSName] # Add special background fitting zones around the exclude zones. foregroundIndices = [21, 22, 23, 24] for i in range(ws.getNumberHistograms()): ys = ws.dataY(i) es = ws.dataE(i) if i in foregroundIndices: ys.fill(1000.0) es.fill(numpy.sqrt(1000.0)) else: ys.fill(-100) es.fill(numpy.sqrt(100)) args = { 'InputWorkspace': inWSName, 'OutputWorkspace': 'unused_for_child', 'LinePosition': 23, 'TwoTheta': 0.6, 'ForegroundHalfWidth': [2, 1], 'FlatBackground': 'Background OFF', 'FluxNormalisation': 'Normalisation OFF', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEquals(outWS.getNumberHistograms(), 100) logs = outWS.run() properties = [common.SampleLogs.FOREGROUND_START, common.SampleLogs.FOREGROUND_CENTRE, common.SampleLogs.FOREGROUND_END] values = [21, 23, 24] for p, val in zip(properties, values): self.assertTrue(logs.hasProperty(p)) self.assertEqual(logs.getProperty(p).value, val) self.assertEquals(mtd.getObjectNames(), ['ReflectometryILLPreprocess_test_ws'])
def testDefaultRunD17(self): args = { 'Run': 'ILL/D17/317370.nxs', 'OutputWorkspace': 'outWS', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEquals(outWS.getAxis(0).getUnit().caption(), 'Wavelength') det122 = outWS.getDetector(122) twoTheta122 = outWS.detectorTwoTheta(det122) self.assertAlmostEquals(twoTheta122, 0.057659886309975004, delta=1.e-13) twoTheta = outWS.run().getProperty(common.SampleLogs.TWO_THETA).value self.assertAlmostEquals(twoTheta, 3.182191848754883, delta=1.e-13) peakPosition = outWS.run().getProperty(common.SampleLogs.FOREGROUND_CENTRE).value twoTheta2 = numpy.rad2deg(outWS.spectrumInfo().twoTheta(peakPosition)) self.assertAlmostEquals(twoTheta2, 1.5371900428796088, delta=1.e-13) self.assertEquals(mtd.getObjectNames(), [])
def testLinePositionTwoThetaInput(self): args = { 'Run': 'ILL/D17/317369', 'LinePosition': 10.23, 'TwoTheta': 40.66, 'OutputWorkspace': 'outWS', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEqual( outWS.getRun().getProperty(common.SampleLogs.LINE_POSITION).value, 10.23) self.assertEqual( outWS.getRun().getProperty( common.SampleLogs.FOREGROUND_CENTRE).value, 10) self.assertEqual( outWS.getRun().getProperty(common.SampleLogs.TWO_THETA).value, 1.5885926485061646) self.assertEqual(outWS.getAxis(0).getUnit().caption(), 'Wavelength') self.assertEqual(mtd.getObjectNames(), [])
def testDisableFlatBackgroundSubtraction(self): inWSName = 'ReflectometryILLPreprocess_test_ws' self.create_sample_workspace(inWSName) # Add a peak to the sample workspace. ws = mtd[inWSName] bkgLevel = ws.readY(0)[0] self.assertGreater(bkgLevel, 0.1) args = { 'InputWorkspace': inWSName, 'OutputWorkspace': 'unused_for_child', 'LinePosition': 49, 'FluxNormalisation': 'Normalisation OFF', 'FlatBackground': 'Background OFF', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEquals(outWS.getNumberHistograms(), 100) for i in range(outWS.getNumberHistograms()): ys = outWS.readY(i) numpy.testing.assert_equal(ys, bkgLevel) self.assertEquals(mtd.getObjectNames(), ['ReflectometryILLPreprocess_test_ws'])
def testCleanupOFF(self): # test if intermediate workspaces exist: # normalise_to_slits, normalise_to_monitor, '_normalised_to_time_','transposed_flat_background' outWSName = 'outWS' ws = illhelpers.create_poor_mans_d17_workspace() ws = illhelpers.refl_add_line_position(ws, 3.0) self.assertEqual( ws.run().getProperty(common.SampleLogs.LINE_POSITION).value, 3.0) # Add a peak to the workspace. for i in range(33, 100): ys = ws.dataY(i) ys += 10.0 args = { 'InputWorkspace': ws, 'OutputWorkspace': outWSName, 'TwoTheta': 0.6, 'Cleanup': 'Cleanup OFF', 'WaterWorkspace': ws, 'ForegroundHalfWidth': [1, 2], 'FluxNormalisation': 'Normalisation OFF', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) wsInADS = mtd.getObjectNames() self.assertEqual(len(wsInADS), 13) self.assertEqual(wsInADS, [ 'outWS_cloned_for_flat_bkg_', 'outWS_detectors_', 'outWS_detectors_moved_', 'outWS_flat_background_', 'outWS_flat_background_subtracted_', 'outWS_in_wavelength_', 'outWS_monitors_', 'outWS_peak_', 'outWS_transposed_clone_', 'outWS_transposed_flat_background_', 'outWS_water_calibrated_', 'outWS_water_detectors_', 'outWS_water_rebinned_' ]) mtd.clear()
def tearDown(self): for wsName in mtd.getObjectNames(): if wsName.startswith(self.prefix): mtd.remove(wsName)
def testForegroundBackgroundRanges(self): inWSName = 'ReflectometryILLPreprocess_test_ws' self.create_sample_workspace(inWSName) ws = mtd[inWSName] # Add special background fitting zones around the exclude zones. lowerBkgIndices = [26] for i in lowerBkgIndices: ys = ws.dataY(i) ys += 5.0 # Add negative 'exclude zone' around the peak. lowerExclusionIndices = [27, 28] for i in lowerExclusionIndices: ys = ws.dataY(i) ys -= 1000.0 # Add a peak to the sample workspace. foregroundIndices = [29, 30, 31] for i in foregroundIndices: ys = ws.dataY(i) ys += 1000.0 # The second exclusion zone is wider. upperExclusionIndices = [32, 33, 34] for i in upperExclusionIndices: ys = ws.dataY(i) ys -= 1000.0 # The second fitting zone is wider. upperBkgIndices = [35, 36] for i in upperBkgIndices: ys = ws.dataY(i) ys += 5.0 args = { 'InputWorkspace': inWSName, 'OutputWorkspace': 'unused_for_child', 'LinePosition': 30, 'ForegroundHalfWidth': [1], 'LowAngleBkgOffset': len(lowerExclusionIndices), 'LowAngleBkgWidth': len(lowerBkgIndices), 'HighAngleBkgOffset': len(upperExclusionIndices), 'HighAngleBkgWidth': len(upperBkgIndices), 'FluxNormalisation': 'Normalisation OFF', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEquals(outWS.getNumberHistograms(), 100) ysSize = outWS.blocksize() for i in range(outWS.getNumberHistograms()): ys = outWS.readY(i) if i in lowerBkgIndices: numpy.testing.assert_equal(ys, [0.0] * ysSize) elif i in lowerExclusionIndices: numpy.testing.assert_equal(ys, [-1005.0] * ysSize) elif i in foregroundIndices: numpy.testing.assert_equal(ys, [995.0] * ysSize) elif i in upperExclusionIndices: numpy.testing.assert_equal(ys, [-1005.0] * ysSize) elif i in upperBkgIndices: numpy.testing.assert_equal(ys, [0.0] * ysSize) else: numpy.testing.assert_equal(ys, [-5.0] * ysSize) self.assertEquals(mtd.getObjectNames(), ['ReflectometryILLPreprocess_test_ws'])
def analyse(data_table, masks, output_file, show_fits=False, show_quality=False): """ Analyse a set of combined Sans and Semsans measurements. The result will be a set of workspaces with the Semsans data and a csv file that can be loaded into the batch sans interface to load the sans data. Parameters ---------- data_table The name of WorkspaceTable with the runs that need to be analysed. This table should be generated by the get_log function. masks A list of strings containing the filenames of the masks for the individual tubes used in the semsans polarisation calculation output_file Where to save the CSV file that will generate the SANS runs show_fits Whether to show the individual tube fits used to calculate the spin echo length. Defaults to False show_quality Whether to show the quality of the linear fit of the precession frequencies used to calculate the spin echo length. Defaults to False """ if "Full_Blank" not in mtd.getObjectNames(): int3samples(table_to_run(mtd["metadata_Full_Blank_runs"]), "Full_Blank", masks) const = sel_const( [mtd["Full_Blank_{}".format(tube)] for tube, _ in enumerate(masks)], show_fits=show_fits, show_quality=show_quality) k = data_table[9:-5] runs = table_to_run(mtd[data_table]) for run in runs: get_shimed(run.number, dirname(output_file)) get_shimed(run.trans, dirname(output_file)) get_shimed(run.csans, dirname(output_file)) get_shimed(run.ctrans, dirname(output_file)) get_shimed(run.direct, dirname(output_file)) semsans_ws = "{}_hours_{:0.02f}".format( k, (run.start - runs[0].start).seconds / 3600.0) int3samples([run], semsans_ws, masks) # DeleteWorkspace("{}_sans_nxs".format(run.number)) norm(semsans_ws, "Full_Blank", masks) sel(semsans_ws + "_norm", const) DeleteWorkspaces([semsans_ws, semsans_ws + "_Norm"]) with open(output_file, "w") as outfile: framework = "sample_sans,{}-add," \ "sample_trans,{}-add," \ "sample_direct_beam,{}-add,"\ "can_sans,{}-add,"\ "can_trans,{}-add,"\ "can_direct_beam,{}-add,"\ "output_as,{}_hours_{:0.2f}\n" for idx, run in enumerate(runs): outfile.write( framework.format(run.number, run.trans, run.direct, run.csans, run.ctrans, run.direct, k, (run.start - runs[0].start).seconds / 3600.0)) import sans.command_interface.ISISCommandInterface as ici ici.Clean() ici.LARMOR() ici.MaskFile( r"\\isis\inst$\NDXLARMOR\User\Users\Masks\USER_Edler_171B_a2_8mm_SEMSANS_r20287.txt" ) ici.BatchReduce(output_file, format=".nxs", verbose=True)
def _clean_up(self,names): for name in names: if name in mtd.getObjectNames(): DeleteWorkspace(name)
def testForegroundBackgroundRanges(self): inWSName = 'ReflectometryILLPreprocess_test_ws' self.create_sample_workspace(inWSName) ws = mtd[inWSName] # Add special background fitting zones around the exclude zones. lowerBkgIndices = [26] for i in lowerBkgIndices: ys = ws.dataY(i) ys += 5.0 # Add negative 'exclude zone' around the peak. lowerExclusionIndices = [27, 28] for i in lowerExclusionIndices: ys = ws.dataY(i) ys -= 1000.0 # Add a peak to the sample workspace. foregroundIndices = [29, 30, 31] for i in foregroundIndices: ys = ws.dataY(i) ys += 1000.0 # The second exclusion zone is wider. upperExclusionIndices = [32, 33, 34] for i in upperExclusionIndices: ys = ws.dataY(i) ys -= 1000.0 # The second fitting zone is wider. upperBkgIndices = [35, 36] for i in upperBkgIndices: ys = ws.dataY(i) ys += 5.0 args = { 'InputWorkspace': inWSName, 'OutputWorkspace': 'unused_for_child', 'LinePosition': 30, 'ForegroundHalfWidth': [1], 'LowAngleBkgOffset': len(lowerExclusionIndices), 'LowAngleBkgWidth': len(lowerBkgIndices), 'HighAngleBkgOffset': len(upperExclusionIndices), 'HighAngleBkgWidth': len(upperBkgIndices), 'FluxNormalisation': 'Normalisation OFF', 'rethrow': True, 'child': True } alg = create_algorithm('ReflectometryILLPreprocess', **args) assertRaisesNothing(self, alg.execute) outWS = alg.getProperty('OutputWorkspace').value self.assertEqual(outWS.getNumberHistograms(), 100) ysSize = outWS.blocksize() for i in range(outWS.getNumberHistograms()): ys = outWS.readY(i) if i in lowerBkgIndices: numpy.testing.assert_equal(ys, [0.0] * ysSize) elif i in lowerExclusionIndices: numpy.testing.assert_equal(ys, [-1005.0] * ysSize) elif i in foregroundIndices: numpy.testing.assert_equal(ys, [995.0] * ysSize) elif i in upperExclusionIndices: numpy.testing.assert_equal(ys, [-1005.0] * ysSize) elif i in upperBkgIndices: numpy.testing.assert_equal(ys, [0.0] * ysSize) else: numpy.testing.assert_equal(ys, [-5.0] * ysSize) self.assertEqual(mtd.getObjectNames(), ['ReflectometryILLPreprocess_test_ws'])