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