def setup_context(freq=False):
loaded_data = MuonLoadData()
loaded_data.get_main_field_direction = mock.MagicMock(return_value='transverse')
data_context = MuonDataContext(load_data=loaded_data)
gui_context = MuonGuiContext()
group_context = MuonGroupPairContext(data_context.check_group_contains_valid_detectors)
corrections_context = CorrectionsContext(loaded_data)
phase_table_context = PhaseTableContext()
freq_context = FrequencyContext()
plot_panes_context = PlotPanesContext()
if freq:
return FrequencyDomainAnalysisContext(muon_data_context=data_context,
muon_group_context=group_context,
muon_gui_context=gui_context,
muon_phase_context=phase_table_context,
corrections_context=corrections_context,
fitting_context=BasicFittingContext(allow_double_pulse_fitting=True),
frequency_context=freq_context,
plot_panes_context=plot_panes_context)
else:
return DataAnalysisContext(muon_data_context=data_context,
muon_group_context=group_context,
muon_gui_context=gui_context,
corrections_context=corrections_context,
muon_phase_context=phase_table_context,
fitting_context=TFAsymmetryFittingContext(allow_double_pulse_fitting=True),
results_context=ResultsContext(),
model_fitting_context=ModelFittingContext(),
plot_panes_context=plot_panes_context)
def setup_context_for_tests(parent_object):
parent_object.loaded_data = MuonLoadData()
parent_object.loaded_data.get_main_field_direction = mock.MagicMock(return_value='transverse')
parent_object.data_context = MuonDataContext(load_data=parent_object.loaded_data)
parent_object.gui_context = MuonGuiContext()
parent_object.group_context = MuonGroupPairContext(parent_object.data_context.check_group_contains_valid_detectors)
parent_object.corrections_context = CorrectionsContext(parent_object.loaded_data)
parent_object.phase_table_context = PhaseTableContext()
parent_object.fitting_context = TFAsymmetryFittingContext(allow_double_pulse_fitting=True)
parent_object.results_context = ResultsContext()
parent_object.plot_panes_context = PlotPanesContext()
parent_object.model_fitting_context = ModelFittingContext()
parent_object.context = DataAnalysisContext(muon_data_context=parent_object.data_context,
muon_group_context=parent_object.group_context,
muon_gui_context=parent_object.gui_context,
muon_phase_context=parent_object.phase_table_context,
corrections_context=parent_object.corrections_context,
fitting_context=parent_object.fitting_context,
results_context=parent_object.results_context,
model_fitting_context=parent_object.model_fitting_context,
plot_panes_context=parent_object.plot_panes_context)
def __init__(self, parent=None, window_flags=None):
super(FrequencyAnalysisGui, self).__init__(parent)
if window_flags:
self.setWindowFlags(window_flags)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.setFocusPolicy(QtCore.Qt.StrongFocus)
try:
check_facility()
except AttributeError as error:
self.warning_popup(error.args[0])
# load the feature flags
feature_dict = load_features()
# initialise the data storing classes of the interface
self.loaded_data = MuonLoadData()
self.data_context = MuonDataContext('Frequency Domain Data',
self.loaded_data)
self.gui_context = MuonGuiContext()
self.plot_panes_context = PlotPanesContext()
self.group_pair_context = MuonGroupPairContext(
self.data_context.check_group_contains_valid_detectors)
self.corrections_context = CorrectionsContext(self.loaded_data)
self.phase_context = PhaseTableContext()
self.fitting_context = BasicFittingContext(
allow_double_pulse_fitting=True)
self.results_context = ResultsContext()
self.model_fitting_context = ModelFittingContext(
allow_double_pulse_fitting=False)
self.frequency_context = FrequencyContext()
self.context = FrequencyDomainAnalysisContext(
muon_data_context=self.data_context,
muon_gui_context=self.gui_context,
muon_group_context=self.group_pair_context,
corrections_context=self.corrections_context,
muon_phase_context=self.phase_context,
plot_panes_context=self.plot_panes_context,
fitting_context=self.fitting_context,
results_context=self.results_context,
model_fitting_context=self.model_fitting_context,
frequency_context=self.frequency_context)
# create the dockable widget
self.plot_widget = FrequencyAnalysisPlotWidget(self.context,
parent=self)
self.dockable_plot_widget_window = PlottingDockWidget(
parent=self, plotting_widget=self.plot_widget.view)
self.dockable_plot_widget_window.setMinimumWidth(575)
# Add dock widget to main Muon analysis window
self.addDockWidget(QtCore.Qt.RightDockWidgetArea,
self.dockable_plot_widget_window)
# Need this line to stop the bug where the dock window snaps back to its original size after resizing.
# 0 argument is arbitrary and has no effect on fit widget size
# This is a qt bug reported at (https://bugreports.qt.io/browse/QTBUG-65592)
if QT_VERSION >= LooseVersion("5.6"):
self.resizeDocks({self.dockable_plot_widget_window}, {1},
QtCore.Qt.Horizontal)
# construct all the widgets.
self.load_widget = LoadWidget(self.loaded_data, self.context, self)
self.grouping_tab_widget = GroupingTabWidget(self.context, parent)
self.corrections_tab = CorrectionsTabWidget(self.context, self)
self.home_tab = HomeTabWidget(self.context, self)
self.phase_tab = PhaseTabWidget(self.context, self)
self.transform = TransformWidget(self.context,
FFTWidget,
MaxEntWidget,
parent=self)
self.fitting_tab = FittingTabWidget(self.context, self)
self.seq_fitting_tab = SeqFittingTabWidget(
self.context, self.fitting_tab.fitting_tab_model, self)
self.results_tab = ResultsTabWidget(self.context.fitting_context,
self.context, self)
self.add_model_analysis = AddModelAnalysis(self, feature_dict)
self.add_raw_plots = AddRawPlots(self, feature_dict)
self.add_fitting = AddFitting(self, feature_dict)
setup_group_ws = AddGroupingWorkspaces(self, feature_dict)
self.setup_tabs()
self.plot_widget.insert_plot_panes()
self.help_widget = HelpWidget(self.context.window_title)
central_widget = QtWidgets.QWidget()
vertical_layout = QtWidgets.QVBoxLayout()
vertical_layout.addWidget(self.load_widget.load_widget_view)
vertical_layout.addWidget(self.tabs)
vertical_layout.addWidget(self.help_widget.view)
central_widget.setLayout(vertical_layout)
central_widget.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum,
QtWidgets.QSizePolicy.Maximum))
self.disable_notifier = GenericObservable()
self.disable_observer = GenericObserver(
self.disable_notifier.notify_subscribers)
self.enable_notifier = GenericObservable()
self.enable_observer = GenericObserver(
self.enable_notifier.notify_subscribers)
self.setup_disable_notifier()
self.setup_enable_notifier()
self.setCentralWidget(central_widget)
self.setWindowTitle(self.context.window_title)
self.setup_load_observers()
self.setup_gui_variable_observers()
self.setup_grouping_changed_observers()
self.setup_corrections_changed_observers()
self.setup_instrument_changed_notifier()
self.setup_group_calculation_enable_notifier()
self.setup_group_calculation_disabler_notifier()
self.setup_on_load_enabler()
self.setup_on_load_disabler()
self.setup_phase_quad_changed_notifier()
self.setup_phase_table_changed_notifier()
self.setup_fitting_notifier()
self.setup_counts_calculation_finished_notifier()
self.setup_asymmetry_pair_and_diff_calculations_finished_notifier()
self.setup_transform()
self.context.data_context.message_notifier.add_subscriber(
self.grouping_tab_widget.group_tab_presenter.message_observer)
self.add_model_analysis.add_observers_to_feature(self)
self.add_model_analysis.set_feature_observables(self)
self.add_raw_plots.add_observers_to_feature(self)
setup_group_ws.add_observers_to_feature(self)
def setUp(self):
self.context = MuonGroupPairContext()
class MuonGroupPairContextTest(unittest.TestCase):
def setUp(self):
self.context = MuonGroupPairContext()
def test_can_be_created(self):
self.assertTrue(self.context)
def test_groups_and_pairs_initially_empty(self):
self.assertEqual(self.context.groups, [])
self.assertEqual(self.context.pairs, [])
self.assertEqual(self.context.diffs, [])
def test_group_can_be_added(self):
group = MuonGroup('group_1', [1, 3, 5, 7, 9])
self.context.add_group(group)
self.assertEqual(self.context['group_1'], group)
def test_non_group_cannot_be_added(self):
pair = MuonPair('pair_1')
diff = MuonDiff('diff_1', 'positive', 'negative')
self.assertRaises(AssertionError, self.context.add_group, pair)
self.assertRaises(AssertionError, self.context.add_group, diff)
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_pair_can_be_added(self):
pair = MuonPair('pair_1')
self.context.add_pair(pair)
self.assertEqual(self.context['pair_1'], pair)
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_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_diff_can_be_added(self):
diff = MuonDiff('diff_1', 'positive', 'negative')
self.context.add_diff(diff)
self.assertEqual(self.context['diff_1'], diff)
def test_non_diff_cannot_be_added(self):
group = MuonGroup('group_1', [1, 3, 5, 7, 9])
pair = MuonPair('pair_1')
self.assertRaises(AssertionError, self.context.add_diff, group)
self.assertRaises(AssertionError, self.context.add_diff, pair)
def test_cannot_add_diff_with_duplicate_name(self):
diff_1 = MuonDiff('diff', 'positive', 'negative')
diff_2 = MuonDiff('diff', 'positive', 'negative')
self.context.add_diff(diff_1)
self.assertRaises(ValueError, self.context.add_diff, diff_2)
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_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_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 test_diff_names_returns_ordered_list_of_names(self):
diff_1 = MuonDiff('diff_1', 'positive', 'negative')
diff_2 = MuonDiff('diff_2', 'positive', 'negative')
diff_3 = MuonDiff('diff_3', 'positive', 'negative')
self.context.add_diff(diff_1)
self.context.add_diff(diff_2)
self.context.add_diff(diff_3)
self.assertEqual(self.context.diff_names,
['diff_1', 'diff_2', 'diff_3'])
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 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_can_remove_diffs_as_expected(self):
diff_1 = MuonDiff('diff_1', 'positive', 'negative')
diff_2 = MuonDiff('diff_2', 'positive', 'negative')
diff_3 = MuonDiff('diff_3', 'positive', 'negative')
self.context.add_diff(diff_1)
self.context.add_diff(diff_2)
self.context.add_diff(diff_3)
self.context.remove_diff('diff_2')
self.assertEqual(self.context.diff_names, ['diff_1', 'diff_3'])
def test_get_group_workspace_names_returns_correct_workspace_names(self):
group = create_group_populated_by_two_workspace()
self.context.add_group(group)
workspace_list = self.context.get_group_workspace_names([[33333]],
['group1'],
False)
self.assertEqual(workspace_list, ['asymmetry_name_33333'])
def test_that_reset_to_default_groups_creates_correct_groups_and_pairs_for_single_period_data(
self):
workspace = CreateSampleWorkspace()
LoadInstrument(workspace, InstrumentName="EMU", RewriteSpectraMap=True)
self.context.reset_group_and_pairs_to_default(workspace, 'EMU',
'longitudanal', 1)
self.assertEqual(self.context.group_names, ['fwd', 'bwd'])
self.assertEqual(self.context.pair_names, ['long'])
self.assertEqual(self.context.diff_names, [])
for group in self.context.groups:
self.assertEqual(group.periods, [1])
def test_that_reset_to_default_groups_creates_correct_groups_and_pairs_for_multi_period_data(
self):
workspace = CreateSampleWorkspace()
LoadInstrument(workspace, InstrumentName="EMU", RewriteSpectraMap=True)
self.context.reset_group_and_pairs_to_default(workspace, 'EMU',
'longitudanal', 2)
self.assertEqual(self.context.group_names,
['fwd1', 'bwd1', 'fwd2', 'bwd2'])
self.assertEqual(self.context.pair_names, ['long1', 'long2'])
self.assertEqual(self.context.diff_names, ['pair_diff1'])
self.assertEqual(self.context.groups[0].periods, [1])
self.assertEqual(self.context.groups[1].periods, [1])
self.assertEqual(self.context.groups[2].periods, [2])
self.assertEqual(self.context.pairs[0].forward_group, 'fwd1')
self.assertEqual(self.context.pairs[0].backward_group, 'bwd1')
self.assertEqual(self.context.pairs[1].forward_group, 'fwd2')
self.assertEqual(self.context.pairs[1].backward_group, 'bwd2')
self.assertEqual(self.context.diffs[0].positive, 'long1')
self.assertEqual(self.context.diffs[0].negative, 'long2')
self.assertEqual(self.context.selected, 'long1')
def test_get_group_pair_name_and_run_from_workspace_name(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)
group_1.update_counts_workspace(MuonRun([62260]), 'group_1_counts',
False)
group_1.update_asymmetry_workspace(MuonRun([62260]), 'group_1_asym',
'group_1_asym_unorm', False)
workspace_name_list = self.context.get_group_workspace_names(
runs=[[62260]], groups=['group_1'], rebin=False)
group_name, run = self.context.get_group_pair_name_and_run_from_workspace_name(
workspace_name_list[0])
self.assertEqual(group_name, 'group_1')
self.assertEqual(run, '62260')
def test_get_group_pair_name_and_run_works_for_co_added_runs(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)
group_1.update_counts_workspace(MuonRun([62260, 62261]),
'group_1_counts', False)
group_1.update_asymmetry_workspace(MuonRun([62260,
62261]), 'group_1_asym',
'group_1_asym_unorm', False)
workspace_name_list = self.context.get_group_workspace_names(
runs=[[62260, 62261]], groups=['group_1'], rebin=False)
group_name, run = self.context.get_group_pair_name_and_run_from_workspace_name(
workspace_name_list[0])
self.assertEqual(group_name, 'group_1')
self.assertEqual(run, '62260-62261')
def test_that_get_group_pair_name_and_run_works_for_fit_workspace_names_containing_original_worspace(
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)
group_1.update_counts_workspace(MuonRun([62260, 62261]),
'group_1_counts', False)
group_1.update_asymmetry_workspace(MuonRun([62260,
62261]), 'group_1_asym',
'group_1_asym_unorm', False)
workspace_name_list = self.context.get_group_workspace_names(
runs=[[62260, 62261]], groups=['group_1'], rebin=False)
group_name, run = self.context.get_group_pair_name_and_run_from_workspace_name(
workspace_name_list[0] + '; Fit Seq Flatbackground')
self.assertEqual(group_name, 'group_1')
self.assertEqual(run, '62260-62261')
def test_add_phasequad(self):
phasequad = MuonPhasequad("test", "table")
self.assertEqual(len(self.context._phasequad), 0)
self.assertEqual(len(self.context._pairs), 0)
self.context.add_phasequad(phasequad)
self.assertEqual(len(self.context._phasequad), 1)
self.assertEqual(len(self.context._pairs), 2)
self.assertEqual(self.context._phasequad[0].name, "test")
self.assertEqual(self.context._pairs[0].name, "test_Re_")
self.assertEqual(self.context._pairs[1].name, "test_Im_")
def test_rm_phasequad(self):
phasequad = MuonPhasequad("test", "table")
phasequad2 = MuonPhasequad("test2", "table2")
self.context.add_phasequad(phasequad)
self.context.add_phasequad(phasequad2)
self.assertEqual(len(self.context._phasequad), 2)
self.assertEqual(len(self.context._pairs), 4)
self.context.remove_phasequad(phasequad)
self.assertEqual(len(self.context._phasequad), 1)
self.assertEqual(len(self.context._pairs), 2)
self.assertEqual(self.context._phasequad[0].name, "test2")
self.assertEqual(self.context._pairs[0].name, "test2_Re_")
self.assertEqual(self.context._pairs[1].name, "test2_Im_")