def test_get_fit_workspace_names_from_groups_and_runs_when_fit_to_raw_is_true(self): self.model.fit_to_raw = True self.model.context.data_context.instrument = "MUSR" self.model.context.group_pair_context.add_pair(MuonPair("long", "f", "b", 1.0)) self.model.context.group_pair_context.add_pair(MuonPair("long2", "f", "b", 2.0)) self.model.context.group_pair_context.add_pair(MuonBasePair("phase_Re_")) self.model.context.group_pair_context.add_pair(MuonBasePair("phase_Im_")) self.model.context.group_pair_context.add_pair(MuonBasePair("phase2_Re_")) self.model.context.group_pair_context.add_pair(MuonBasePair("phase2_Im_")) self.model.context.group_pair_context.add_pair_to_selected_pairs("long") self.model.context.group_pair_context.add_pair_to_selected_pairs("phase_Re_") self.model.context.group_pair_context.add_pair_to_selected_pairs("phase2_Im_") selection = ["long", "long2", "phase_Re_", "phase_Im_", "phase2_Re_", "phase2_Im_"] result = self.model.get_fit_workspace_names_from_groups_and_runs([1, 2, 3], selection) self.assertEqual(["MUSR1; Pair Asym; long; MA", "MUSR1; PhaseQuad; phase_Re_; MA", "MUSR1; PhaseQuad; phase2_Im_; MA", "MUSR2; Pair Asym; long; MA", "MUSR2; PhaseQuad; phase_Re_; MA", "MUSR2; PhaseQuad; phase2_Im_; MA", "MUSR3; Pair Asym; long; MA", "MUSR3; PhaseQuad; phase_Re_; MA", "MUSR3; PhaseQuad; phase2_Im_; MA"], result)
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; 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 test_cannot_add_pair_with_duplicate_name(self): pair_1 = MuonPair('pair') pair_2 = MuonPair('pair') self.context.add_pair(pair_1) self.assertRaises(ValueError, self.context.add_pair, pair_2)
def test_that_AttributeError_thrown_if_setting_workspace_to_non_MuonWorkspace_object( self): pair = MuonPair(pair_name="pair1") self.assertEqual(pair.workspace, {}) with self.assertRaises(AttributeError): pair.workspace = [1, 2, 3] self.assertEqual(pair.workspace, {})
def test_that_can_only_set_workspace_if_MuonWorkspace_object(self): pair = MuonPair(pair_name="pair1") self.assertEqual(pair.workspace, {}) dataX = [0, 1, 2, 3, 4, 5] dataY = [10, 20, 30, 20, 10] input_workspace = CreateWorkspace(dataX, dataY) workspace_wrapper = MuonWorkspaceWrapper(input_workspace) pair.workspace = workspace_wrapper self.assertEqual(pair.workspace, workspace_wrapper)
def add_two_pairs(self): pair0 = MuonPair(pair_name="pair_0", forward_group_name="group_0", backward_group_name="group_1", alpha=1.0) pair1 = MuonPair(pair_name="pair_1", forward_group_name="group_1", backward_group_name="group_0", alpha=1.0) self.model.add_pair(pair0) self.model.add_pair(pair1)
def test_pair_names_returns_ordered_list_of_names(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.assertEqual(self.context.pair_names, ['pair_1', 'pair_2', 'pair_3'])
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_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_calculate_pair_diff_calculates_diff_for_given_run(self): diff = self.add_pair_diff() pairs = [ MuonPair("long", "bwd", "fwd"), MuonPair("long2", "bwd", "fwd") ] diffs = [diff] self._calculate_data_for(self.run_list, self.groups, self.rebins, pairs, diffs) self._assert_list_in_ADS(['EMU19489; Diff; pair_diff; Asymmetry; MA'])
def test_cannot_add_pair_diff_without_two_pairs(self): self.presenter.pair_widget.handle_add_diff_button_clicked() # No pairs pair0 = MuonPair(pair_name="pair_0", forward_group_name="group_1", backward_group_name="group_0", alpha=1.0) self.model.add_pair(pair0) self.presenter.pair_widget.handle_add_diff_button_clicked() # 1 pair pair1 = MuonPair(pair_name="pair_1", forward_group_name="group_0", backward_group_name="group_1", alpha=1.0) self.model.add_pair(pair1) self.presenter.pair_widget.handle_add_diff_button_clicked() # 2 pairs self.assertEqual(2, self.presenter.pair_view.warning_popup.call_count)
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_that_show_all_calculates_and_shows_all_diffs(self): 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, self.groups, self.rebins, pairs, diffs) self._assert_list_in_ADS([ 'EMU19489; Diff; group_diff; Asymmetry; MA', 'EMU19489; Diff; pair_diff; Asymmetry; MA' ])
def setUp(self): self.context = setup_context(True) self.context.data_context.instrument = 'MUSR' self.context.data_context.num_periods = mock.Mock(return_value=1) self.context.gui_context.update({'RebinType': 'None'}) self.view = maxent_view.MaxEntView() self.presenter = maxent_presenter.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._count = 0 self.view.warning_popup = mock.MagicMock()
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 = [ call("Instrument : MUSR"), call("Run : 22725"), call("Title : FeTeSe T=1 F=100"), call("Comment : FC first sample"), call("Start : 2009-03-24T04:18:58"), call("End : 2009-03-24T04:56:26"), call("Counts (MEv) : 20.076704"), call("Good Frames : 88540"), call("Counts per Good Frame : 226.753"), call("Counts per Good Frame per det : 3.543"), call("Average Temperature (K) : 19.69992"), call("Sample Temperature (K) : 1.0"), call("Sample Magnetic Field (G) : 100.0"), call("Number of DAQ Periods : 1") ] self.assertEqual(self.view.add_text_line.call_args_list, expected)
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 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_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", forward_group_name='my_group_0', backward_group_name='my_group_1')) self.assertEqual( self.view.get_table_item_text(self.view.num_rows() - 1, 0), "new")
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_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')] diffs = [] xml_tree = save_grouping_to_XML(groups, pairs, diffs, 'filename.xml', save=False, description='Bespoke grouping') mock_file_parse.return_value = xml_tree loaded_groups, loaded_pairs, diffs, 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 update_model_from_view(self, table=None): if not table: table = self._view.get_table_contents() self._model.clear_pairs() for entry in table: periods = self._model.get_periods(str(entry[2]))+self._model.get_periods(str(entry[3])) pair = MuonPair(pair_name=str(entry[0]), backward_group_name=str(entry[3]), forward_group_name=str(entry[2]), alpha=float(entry[4]), periods = periods) self._model.add_pair(pair)
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 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 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 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 periods = self._model.get_periods(group1)+self._model.get_periods(group2) pair = MuonPair(pair_name=str(new_pair_name), forward_group_name=group1, backward_group_name=group2, alpha=1.0, periods=periods) self.add_pair(pair) self.notify_data_changed()
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 setUp(self): self.context = setup_context(True) self.context.data_context.instrument = 'MUSR' self.context.gui_context.update({'RebinType': 'None'}) self.view = fft_view.FFTView() self.model1 = fft_model.FFTModel() self.model = fft_model.FFTWrapper self.run_list = [22725] self.groups = [MuonGroup(group) for group in GROUP_LIST] self.rebins = [False] * len(self.groups) self.pairs = [MuonPair(EXAMPLE_PAIR, 'top', 'bottom', alpha=0.75)] self.presenter = fft_presenter.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() self.context.group_pair_context.add_pair(pair=self.pairs[0]) self._calculate_all_data() 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_that_cannot_add_negative_alpha(self): pair = MuonPair(pair_name="pair1") with self.assertRaises(AttributeError): pair.alpha = -1.0 pair.alpha = "-1.0"
def add_pair_diff(self): long2 = MuonPair('long2', 'bwd', 'fwd') self.group_pair_context.add_pair(long2) diff = MuonDiff('pair_diff', 'long', 'long2', 'pair') self.group_pair_context.add_diff(diff) return diff