Пример #1
0
def create_test_model(input_workspaces,
                      function_name,
                      parameters,
                      output_workspace_names=None,
                      logs=None,
                      global_parameters=None):
    """
    Create a list of fits with time series logs on the workspaces
    :param input_workspaces: See create_test_fits
    :param function_name: See create_test_fits
    :param parameters: See create_test_fits
    :param logs: A list of (name, (values...), (name, (values...)))
    :param global_parameters: An optional list of tied parameters
    :return: A list of Fits with workspaces/logs attached
    """
    fits = create_test_fits(input_workspaces, function_name, parameters,
                            output_workspace_names, global_parameters)
    logs = logs if logs is not None else []
    for fit, workspace_name in zip(fits, input_workspaces):
        add_logs(workspace_name, logs)

    fitting_context = FittingContext()
    for fit in fits:
        fitting_context.add_fit(fit)
    return fitting_context, ResultsTabModel(fitting_context)
Пример #2
0
class FittingContextTest(GuiTest):
    def setUp(self):
        self.fitting_context = FittingContext()

    def test_context_constructor_accepts_fit_list(self):
        fit_list = [
            FitInformation(mock.MagicMock(), 'MuonGuassOsc', mock.MagicMock(),
                           mock.MagicMock())
        ]
        context = FittingContext(fit_list)

        self.assertEqual(fit_list, context.fit_list)

    def test_len_gives_length_of_fit_list(self):
        self.assertEqual(0, len(self.fitting_context))
        self.fitting_context.add_fit(
            FitInformation(mock.MagicMock(), 'MuonGuassOsc', mock.MagicMock(),
                           mock.MagicMock()))
        self.assertEqual(1, len(self.fitting_context))

    def test_items_can_be_added_to_fitting_context(self):
        fit_information_object = FitInformation(mock.MagicMock(),
                                                'MuonGuassOsc',
                                                mock.MagicMock(),
                                                mock.MagicMock())

        self.fitting_context.add_fit(fit_information_object)

        self.assertEqual(fit_information_object,
                         self.fitting_context.fit_list[0])

    def test_fitfunctions_gives_list_of_unique_function_names(self):
        test_fit_function = 'MuonGuassOsc'
        self.fitting_context.add_fit_from_values(mock.MagicMock(),
                                                 test_fit_function,
                                                 mock.MagicMock(),
                                                 mock.MagicMock(), [])
        self.fitting_context.add_fit_from_values(mock.MagicMock(),
                                                 test_fit_function,
                                                 mock.MagicMock(),
                                                 mock.MagicMock(), [])

        fit_functions = self.fitting_context.fit_function_names()

        self.assertEqual(len(fit_functions), 1)
        self.assertEqual(test_fit_function, fit_functions[0])

    def test_can_add_fits_without_first_creating_fit_information_objects(self):
        parameter_workspace = mock.MagicMock()
        input_workspace = mock.MagicMock()
        output_workspace_names = mock.MagicMock()
        fit_function_name = 'MuonGuassOsc'
        fit_information_object = FitInformation(parameter_workspace,
                                                fit_function_name,
                                                input_workspace,
                                                output_workspace_names)

        self.fitting_context.add_fit_from_values(parameter_workspace,
                                                 fit_function_name,
                                                 input_workspace,
                                                 output_workspace_names)

        self.assertEqual(fit_information_object,
                         self.fitting_context.fit_list[0])

    def test_can_add_fits_with_global_parameters_without_creating_fit_information(
            self):
        parameter_workspace = mock.MagicMock()
        input_workspace = mock.MagicMock()
        fit_function_name = 'MuonGuassOsc'
        global_params = ['A']
        fit_information_object = FitInformation(parameter_workspace,
                                                fit_function_name,
                                                input_workspace, global_params)

        self.fitting_context.add_fit_from_values(parameter_workspace,
                                                 fit_function_name,
                                                 input_workspace,
                                                 global_params)

        self.assertEqual(fit_information_object,
                         self.fitting_context.fit_list[0])

    def test_parameters_are_readonly(self):
        test_parameters = OrderedDict([('Height', (10., 0.4)),
                                       ('A0', (1, 0.01)),
                                       ('Cost function', (0.1, 0.))])
        fit_params = create_test_fit_parameters(test_parameters)
        fit_info = FitInformation(fit_params._parameter_workspace,
                                  mock.MagicMock(), mock.MagicMock(),
                                  mock.MagicMock())

        self.assertRaises(AttributeError, setattr, fit_info, "parameters",
                          fit_params)

    def test_log_names_returns_logs_from_all_fits_by_default(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:])
        self.fitting_context.add_fit(
            FitInformation(mock.MagicMock(), 'func1', fake1.name(),
                           fake1.name()))
        self.fitting_context.add_fit(
            FitInformation(mock.MagicMock(), 'func1', fake2.name(),
                           fake2.name()))

        log_names = self.fitting_context.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_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:])
        self.fitting_context.add_fit(
            FitInformation(mock.MagicMock(), 'func1', fake1.name(),
                           fake1.name()))
        self.fitting_context.add_fit(
            FitInformation(mock.MagicMock(), 'func1', fake2.name(),
                           fake2.name()))

        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))