def test_that_can_have_group_with_no_detectors(self):
group = MuonGroup(group_name="group1")
group.detectors = []
self.assertEqual(group.detectors, [])
self.assertEqual(group.n_detectors, 0)
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_can_have_group_with_no_detectors(self):
group = MuonGroup(group_name="group1")
group.detectors = []
self.assertEqual(group.detectors, [])
self.assertEqual(group.n_detectors, 0)
def test_when_adding_group_to_empty_table_it_is_selected(self):
self.presenter.add_group(
MuonGroup(group_name='group_1', detector_ids=[1, 2, 3, 4]))
self.presenter.add_group(
MuonGroup(group_name='group_2', detector_ids=[1, 2, 3, 4]))
self.assertEquals(self.model.selected_groups, ['group_1'])
def test_that_AttributeError_thrown_if_setting_workspace_to_non_MuonWorkspace_object(self):
group = MuonGroup(group_name="group1")
self.assertEqual(group.workspace, {})
with self.assertRaises(AttributeError):
group.workspace = [1, 2, 3]
self.assertEqual(group.workspace, {})
def test_that_detector_ids_cannot_be_set_as_string(self):
group = MuonGroup(group_name="group1")
with self.assertRaises(AttributeError):
group.detectors = "1"
group.detectors = "[1]"
group.detectors = "1,2"
def add_three_groups_to_table(self):
group1 = MuonGroup(group_name="my_group_0", detector_ids=[1])
group2 = MuonGroup(group_name="my_group_1", detector_ids=[2])
group3 = MuonGroup(group_name="my_group_2", detector_ids=[3])
self.presenter.add_group(group1)
self.presenter.add_group(group2)
self.presenter.add_group(group3)
def add_three_groups_to_model(self):
group1 = MuonGroup(group_name="my_group_0", detector_ids=[1])
group2 = MuonGroup(group_name="my_group_1", detector_ids=[2])
group3 = MuonGroup(group_name="my_group_2", detector_ids=[3])
self.group_context.add_group(group1)
self.group_context.add_group(group2)
self.group_context.add_group(group3)
def test_that_AttributeError_thrown_if_setting_workspace_to_non_MuonWorkspace_object(self):
group = MuonGroup(group_name="group1")
self.assertEqual(group.workspace, {})
with self.assertRaises(AttributeError):
group.workspace = [1, 2, 3]
self.assertEqual(group.workspace, {})
def test_that_detector_ids_cannot_be_set_as_string(self):
group = MuonGroup(group_name="group1")
with self.assertRaises(AttributeError):
group.detectors = "1"
group.detectors = "[1]"
group.detectors = "1,2"
def test_cannot_add_group_with_duplicate_name(self):
group_1 = MuonGroup('group_1', [1, 3, 5, 7, 9])
group_2 = MuonGroup('group_1', [1, 3, 5, 7, 9])
self.context.add_group(group_1)
self.assertRaises(ValueError, self.context.add_group, group_2)
def test_that_can_set_workspace_if_MuonWorkspace_object(self):
group = MuonGroup(group_name="group1")
dataX = [0, 1, 2, 3, 4, 5]
dataY = [10, 20, 30, 20, 10]
input_workspace = CreateWorkspace(dataX, dataY)
self.assertEqual(group.workspace, {})
group.workspace = MuonWorkspaceWrapper(input_workspace)
self.assertIsNotNone(group.workspace)
def test_that_can_set_workspace_if_MuonWorkspace_object(self):
group = MuonGroup(group_name="group1")
dataX = [0, 1, 2, 3, 4, 5]
dataY = [10, 20, 30, 20, 10]
input_workspace = CreateWorkspace(dataX, dataY)
self.assertEqual(group.workspace, {})
group.workspace = MuonWorkspaceWrapper(input_workspace)
self.assertIsNotNone(group.workspace)
def test_cannot_add_group_diff_without_two_groups(self):
self.presenter.group_widget.handle_add_diff_button_clicked() # No groups
group0 = MuonGroup(group_name="group_0", detector_ids=[1])
self.model.add_group(group0)
self.presenter.group_widget.handle_add_diff_button_clicked() # 1 group
group1 = MuonGroup(group_name="group_1", detector_ids=[2])
self.model.add_group(group1)
self.presenter.group_widget.handle_add_diff_button_clicked() # 2 groups
self.assertEqual(2,self.presenter.group_view.warning_popup.call_count)
def test_group_names_returns_ordered_list_of_names(self):
group_1 = MuonGroup('group_1', [1, 3, 5, 7, 9])
group_2 = MuonGroup('group_2', [1, 3, 4, 7, 9])
group_3 = MuonGroup('group_3', [1, 3, 4, 7, 9])
self.context.add_group(group_1)
self.context.add_group(group_3)
self.context.add_group(group_2)
self.assertEqual(self.context.group_names, ['group_1', 'group_3', 'group_2'])
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_can_remove_groups_as_expected(self):
group_1 = MuonGroup('group_1', [1, 3, 5, 7, 9])
group_2 = MuonGroup('group_2', [1, 3, 4, 7, 9])
group_3 = MuonGroup('group_3', [1, 3, 4, 7, 9])
self.context.add_group(group_1)
self.context.add_group(group_2)
self.context.add_group(group_3)
self.context.remove_group('group_1')
self.assertEqual(self.context.group_names, ['group_2', 'group_3'])
def setUp(self):
self.model = PlotGroupPairModel(context=self.context, name="test")
self.context.group_pair_context._groups = []
self.context.group_pair_context._pairs = []
self.context.group_pair_context._selected_pairs = []
self.context.group_pair_context.add_group(MuonGroup(group_name="fwd", detector_ids=[1]))
self.context.group_pair_context.add_group(MuonGroup(group_name="bwd", detector_ids=[2]))
self.context.group_pair_context.add_group(MuonGroup(group_name="top", detector_ids=[3]))
self.context.group_pair_context._selected_groups = ["fwd", "bwd", "top"]
runs = [[62260], [62261]]
self.context.data_context.current_runs = runs
def test_that_adding_two_groups_and_then_pair_sets_combo_to_added_groups(
self):
self.data.add_group(
MuonGroup(group_name="my_group_0", detector_ids=[1]))
self.data.add_group(
MuonGroup(group_name="my_group_1", detector_ids=[2]))
self.presenter.handle_add_pair_button_clicked()
self.assertEqual(
self.get_group_1_selector_from_pair(0).currentText(), "my_group_0")
self.assertEqual(
self.get_group_2_selector_from_pair(0).currentText(), "my_group_1")
def test_create_tiled_keys_returns_correctly_for_tiled_by_group(self):
self.context.group_pair_context.add_group(
MuonGroup(group_name="bwd", detector_ids=[2]))
self.context.group_pair_context.add_group(
MuonGroup(group_name="top", detector_ids=[3]))
self.context.group_pair_context._selected_groups = [
"fwd", "bwd", "top"
]
runs = [[62260], [62261]]
self.context.data_context.current_runs = runs
keys = self.model.create_tiled_keys("Group/Pair")
self.assertEqual(keys, ["fwd", "bwd", "top"])
def create_group_populated_by_two_workspace():
group = MuonGroup(group_name="group1")
counts_workspace_22222 = CreateWorkspace([0], [0])
asymmetry_workspace_22222 = CreateWorkspace([0], [0])
group.update_workspaces([22222], counts_workspace_22222,
asymmetry_workspace_22222, False)
group.show_raw([22222], 'counts_name_22222', 'asymmetry_name_22222')
counts_workspace_33333 = CreateWorkspace([0], [0])
asymmetry_workspace_33333 = CreateWorkspace([0], [0])
group.update_workspaces([33333], counts_workspace_33333,
asymmetry_workspace_33333, False)
group.show_raw([33333], 'counts_name_33333', 'asymmetry_name_33333')
return group
def setUp(self):
self.view = PhaseTableView()
self.context = setup_context()
self.context.data_context.instrument = 'MUSR'
self.presenter = PhaseTablePresenter(self.view, self.context)
forward_group = MuonGroup(group_name="fwd", detector_ids=[1,3,5,7,9])
backward_group = MuonGroup(group_name="bwd", detector_ids=[2,4,6,8,10])
self.context.group_pair_context.add_group(forward_group)
self.context.group_pair_context.add_group(backward_group)
self.presenter.update_current_groups_list()
self.view.warning_popup = mock.MagicMock()
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 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 test_parameters_correct_for_MuonGroupingCounts(self):
group = MuonGroup('fwd', [1,2,3,4,5], [1,2])
periods = [1]
params = _get_MuonGroupingCounts_parameters(group, periods)
self.assertEquals(params, {'GroupName': 'fwd', 'Grouping': '1,2,3,4,5', 'SummedPeriods': [1]})
def test_get_workspaces_to_plot(self):
selected = ["fwd", "bwd", "top"]
self.model.get_time_workspaces_to_plot = mock.Mock(return_value="test")
self.context.group_pair_context.add_group(
MuonGroup(group_name="bwd", detector_ids=[2]))
self.context.group_pair_context.add_group(
MuonGroup(group_name="top", detector_ids=[3]))
self.context.group_pair_context._selected_groups = selected
self.model.get_workspaces_to_plot(True, "Counts", selected)
self.assertEqual(self.model.get_time_workspaces_to_plot.call_count, 3)
self.model.get_time_workspaces_to_plot.assert_any_call(
"fwd", True, "Counts")
self.model.get_time_workspaces_to_plot.assert_any_call(
"bwd", True, "Counts")
self.model.get_time_workspaces_to_plot.assert_any_call(
"top", True, "Counts")
def create_group_populated_by_two_rebinned_workspaces():
group = MuonGroup(group_name="group1")
counts_workspace_22222 = CreateWorkspace([0], [0])
asymmetry_workspace_22222 = CreateWorkspace([0], [0])
group.update_workspaces([22222], counts_workspace_22222,
asymmetry_workspace_22222, True)
group.show_rebin([22222], 'counts_name_22222_rebin',
'asymmetry_name_22222_rebin')
counts_workspace_33333 = CreateWorkspace([0], [0])
asymmetry_workspace_33333 = CreateWorkspace([0], [0])
group.update_workspaces([33333], counts_workspace_33333,
asymmetry_workspace_33333, True)
group.show_rebin([33333], 'counts_name_33333_rebin',
'asymmetry_name_33333_rebin')
return group
def test_non_pair_cannot_be_added(self):
group = MuonGroup('group_1', [1, 3, 5, 7, 9])
diff = MuonDiff('diff_1', 'positive', 'negative')
# Value error as cannot assert isinstance in code since could add MuonPair or MuonBasePair
self.assertRaises(ValueError, self.context.add_pair, group)
self.assertRaises(ValueError, self.context.add_pair, diff)
def test_handle_plot_type_changed_calls_add_workspace_to_plot(self):
self.context.group_pair_context.__getitem__.return_value = MuonGroup(
'bottom', [])
self.presenter.workspace_finder.get_workspaces_to_plot = mock.MagicMock(
return_value=self.workspace_list)
self.presenter.get_workspace_legend_label = mock.MagicMock(
return_value='label')
self.view.get_selected.return_value = 'Counts'
plot_kwargs = {
'distribution': True,
'autoscale_on_update': False,
'label': 'label'
}
self.presenter.handle_plot_type_changed()
self.model.add_workspace_to_plot.assert_any_call(
self.view.get_axes()[0],
self.workspace_list[0], [0],
errors=True,
plot_kwargs=plot_kwargs)
self.model.add_workspace_to_plot.assert_called_with(
self.view.get_axes()[0],
self.workspace_list[1], [0],
errors=True,
plot_kwargs=plot_kwargs)
def test_that_add_group_button_adds_group_to_end_of_table(self):
self.add_three_groups_to_table()
self.presenter.add_group(MuonGroup(group_name="new", detector_ids=[4]))
self.assertEqual(
self.view.get_table_item_text(self.view.num_rows() - 1, 0), "new")
def setUp(self):
self.model = PlotWidgetModel(context=self.context)
test_group = MuonGroup(group_name="fwd", detector_ids=[1, 2, 3, 4, 5])
self.context.group_pair_context._groups = [test_group]
self.context.group_pair_context._pairs = []
self.context.group_pair_context._selected_groups = ["fwd"]
self.context.group_pair_context._selected_pairs = []
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_that_adding_pair_then_adding_group_puts_group_in_combos(self):
self.presenter.handle_add_pair_button_clicked()
self.data.add_group(
MuonGroup(group_name="my_group_0", detector_ids=[1]))
self.presenter.update_view_from_model()
self.assertEqual(self.get_group_1_selector_from_pair(0).count(), 1)
self.assertEqual(self.get_group_2_selector_from_pair(0).count(), 1)
def update_model_from_view(self):
table = self._view.get_table_contents()
self._model.clear_groups()
for entry in table:
detector_list = run_utils.run_string_to_list(str(entry[2]), False)
group = MuonGroup(group_name=str(entry[0]),
detector_ids=detector_list)
self._model.add_group(group)
def get_grouping_psi(workspace):
grouping_list = []
sample_log_value_list = []
for ii in range(0, workspace.getNumberHistograms()):
sample_log_label_name = "Label Spectra " + str(ii)
workspace_run = workspace.getRun()
if workspace_run.hasProperty(sample_log_label_name):
sample_log_value = workspace_run.getProperty(sample_log_label_name).value
if sample_log_value not in sample_log_value_list:
grouping_list.append(MuonGroup(sample_log_value, [ii + 1]))
else:
sample_log_value += get_incremental_number_for_value_in_list(sample_log_value, sample_log_value_list)
grouping_list.append(MuonGroup(sample_log_value, [ii + 1]))
sample_log_value_list.append(sample_log_value)
return grouping_list, [], ''
def test_that_cannot_set_new_name_on_group(self):
group = MuonGroup(group_name="group1")
with self.assertRaises(AttributeError):
group.name = "new_name"
self.assertEqual(group.name, "group1")
def test_that_detectors_set_as_list_of_ints_is_set_correctly(self):
group = MuonGroup(group_name="group1")
group.detectors = [1, 2, 3, 4, 5]
self.assertEqual(group.detectors, [1, 2, 3, 4, 5])
def test_that_number_of_detectors_is_correct(self):
group = MuonGroup(group_name="group1")
group.detectors = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
self.assertEqual(group.n_detectors, 5)
def test_that_detectors_always_in_ascending_order(self):
group = MuonGroup(group_name="group1")
group.detectors = [5, 4, 3, 2, 1]
self.assertEqual(group.detectors, [1, 2, 3, 4, 5])
def test_that_duplicated_detectors_are_removed(self):
group = MuonGroup(group_name="group1")
group.detectors = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
self.assertEqual(group.detectors, [1, 2, 3, 4, 5])
