def _add_simultaneous_fit_results_to_ADS_and_context( self, input_workspace_names: list, parameter_table, output_group_workspace, covariance_matrix, global_parameters: list) -> None: """Adds the results of a simultaneous fit to the ADS and fitting context.""" function_name = self.fitting_context.function_name output_workspace_wraps, directory = self._create_output_workspace_wraps( input_workspace_names, function_name, output_group_workspace) parameter_table_name, _ = create_parameter_table_name( input_workspace_names[0] + "+ ...", function_name) covariance_matrix_name, _ = create_covariance_matrix_name( input_workspace_names[0] + "+ ...", function_name) self._add_workspace_to_ADS(parameter_table, parameter_table_name, directory) self._add_workspace_to_ADS(covariance_matrix, covariance_matrix_name, directory) parameter_workspace_wrap = StaticWorkspaceWrapper( parameter_table_name, retrieve_ws(parameter_table_name)) covariance_workspace_wrap = StaticWorkspaceWrapper( covariance_matrix_name, retrieve_ws(covariance_matrix_name)) # the directory returns with a slash, so lets remove it self._add_workspaces_to_group( [parameter_table_name, covariance_matrix_name], directory[:-1]) self._add_fit_to_context(input_workspace_names, output_workspace_wraps, parameter_workspace_wrap, covariance_workspace_wrap, global_parameters)
def test_log_names_respects_filter(self): time_series_logs = (('ts_1', (1., )), ('ts_2', (3., )), ('ts_3', [2.]), ('ts_4', [3.])) fake1 = create_test_workspace( ws_name='fake1', time_series_logs=time_series_logs[:2]) fake2 = create_test_workspace( ws_name='fake2', time_series_logs=time_series_logs[2:]) table_workspace = WorkspaceFactory.createTable() fit1 = FitInformation(mock.MagicMock(), 'func1', [StaticWorkspaceWrapper(fake1.name(), fake1)], StaticWorkspaceWrapper(fake1.name(), table_workspace), mock.MagicMock()) fit2 = FitInformation(mock.MagicMock(), 'func1', [StaticWorkspaceWrapper(fake2.name(), fake2)], StaticWorkspaceWrapper(fake2.name(), table_workspace), mock.MagicMock()) self.mock_active_fit_history = mock.PropertyMock(return_value=[fit1, fit2]) type(self.fitting_context).active_fit_history = self.mock_active_fit_history self.fitting_context.all_latest_fits = mock.MagicMock(return_value=[fit1, fit2]) self.fitting_context.add_fit(fit1) self.fitting_context.add_fit(fit2) required_logs = ('ts_2', 'ts_4') log_names = self.fitting_context.log_names( filter_fn=lambda log: log.name in required_logs) self.assertEqual(len(required_logs), len(log_names)) for name in required_logs: self.assertTrue( name in log_names, msg="{} not found in log list".format(name))
def test_has_log_returns_true_if_all_workspaces_have_the_log(self): time_series_logs = (('ts_1', (1., )), ('ts_2', (3., ))) fake1 = create_test_workspace(ws_name='fake1', time_series_logs=time_series_logs) fake2 = create_test_workspace(ws_name='fake2', time_series_logs=time_series_logs) fit = FitInformation(mock.MagicMock(), 'func1', [ StaticWorkspaceWrapper(fake1.name(), fake1), StaticWorkspaceWrapper(fake2.name(), fake2) ], mock.MagicMock(), mock.MagicMock()) self.assertTrue(fit.has_log('ts_1'))
def test_has_log_returns_false_if_all_workspaces_do_not_have_log(self): time_series_logs = [('ts_1', (1., ))] fake1 = create_test_workspace(ws_name='fake1', time_series_logs=time_series_logs) fake2 = create_test_workspace(ws_name='fake2') fit = FitInformation(mock.MagicMock(), 'func1', [ StaticWorkspaceWrapper(fake1.name(), fake1), StaticWorkspaceWrapper(fake2.name(), fake2) ], mock.MagicMock(), mock.MagicMock()) self.assertFalse( fit.has_log('ts_1'), msg='All input workspaces should have the requested log')
def test_that_show_normalised_covariance_matrix_will_not_raise_an_error( self): ws = CreateEmptyTableWorkspace() wrapper = StaticWorkspaceWrapper("CovarianceMatrix", ws) self.view.show_normalised_covariance_matrix(wrapper.workspace, wrapper.workspace_name)
def test_that_current_normalised_covariance_matrix_will_return_a_statix_workspace_wrapper_when_a_fit_exists(self): ws = CreateEmptyTableWorkspace() wrapper = StaticWorkspaceWrapper("CovarianceMatrix", ws) self.model._get_normalised_covariance_matrix_for = mock.Mock(return_value=wrapper) covariance_wrapper = self.model.current_normalised_covariance_matrix() self.assertEqual(covariance_wrapper, wrapper)
def test_that_has_normalised_covariance_matrix_returns_true_when_there_is_not_a_covariance_matrix( self): ws = CreateEmptyTableWorkspace() wrapper = StaticWorkspaceWrapper("CovarianceMatrix", ws) self.model._get_normalised_covariance_matrix_for = mock.Mock( return_value=wrapper) self.assertTrue(self.model.has_normalised_covariance_matrix())
def test_logs_from_workspace_without_logs_returns_emtpy_list(self): fake_ws = create_test_workspace() fit = FitInformation(mock.MagicMock(), 'func1', [StaticWorkspaceWrapper(fake_ws.name(), fake_ws)], mock.MagicMock(), mock.MagicMock()) allowed_logs = fit.log_names() self.assertEqual(0, len(allowed_logs))
def test_create_results_table_with_logs_selected(self): workspace = CreateWorkspace([0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]) workspace.mutableRun().addProperty( "run_start", "1970-01-01T00:00:01 to 1970-01-01T00:00:01", True) AddTimeSeriesLog(workspace, Name="sample_temp", Time="2010-01-01T00:00:00", Value=100) AddTimeSeriesLog(workspace, Name="sample_temp", Time="2010-01-01T00:30:00", Value=65) AddTimeSeriesLog(workspace, Name="sample_temp", Time="2010-01-01T00:50:00", Value=100.2) workspace.mutableRun().addProperty("sample_magn_field", 2, True) _, model = create_test_model( ('ws1', ), 'func1', self.parameters, [StaticWorkspaceWrapper('ws1', workspace)], self.logs) selected_results = [('ws1', 0)] table = model.create_results_table(self.log_names, selected_results) # workspace_name => no error col as its a string # sample_temp => time series and will have non-zero error # sample_magn_field => just a number expected_cols = [ 'workspace_name', 'run_start', 'run_start_seconds', 'sample_temp', 'sample_tempError', 'sample_magn_field', 'sample_magn_fieldError', 'f0.Height', 'f0.HeightError', 'f0.PeakCentre', 'f0.PeakCentreError', 'f0.Sigma', 'f0.SigmaError', 'f1.Height', 'f1.HeightError', 'f1.PeakCentre', 'f1.PeakCentreError', 'f1.Sigma', 'f1.SigmaError', 'Cost function value' ] expected_types = (TableColumnType.NoType, TableColumnType.X, TableColumnType.X, TableColumnType.X, TableColumnType.XErr, TableColumnType.X, TableColumnType.XErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y) avg_log_values = "1970-01-01T00:00:01 to 1970-01-01T00:00:01", 1, 86., 2.0 expected_content = [ ('ws1_Parameters', avg_log_values[0], avg_log_values[1], avg_log_values[2], 17.146, avg_log_values[3], 0., self.f0_height[0], self.f0_height[1], self.f0_centre[0], self.f0_centre[1], self.f0_sigma[0], self.f0_sigma[1], self.f1_height[0], self.f1_height[1], self.f1_centre[0], self.f1_centre[1], self.f1_sigma[0], self.f1_sigma[1], self.cost_function[0]) ] self._assert_table_matches_expected(zip(expected_cols, expected_types), expected_content, table, model.results_table_name())
def test_log_names_from_list_of_workspaces_gives_combined_set(self): time_series_logs = (('ts_1', (1., )), ('ts_2', (3., )), ('ts_3', [2.]), ('ts_4', [3.])) fake1 = create_test_workspace(ws_name='fake1', time_series_logs=time_series_logs[:2]) fake2 = create_test_workspace(ws_name='fake2', time_series_logs=time_series_logs[2:]) fit = FitInformation(mock.MagicMock(), 'func1', [ StaticWorkspaceWrapper(fake1.name(), fake1), StaticWorkspaceWrapper(fake2.name(), fake2) ], mock.MagicMock(), mock.MagicMock()) log_names = fit.log_names() self.assertEqual(len(time_series_logs), len(log_names)) for name, _ in time_series_logs: self.assertTrue(name in log_names, msg="{} not found in log list".format(name))
def test_that_handle_covariance_matrix_clicked_calls_the_expected_functions(self): ws = CreateEmptyTableWorkspace() wrapper = StaticWorkspaceWrapper("CovarianceMatrix", ws) self.model.current_normalised_covariance_matrix = mock.Mock(return_value=wrapper) self.presenter.handle_covariance_matrix_clicked() self.model.current_normalised_covariance_matrix.assert_called_once_with() self.view.show_normalised_covariance_matrix.assert_called_once_with(wrapper.workspace, wrapper.workspace_name)
def test_string_log_value_from_fit_with_single_workspace(self): single_value_logs = [('sv_1', '5')] fake1 = create_test_workspace(ws_name='fake1', string_value_logs=single_value_logs) fit = FitInformation(mock.MagicMock(), 'func1', [StaticWorkspaceWrapper(fake1.name(), fake1)], mock.MagicMock(), mock.MagicMock()) self.assertEqual(float(single_value_logs[0][1]), fit.log_value(single_value_logs[0][0]))
def test_time_series_log_value_from_fit_with_multiple_workspaces_uses_average_of_time_average( self): time_series_logs1 = \ [('ts_1', (("2000-05-01T12:00:00", 5.), ("2000-05-01T12:00:10", 20.), ("2000-05-01T12:05:00", 30.)))] fake1 = create_test_workspace('fake1', time_series_logs1) time_series_logs2 = \ [('ts_1', (("2000-05-01T12:00:30", 10.), ("2000-05-01T12:01:45", 30.), ("2000-05-01T12:05:00", 40.)))] fake2 = create_test_workspace('fake2', time_series_logs2) fit = FitInformation(mock.MagicMock(), 'func1', [ StaticWorkspaceWrapper(fake1.name(), fake1), StaticWorkspaceWrapper(fake2.name(), fake2) ], mock.MagicMock(), mock.MagicMock()) time_average1 = (10 * 5 + 290 * 20) / 300. time_average2 = (75 * 10 + 195 * 30) / 270. all_average = 0.5 * (time_average1 + time_average2) self.assertAlmostEqual(all_average, fit.log_value('ts_1'), places=6)
def test_log_names_uses_filter_fn(self): time_series_logs = (('ts_1', (1., )), ('ts_2', (3., )), ('ts_3', [2.]), ('ts_4', [3.])) fake1 = create_test_workspace(ws_name='fake1', time_series_logs=time_series_logs) fit = FitInformation(mock.MagicMock(), 'func1', [StaticWorkspaceWrapper(fake1.name(), fake1)], mock.MagicMock(), mock.MagicMock()) log_names = fit.log_names(lambda log: log.name == 'ts_1') self.assertEqual(1, len(log_names)) self.assertEqual(time_series_logs[0][0], log_names[0])
def test_remove_workspace_by_name_will_remove_a_fit_containing_a_specific_parameter_workspace( self): output_ws = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) table_workspace = WorkspaceFactory.createTable() output_ws_wrap1 = StaticWorkspaceWrapper("Output1", output_ws) parameter_ws_wrap1 = StaticWorkspaceWrapper("Parameter1", table_workspace) covariance_ws_wrap1 = StaticWorkspaceWrapper("Covariance1", table_workspace) output_ws_wrap2 = StaticWorkspaceWrapper("Output2", output_ws) parameter_ws_wrap2 = StaticWorkspaceWrapper("Parameter2", table_workspace) covariance_ws_wrap2 = StaticWorkspaceWrapper("Covariance2", table_workspace) fit1 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1], parameter_ws_wrap1, covariance_ws_wrap1) fit2 = FitInformation(["Input2"], "GausOsc", [output_ws_wrap2], parameter_ws_wrap2, covariance_ws_wrap2) self.fitting_context.active_fit_history = [fit1, fit2] self.fitting_context.remove_workspace_by_name("Parameter1") self.assertEqual(self.fitting_context.active_fit_history[0], fit2) self.assertEqual(self.fitting_context.all_latest_fits()[0], fit2)
def test_that_all_latest_fits_will_return_the_two_most_recent_unique_fits( self): output_ws = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) table_workspace = WorkspaceFactory.createTable() output_ws_wrap1 = StaticWorkspaceWrapper("Output1", output_ws) parameter_ws_wrap1 = StaticWorkspaceWrapper("Parameter1", table_workspace) covariance_ws_wrap1 = StaticWorkspaceWrapper("Covariance1", table_workspace) output_ws_wrap2 = StaticWorkspaceWrapper("Output2", output_ws) parameter_ws_wrap2 = StaticWorkspaceWrapper("Parameter2", table_workspace) covariance_ws_wrap2 = StaticWorkspaceWrapper("Covariance2", table_workspace) fit1 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1], parameter_ws_wrap1, covariance_ws_wrap1) fit2 = FitInformation(["Input2"], "GausOsc", [output_ws_wrap2], parameter_ws_wrap2, covariance_ws_wrap2) fit3 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1], parameter_ws_wrap1, covariance_ws_wrap1) self.fitting_context.active_fit_history = [fit1, fit2, fit3] self.assertEqual(self.fitting_context.active_fit_history[0], fit1) self.assertEqual(self.fitting_context.active_fit_history[1], fit2) self.assertEqual(self.fitting_context.active_fit_history[2], fit3) # fit3 == fit1 and fit3 is more recent, so 'all_latest_fits' will only return the most recent unique fits. self.assertEqual(self.fitting_context.all_latest_fits()[0], fit2) self.assertEqual(self.fitting_context.all_latest_fits()[1], fit3)
def test_time_series_log_value_from_fit_with_single_workspace_uses_time_average( self): time_series_logs = \ [('ts_1', (("2000-05-01T12:00:00", 5.), ("2000-05-01T12:00:10", 20.), ("2000-05-01T12:05:00", 30.)))] fake1 = create_test_workspace('fake1', time_series_logs) fit = FitInformation(mock.MagicMock(), 'func1', [StaticWorkspaceWrapper(fake1.name(), fake1)], mock.MagicMock(), mock.MagicMock()) time_average = (10 * 5 + 290 * 20) / 300. self.assertAlmostEqual(time_average, fit.log_value('ts_1'), places=6)
def _create_output_workspace_wraps_for_a_multi_domain_fit( self, input_workspace_names: list, output_group_workspace, output_group_name: str) -> list: """Returns a list of StaticWorkspaceWrapper objects containing the fitted output workspaces for many domains.""" self._add_workspace_to_ADS(output_group_workspace, output_group_name, "") output_workspace_names = self._rename_members_of_fitted_workspace_group( input_workspace_names, output_group_name) return [ StaticWorkspaceWrapper(workspace_name, retrieve_ws(workspace_name)) for workspace_name in output_workspace_names ]
def test_create_results_table_with_logs_missing_from_some_workspaces_raises( self): workspace = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) parameters = OrderedDict([('f0.Height', (100, 0.1))]) logs = [('log1', (1., 2.)), ('log2', (3., 4.)), ('log3', (4., 5.)), ('log4', (5., 6.))] fits_logs1 = create_test_fits( ('ws1', ), 'func1', parameters, output_workspace_names=[ StaticWorkspaceWrapper('test-ws1-ws', workspace) ]) add_logs(fits_logs1[0].input_workspaces[0], logs[:2]) fits_logs2 = create_test_fits( ('ws2', ), 'func1', parameters, output_workspace_names=[ StaticWorkspaceWrapper('test-ws2-ws', workspace) ]) add_logs(fits_logs2[0].input_workspaces[0], logs[2:]) fitting_context = TFAsymmetryFittingContext() fitting_context.fit_list = fits_logs1 + fits_logs2 model = ResultsTabModel(fitting_context, ResultsContext()) selected_results = [('ws1', 0), ('ws2', 1)] selected_logs = ['log1', 'log3'] self.assertRaises(IndexError, model.create_results_table, selected_logs, selected_results)
def test_logs_for_single_workspace_return_all_time_series_logs(self): time_series_logs = (('ts_1', (1., )), ('ts_2', (3., ))) single_value_logs = (('sv_1', 'val1'), ('sv_2', 'val2')) fake_ws = create_test_workspace(time_series_logs=time_series_logs) fit = FitInformation(mock.MagicMock(), 'func1', [StaticWorkspaceWrapper(fake_ws.name(), fake_ws)], mock.MagicMock(), mock.MagicMock()) log_names = fit.log_names() for name, _ in time_series_logs: self.assertTrue(name in log_names, msg="{} not found in log list".format(name)) for name, _ in single_value_logs: self.assertFalse(name in log_names, msg="{} found in log list".format(name))
def _create_output_workspace_wraps(self, input_workspace_names: list, function_name: str, output_group_workspace) -> tuple: """Returns a list of StaticWorkspaceWrapper objects containing the fitted output workspaces""" if self.fitting_context.number_of_datasets > 1: output_group_name, directory = create_multi_domain_fitted_workspace_name( input_workspace_names[0], function_name) output_workspace_wraps = self._create_output_workspace_wraps_for_a_multi_domain_fit( input_workspace_names, output_group_workspace, output_group_name) else: output_workspace_name, directory = create_fitted_workspace_name( input_workspace_names[0], function_name) self._add_workspace_to_ADS(output_group_workspace, output_workspace_name, directory) output_workspace_wraps = [ StaticWorkspaceWrapper(output_workspace_name, retrieve_ws(output_workspace_name)) ] return output_workspace_wraps, directory
def create_test_fits(input_workspaces, function_name, parameters, output_workspace_names=None, global_parameters=None): """ Create a list of fits :param input_workspaces: The input workspaces :param function_name: The name of the function :param parameters: The parameters list :param output_workspace_names: A list of workspace names :param global_parameters: An optional list of tied parameters :return: A list of Fits """ workspace = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) output_workspace_names = output_workspace_names if output_workspace_names is not None else [ StaticWorkspaceWrapper('test-output-ws', workspace) ] # Convert parameters to fit table-like structure fit_table = [{ 'Name': name, 'Value': value, 'Error': error } for name, (value, error) in parameters.items()] fits = [] for name in input_workspaces: parameter_workspace = mock.NonCallableMagicMock() parameter_workspace.workspace.__iter__.return_value = fit_table parameter_workspace.workspace_name = name + '_Parameters' fits.append( FitInformation([name], function_name, output_workspace_names, parameter_workspace, mock.Mock(), global_parameters)) return fits
def test_create_results_table_with_logs_selected(self): workspace = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) workspace.mutableRun().addProperty("sample_temp", 50, True) workspace.mutableRun().addProperty("sample_magn_field", 2, True) _, model = create_test_model( ('ws1', ), 'func1', self.parameters, [StaticWorkspaceWrapper('ws1', workspace)], self.logs) selected_results = [('ws1', 0)] table = model.create_results_table(self.log_names, selected_results) expected_cols = ['workspace_name'] + self.log_names + [ 'f0.Height', 'f0.HeightError', 'f0.PeakCentre', 'f0.PeakCentreError', 'f0.Sigma', 'f0.SigmaError', 'f1.Height', 'f1.HeightError', 'f1.PeakCentre', 'f1.PeakCentreError', 'f1.Sigma', 'f1.SigmaError', 'Cost function value' ] expected_types = (TableColumnType.NoType, TableColumnType.X, TableColumnType.X, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y, TableColumnType.YErr, TableColumnType.Y) avg_log_values = 50., 2.0 expected_content = [ ('ws1_Parameters', avg_log_values[0], avg_log_values[1], self.f0_height[0], self.f0_height[1], self.f0_centre[0], self.f0_centre[1], self.f0_sigma[0], self.f0_sigma[1], self.f1_height[0], self.f1_height[1], self.f1_centre[0], self.f1_centre[1], self.f1_sigma[0], self.f1_sigma[1], self.cost_function[0]) ] self._assert_table_matches_expected(zip(expected_cols, expected_types), expected_content, table, model.results_table_name())
def test_that_all_latest_fits_will_return_the_two_most_recent_unique_fits( self): output_ws = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5) table_workspace = WorkspaceFactory.createTable() output_ws_wrap1 = StaticWorkspaceWrapper("Output1", output_ws) parameter_ws_wrap1 = StaticWorkspaceWrapper("Parameter1", table_workspace) covariance_ws_wrap1 = StaticWorkspaceWrapper("Covariance1", table_workspace) output_ws_wrap2 = StaticWorkspaceWrapper("Output2", output_ws) parameter_ws_wrap2 = StaticWorkspaceWrapper("Parameter2", table_workspace) covariance_ws_wrap2 = StaticWorkspaceWrapper("Covariance2", table_workspace) fit1 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1], parameter_ws_wrap1, covariance_ws_wrap1) fit2 = FitInformation(["Input2"], "GausOsc", [output_ws_wrap2], parameter_ws_wrap2, covariance_ws_wrap2) fit3 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1], parameter_ws_wrap1, covariance_ws_wrap1) self.fitting_context.tf_asymmetry_mode = True self.fitting_context.simultaneous_fitting_mode = True self.fitting_context.active_fit_history = [fit1, fit2, fit3] self.assertEqual(self.fitting_context.active_fit_history[0], fit1) self.assertEqual(self.fitting_context.active_fit_history[1], fit2) self.assertEqual(self.fitting_context.active_fit_history[2], fit3) self.assertEqual(self.fitting_context.all_latest_fits()[0], fit2) self.assertEqual(self.fitting_context.all_latest_fits()[1], fit3) self.fitting_context.tf_asymmetry_mode = False self.assertEqual(self.fitting_context.active_fit_history, []) self.assertEqual(self.fitting_context.all_latest_fits()[0], fit2) self.assertEqual(self.fitting_context.all_latest_fits()[1], fit3)