def test_that_AttributeError_thrown_if_setting_workspace_to_non_MuonWorkspace_object(self): pair = MuonPair(pair_name="pair1") self.assertIsNone(pair.workspace) with self.assertRaises(AttributeError): pair.workspace = [1, 2, 3] self.assertIsNone(pair.workspace)
def test_that_can_only_set_workspace_if_MuonWorkspace_object(self): pair = MuonPair(pair_name="pair1") self.assertIsNone(pair.workspace) dataX = [0, 1, 2, 3, 4, 5] dataY = [10, 20, 30, 20, 10] input_workspace = CreateWorkspace(dataX, dataY) pair.workspace = MuonWorkspaceWrapper(input_workspace) self.assertIsNotNone(pair.workspace)
def test_can_remove_pairs_as_expected(self): pair_1 = MuonPair('pair_1') pair_2 = MuonPair('pair_2') pair_3 = MuonPair('pair_3') self.context.add_pair(pair_1) self.context.add_pair(pair_2) self.context.add_pair(pair_3) self.context.remove_pair('pair_2') self.assertEqual(self.context.pair_names, ['pair_1', 'pair_3'])
def test_show_adds_group_or_pair_to_ADS(self): group_1 = MuonGroup('group_1', [1, 3, 5, 7, 9]) group_2 = MuonGroup('group_2', [1, 3, 4, 7, 9]) pair = MuonPair('pair_1') group_1.show = mock.MagicMock() pair.show = mock.MagicMock() self.context.add_group(group_1) self.context.add_group(group_2) self.context.add_pair(pair) self.context.show('group_1', [12345]) self.context.show('pair_1', [12345]) group_1.show.assert_called_once_with(str([12345])) pair.show.assert_called_once_with(str([12345]))
def setUp(self): self._qapp = mock_widget.mockQapp() self.obj = QtGui.QWidget() ConfigService['default.instrument'] = 'MUSR' setup_context_for_tests(self) self.gui_context['RebinType'] = 'None' self.view = HomeGroupingWidgetView(self.obj) self.model = HomeGroupingWidgetModel(self.context) self.presenter = HomeGroupingWidgetPresenter(self.view, self.model) self.view.warning_popup = mock.MagicMock() self.view.instrument_changed_warning = mock.MagicMock(return_value=1) file_path = FileFinder.findRuns('MUSR00022725.nxs')[0] ws, run, filename = load_utils.load_workspace_from_filename(file_path) self.data_context._loaded_data.remove_data(run=run) self.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='MUSR') self.data_context.current_runs = [[22725]] self.context.update_current_data() test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75) self.group_context.add_pair(pair=test_pair) self.presenter.update_group_pair_list()
def setUp(self): AnalysisDataService.clear() ConfigService['MantidOptions.InvisibleWorkspaces'] = 'True' self.filepath = FileFinder.findRuns('EMU00019489.nxs')[0] self.load_result, self.run_number, self.filename, psi_data = load_workspace_from_filename(self.filepath) self.assert_(not psi_data) self.context = setup_context() self.context.gui_context.update({'RebinType': 'None'}) self.loaded_data = self.context.data_context._loaded_data self.data_context = self.context.data_context self.gui_context = self.context.gui_context self.group_pair_context = self.context.group_pair_context self.data_context.instrument = 'EMU' self.loaded_data.add_data(workspace=self.load_result, run=[self.run_number], filename=self.filename, instrument='EMU') self.data_context.current_runs = [[self.run_number]] self.data_context.update_current_data() self.group_pair_context.reset_group_and_pairs_to_default(self.load_result['OutputWorkspace'][0].workspace, 'EMU', '', 1) self.run_list = [19489] self.groups = [MuonGroup("bwd"), MuonGroup("fwd")] self.rebins = [False, False] self.pairs = [MuonPair("long", "bwd", "fwd")]
def test_calculate_pair_returns_nothing_if_relevant_groups_do_not_exist(self): self._calculate_data_for(self.run_list, self.groups, self.rebins) long = MuonPair('long', 'fwd', 'bwd') pair_asymmetry = self.context.calculate_pair(long, self.run_list, True) self.assertEqual(pair_asymmetry, None)
def test_calculate_pair_calculates_pair_for_given_run(self): self._calculate_data_for(self.run_list, self.groups, self.rebins) long = MuonPair('long', 'fwd', 'bwd') pair_asymmetry = self.context.calculate_pair(long, self.run_list, False) self.assertEqual(pair_asymmetry, 'EMU19489; Pair Asym; long; MA')
def test_calculate_pair_returns_nothing_if_relevant_groups_do_not_exist( self): self.context.show_all_groups() long = MuonPair('long', 'fwd', 'bwd') pair_asymmetry = self.context.calculate_pair(long, [19489], True) self.assertEqual(pair_asymmetry, None)
def test_that_add_pair_button_adds_pair_to_end_of_table(self): self.add_two_pairs_to_table() self.presenter.add_pair(MuonPair(pair_name="new")) self.assertEqual( self.view.get_table_item_text(self.view.num_rows() - 1, 0), "new")
def setUp(self): self.context = setup_context(True) self.context.data_context.instrument = 'MUSR' self.context.gui_context.update({'RebinType': 'None'}) self.model = maxent_model.MaxEntModel() self.view = maxent_view_new.MaxEntView() self.presenter = maxent_presenter_new.MaxEntPresenter( self.view, self.context) file_path = FileFinder.findRuns('MUSR00022725.nxs')[0] ws, run, filename, _ = load_utils.load_workspace_from_filename( file_path) self.context.data_context._loaded_data.remove_data(run=run) self.context.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='MUSR') self.context.data_context.current_runs = [[22725]] self.context.update_current_data() test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75) self.context.group_pair_context.add_pair(pair=test_pair) self.view.warning_popup = mock.MagicMock()
def setUp(self): self._qapp = mock_widget.mockQapp() # Store an empty widget to parent all the views, and ensure they are deleted correctly self.obj = QtWidgets.QWidget() setup_context_for_tests(self) self.data_context.instrument = 'MUSR' self.gui_context.update({'RebinType': 'None'}) self.model = maxent_model.MaxEntModel() self.view = maxent_view_new.MaxEntView(self.obj) self.presenter = maxent_presenter_new.MaxEntPresenter(self.view, self.context) file_path = FileFinder.findRuns('MUSR00022725.nxs')[0] ws, run, filename = load_utils.load_workspace_from_filename(file_path) self.data_context._loaded_data.remove_data(run=run) self.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='MUSR') self.data_context.current_runs = [[22725]] self.context.update_current_data() test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75) self.group_context.add_pair(pair=test_pair) self.view.warning_popup = mock.MagicMock()
def load_grouping_from_XML(filename): """ Load group/pair data from an XML file (which can be produced using the save_grouping_to_XML() function :param filename: Full filepath to an xml file. :return: (groups, pairs), lists of MuonGroup, MuonPair objects respectively. """ tree = ET.parse(filename) root = tree.getroot() description = root.get('description') if not description: description = filename try: default = root.find('default').get('name') except (AttributeError, KeyError): default = '' group_names, group_ids = _get_groups_from_XML(root) pair_names, pair_groups, pair_alphas = _get_pairs_from_XML(root) groups, pairs = [], [] for i, group_name in enumerate(group_names): groups += [MuonGroup(group_name=group_name, detector_ids=group_ids[i])] for i, pair_name in enumerate(pair_names): pairs += [ MuonPair(pair_name=pair_name, forward_group_name=pair_groups[i][0], backward_group_name=pair_groups[i][1], alpha=pair_alphas[i]) ] return groups, pairs, description, default
def test_runinfo_correct(self): file_path = FileFinder.findRuns('MUSR00022725.nxs')[0] ws, run, filename = load_utils.load_workspace_from_filename(file_path) self.data_context._loaded_data.remove_data(run=run) self.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='MUSR') self.data_context.current_runs = [[22725]] self.context.update_current_data() test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75) self.group_context.add_pair(pair=test_pair) self.presenter.update_view_from_model() expected_string_list = [ 'Instrument:MUSR', 'Run:22725', 'Title:FeTeSeT=1F=100', 'Comment:FCfirstsample', 'Start:2009-03-24T04:18:58', 'End:2009-03-24T04:56:26', 'Counts(MEv):20.076704', 'GoodFrames:88540', 'CountsperGoodFrame:226.753', 'CountsperGoodFrameperdet:3.543', 'AverageTemperature(K):2.53386', 'SampleTemperature(K):1.0', 'SampleMagneticField(G):100.0' ] self.assertEqual( str(self.view.run_info_box.toPlainText()).replace(' ', '').splitlines(), expected_string_list)
def setUp(self): self.context = setup_context(True) self.context.data_context.instrument = 'MUSR' self.context.gui_context.update({'RebinType': 'None'}) self.view = fft_view_new.FFTView() self.model1 = fft_model.FFTModel() self.model = fft_model.FFTWrapper self.presenter = fft_presenter_new.FFTPresenter( self.view, self.model, self.context) file_path = FileFinder.findRuns('MUSR00022725.nxs')[0] ws, run, filename, _ = load_utils.load_workspace_from_filename(file_path) self.context.data_context._loaded_data.remove_data(run=run) self.context.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='MUSR') self.context.data_context.current_runs = [[22725]] self.context.update_current_data() test_pair = MuonPair(EXAMPLE_PAIR, 'top', 'bottom', alpha=0.75) self.context.group_pair_context.add_pair(pair=test_pair) self.context.show_all_groups() self.context.show_all_pairs() self.context.group_pair_context._selected_groups = GROUP_LIST self.context.group_pair_context._selected_pairs = [EXAMPLE_PAIR] self.view.warning_popup = mock.MagicMock()
def test_handle_plot_type_changed_displays_a_warning_if_trying_to_plot_counts_on_a_pair(self): self.context.group_pair_context.__getitem__.return_value = MuonPair('long', 'bwd', 'fwd') self.view.get_selected.return_value = 'Counts' self.presenter.handle_plot_type_changed() self.model.plot.assert_not_called() self.view.warning_popup.assert_called_once_with('Pair workspaces have no counts workspace')
def test_that_calculate_pair_for_calls_the_expected_methods(self): self.context._calculate_pair_for = mock.Mock() self.context._do_rebin = mock.Mock(return_value=False) pair = MuonPair("long", "fwd", "bwd") self.context.calculate_pair_for(self.run_list, pair) self.context._calculate_pair_for.assert_called_with(self.run_list, pair, rebin=False) self.assertEqual(self.context._calculate_pair_for.call_count, 1)
def test_that_show_all_calculates_and_shows_all_diffs_with_rebin(self): self.gui_context['RebinType'] = 'Fixed' self.gui_context['RebinFixed'] = 2 groups = [MuonGroup("bwd"), MuonGroup("bwd"), MuonGroup("fwd"), MuonGroup("fwd")] rebins = [False, True, False, True] group_diff = self.add_group_diff() pair_diff = self.add_pair_diff() pairs = [MuonPair("long", "bwd", "fwd"), MuonPair("long2", "bwd", "fwd")] diffs = [group_diff, pair_diff] self._calculate_data_for(self.run_list, groups, rebins, pairs, diffs) self._assert_list_in_ADS(['EMU19489 MA', 'EMU19489; Diff; group_diff; Asymmetry; MA', 'EMU19489; Diff; group_diff; Asymmetry; Rebin; MA', 'EMU19489; Diff; pair_diff; Asymmetry; MA', 'EMU19489; Diff; pair_diff; Asymmetry; Rebin; MA'])
def load_grouping_from_XML(filename): """ Load group/pair data from an XML file (which can be produced using the save_grouping_to_XML() function :param filename: Full filepath to an xml file. :return: (groups, pairs), lists of MuonGroup, MuonPair objects respectively. """ tree = ET.parse(filename) root = tree.getroot() description = root.get('description') if not description: description = filename try: default = root.find('default').get('name') except (AttributeError, KeyError): default = '' group_names, group_ids, periods = _get_groups_from_XML(root) pair_names, pair_groups, pair_alphas, pair_periods = _get_pairs_from_XML( root) diff_names, diff_groups, diff_periods = _get_diffs_from_XML(root) groups, diffs, pairs = [], [], [] for i, group_name in enumerate(group_names): period = periods[i] if periods and i < len(periods) else [1] groups += [ MuonGroup(group_name=group_name, detector_ids=group_ids[i], periods=period) ] for i, pair_name in enumerate(pair_names): if pair_periods: pair_periods_converted = _convert_periods_to_int(pair_periods[i]) else: pair_periods_converted = [1] pairs += [ MuonPair(pair_name=pair_name, forward_group_name=pair_groups[i][0], backward_group_name=pair_groups[i][1], alpha=pair_alphas[i], periods=pair_periods_converted) ] for i, diff_name in enumerate(diff_names): if diff_periods: diff_periods_converted = _convert_periods_to_int(diff_periods[i]) else: diff_periods_converted = [1] diffs += [ MuonDiff(diff_name, diff_groups[i][0], diff_groups[i][1], diff_groups[i][2], diff_periods_converted) ] return groups, pairs, diffs, description, default
def test_parameters_correct_for_pairing_asymmetry(self): pair=MuonPair('long1', 'group_1', 'group2', 1.0) params = _get_MuonPairingAsymmetry_parameters(pair, 'group_1_counts', 'group_2_counts') self.assertEqual(params, {'Alpha': '1.0', 'InputWorkspace1': 'group_1_counts', 'InputWorkspace2': 'group_2_counts', 'PairName': 'long1', 'SpecifyGroupsManually': False})
def update_model_from_view(self, table=None): if not table: table = self._view.get_table_contents() self._model.clear_pairs() for entry in table: pair = MuonPair(pair_name=str(entry[0]), backward_group_name=str(entry[2]), forward_group_name=str(entry[1]), alpha=float(entry[3])) self._model.add_pair(pair)
def test_that_save_and_load_grouping_xml_correctly_stores_and_reads_period_data(self, mock_file_parse): groups = [MuonGroup('fwd', [1,2,3], [1,3]), MuonGroup('bwd', [4,5,6], [2,4])] pairs = [MuonPair('long', 'fwd', 'bwd')] xml_tree = save_grouping_to_XML(groups, pairs, 'filename.xml', save=False, description='Bespoke grouping') mock_file_parse.return_value = xml_tree loaded_groups, loaded_pairs, loaded_description, loaded_default = load_grouping_from_XML('filename.xml') self.assertEqual(loaded_groups[0].periods, groups[0].periods) self.assertEqual(loaded_groups[1].periods, groups[1].periods)
def test_groups_pairs_diffs_should_all_have_unique_names(self): group_1 = MuonGroup('group', [1, 3, 5, 7, 9]) group_2 = MuonGroup('pair', [1, 3, 5, 7, 9]) group_3 = MuonGroup('diff', [1, 3, 5, 7, 9]) pair_1 = MuonPair('pair') pair_2 = MuonPair('group') pair_3 = MuonPair('diff') diff_1 = MuonDiff('diff', 'positive', 'negative') diff_2 = MuonDiff('group', 'positive', 'negative') diff_3 = MuonDiff('pair', 'positive', 'negative') # Add correct group, pair and diff self.context.add_group(group_1) self.context.add_pair(pair_1) self.context.add_diff(diff_1) # Now check cannot duplicate names self.assertRaises(ValueError, self.context.add_group, group_2) self.assertRaises(ValueError, self.context.add_group, group_3) self.assertRaises(ValueError, self.context.add_pair, pair_2) self.assertRaises(ValueError, self.context.add_pair, pair_3) self.assertRaises(ValueError, self.context.add_diff, diff_2) self.assertRaises(ValueError, self.context.add_diff, diff_3)
def handle_add_pair_button_clicked(self, group_1='', group_2=''): if len(self._model.group_names) == 0 or len(self._model.group_names) == 1: self._view.warning_popup("At least two groups are required to create a pair") else: new_pair_name = self._view.enter_pair_name() if new_pair_name is None: return elif new_pair_name in self._model.group_and_pair_names: self._view.warning_popup("Groups and pairs must have unique names") elif self.validate_pair_name(new_pair_name): group1 = self._model.group_names[0] if not group_1 else group_1 group2 = self._model.group_names[1] if not group_2 else group_2 pair = MuonPair(pair_name=str(new_pair_name), forward_group_name=group1, backward_group_name=group2, alpha=1.0) self.add_pair(pair) self.notify_data_changed()
def test_that_removing_groups_and_then_calling_update_removes_groups_from_selections( self): pair = MuonPair(pair_name="my_pair_1", forward_group_name="my_group_1", backward_group_name="my_group_2", alpha=1.0) self.presenter.add_pair(pair) self.group_context.remove_group("my_group_0") self.presenter.update_view_from_model() self.assertEqual(self.get_group_1_selector_from_pair(0).count(), 2) self.assertEqual(self.get_group_2_selector_from_pair(0).count(), 2) self.assertEqual( self.get_group_1_selector_from_pair(0).findText("my_group_0"), -1) self.assertEqual( self.get_group_2_selector_from_pair(0).findText("my_group_0"), -1)
def perform_psi_file_finder(self): file_path = FileFinder.findRuns('deltat_tdc_dolly_1529.bin')[0] ws, run, filename, psi_data = load_utils.load_workspace_from_filename( file_path) self.assert_(psi_data) self.data_context._loaded_data.remove_data(run=run) self.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='PSI') self.data_context.current_runs = [[1529]] self.context.data_context._instrument = "PSI" self.context.update_current_data() test_pair = MuonPair('test_pair1', 'Forw', 'Back', alpha=0.75) self.group_context.add_pair(pair=test_pair) self.presenter.update_group_pair_list()
def reset_group_and_pairs_to_default(self, workspace, instrument, main_field_direction, num_periods): default_groups, default_pairs, default_diffs, default_selected = get_default_grouping( workspace, instrument, main_field_direction) if num_periods == 1: self._groups = default_groups self._diffs = default_diffs self._pairs = default_pairs self._selected = default_selected else: periods = range(num_periods + 1)[1:] self._groups = [] self._diffs = [] self._pairs = [] for period in periods: for group in default_groups: self._groups.append( MuonGroup(group.name + str(period), group.detectors, [period])) for period in periods: for pair in default_pairs: self._pairs.append( MuonPair(pair.name + str(period), pair.forward_group + str(period), pair.backward_group + str(period), pair.alpha, [period])) if default_diffs: for diff in default_diffs: self._diffs.append( MuonDiff(diff.name, diff.forward, diff.backward, diff.group_or_pair, diff.periods)) else: for index in range(0, floor(len(periods) / 2.)): for pair in default_pairs: odd_period = index * 2 + 1 even_period = odd_period + 1 self._diffs.append( MuonDiff("pair_diff" + str(index + 1), pair.name + str(odd_period), pair.name + str(even_period), group_or_pair="pair", periods=[odd_period, even_period])) self._selected = self.pair_names[0]
def perform_musr_file_finder(self): ConfigService['default.instrument'] = 'MUSR' file_path = FileFinder.findRuns('MUSR00022725.nxs')[0] ws, run, filename, psi_data = load_utils.load_workspace_from_filename( file_path) self.assert_(not psi_data) self.data_context._loaded_data.remove_data(run=run) self.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='MUSR') self.data_context.current_runs = [[22725]] self.context.data_context._instrument = "MUSR" self.context.update_current_data() test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75) self.group_context.add_pair(pair=test_pair) self.presenter.update_group_pair_list()
def reset_group_and_pairs_to_default(self, workspace, instrument, main_field_direction, num_periods): default_groups, default_pairs, default_selected = get_default_grouping(workspace, instrument, main_field_direction) if num_periods == 1: self._groups = default_groups self._pairs = default_pairs self._selected = default_selected else: periods = range(num_periods + 1)[1:] self._groups = [] self._pairs = [] for period in periods: for group in default_groups: self._groups.append(MuonGroup(group.name + str(period), group.detectors, [period])) for period in periods: for pair in default_pairs: self._pairs.append(MuonPair(pair.name + str(period), pair.forward_group + str(period), pair.backward_group + str(period), pair.alpha)) self._selected = self.pair_names[0]
def construct_empty_pair(group_names, pair_names, pair_index=0): """ Create an empty MuonPair appropriate for adding to the current pairing table. """ new_pair_name = "pair_" + str(pair_index) while new_pair_name in pair_names: # modify the name until it is unique pair_index += 1 new_pair_name = "pair_" + str(pair_index) if len(group_names) == 1: group1 = group_names[0] group2 = group_names[0] elif len(group_names) >= 2: group1 = group_names[0] group2 = group_names[1] else: group1 = None group2 = None return MuonPair(pair_name=new_pair_name, forward_group_name=group1, backward_group_name=group2, alpha=1.0)
def load_grouping_from_XML(filename): """ Load group/pair data from an XML file (which can be produced using the save_grouping_to_XML() function :param filename: Full filepath to an xml file. :return: (groups, pairs), lists of MuonGroup, MuonPair objects respectively. """ tree = ET.parse(filename) root = tree.getroot() group_names, group_ids = _get_groups_from_XML(root) pair_names, pair_groups, pair_alphas = _get_pairs_from_XML(root) groups, pairs = [], [] for i, group_name in enumerate(group_names): groups += [MuonGroup(group_name=group_name, detector_ids=group_ids[i])] for i, pair_name in enumerate(pair_names): pairs += [MuonPair(pair_name=pair_name, forward_group_name=pair_groups[i][0], backward_group_name=pair_groups[i][1], alpha=pair_alphas[i])] return groups, pairs
def add_two_pairs_to_table(self): pair1 = MuonPair(pair_name="my_pair_0", forward_group_name="my_group_0", backward_group_name="my_group_1", alpha=1.0) pair2 = MuonPair(pair_name="my_pair_1", forward_group_name="my_group_1", backward_group_name="my_group_2", alpha=1.0) self.presenter.add_pair(pair1) self.presenter.add_pair(pair2)
def test_that_cannot_add_negative_alpha(self): pair = MuonPair(pair_name="pair1") with self.assertRaises(AttributeError): pair.alpha = -1.0 pair.alpha = "-1.0"
def test_that_can_set_string_value_for_alpha(self): pair = MuonPair(pair_name="pair1") pair.alpha = "2.0" self.assertEqual(pair.alpha, 2.0)
def test_that_can_set_and_get_float_value_for_alpha(self): pair = MuonPair(pair_name="pair1") pair.alpha = 2.0 self.assertEqual(pair.alpha, 2.0)
def test_that_cannot_set_new_name_on_pair(self): pair = MuonPair(pair_name="pair1") with self.assertRaises(AttributeError): pair.name = "new_name" self.assertEqual(pair.name, "pair1")
def test_that_can_get_and_set_group2_name(self): pair = MuonPair(pair_name="pair1") pair.backward_group = "group2" self.assertEqual(pair.backward_group, "group2")