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