Merge pull request #28627 from mantidproject/investigate_muon_performance

docs/source/release/v5.1.0/muon.rst

@@ -23,6 +23,9 @@ New Features
 - Addition of an external plotting button to the Muon Analysis 2 GUI.
   This allows the user to create a standalone Workbench (or MantidPlot) plot of the displayed data.
   The user may then perform standard operations on the plot, e.g drag and drop workspaces onto the figure.
+- The loading in the Muon and Frequency domain interfaces has been sped up by reducing the number of calls made to algorithms.
+  On average, this should result in a 50% decrease in load times. This reduction in the number of algorithms also improves
+  the clarity of the workspace history, as the number of algorithms present in the history is now reduced.
 - On the fitting tab, only one fit object (fit output and input workspaces) will be shown at a time.
 - Addition of background correction algorithm (PSIBackgroundCorrection) to remove the background present in
   PSI bin data loaded using LoadPSIMuonBin.

scripts/Muon/GUI/Common/ADSHandler/muon_workspace_wrapper.py

@@ -5,8 +5,9 @@
 #   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
 # SPDX - License - Identifier: GPL - 3.0 +
 # pylint: disable=F0401
+from Muon.GUI.Common.ADSHandler.workspace_group_definition import WorkspaceGroupDefinition
 from mantid.api import Workspace, AnalysisDataService
-from mantid.simpleapi import RenameWorkspace, GroupWorkspaces
+from mantid.simpleapi import RenameWorkspace
 
 
 def _add_workspace_to_group(group_name, workspace_name):
@@ -15,7 +16,8 @@ def _add_workspace_to_group(group_name, workspace_name):
     else:
         workspaces_to_group = []
     workspaces_to_group.append(workspace_name)
-    GroupWorkspaces(InputWorkspaces=workspaces_to_group, OutputWorkspace=group_name)
+    WorkspaceGroupDefinition().add_workspaces_to_group(group_name, workspaces_to_group)
+    WorkspaceGroupDefinition().execute_grouping()
 
 
 class MuonWorkspaceWrapper(object):

scripts/Muon/GUI/Common/ADSHandler/workspace_group_definition.py

+# Mantid Repository : https://github.com/mantidproject/mantid
+#
+# Copyright © 2020 ISIS Rutherford Appleton Laboratory UKRI,
+#   NScD Oak Ridge National Laboratory, European Spallation Source,
+#   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
+# SPDX - License - Identifier: GPL - 3.0 +
+
+from mantid.simpleapi import GroupWorkspaces
+
+
+# A singleton metaclass, required for the WorkspaceGroupDefinition class.
+class Singleton(type):
+    """
+    A singleton metaclass, required for the WorkspaceGroupDefinition class.
+    """
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+class WorkspaceGroupDefinition(metaclass=Singleton):
+    """
+    This class can have a context manager attached to it, which prevents the grouping algorithm from running
+    until the desired groups and workspaces names have been added to the instance.
+    The grouping algorithm will then be executed on the contents of the grouping dict.
+    The grouping dict contains: {workspace_group_name: [workspaces in that group]}
+    """
+
+    def __init__(self):
+        self.__saveState = False
+        self.grouping = {}
+
+    def execute_grouping(self):
+        if not self.__saveState:
+            for group_name, workspace_set in self.grouping.items():
+                workspace_list = list(workspace_set)
+                GroupWorkspaces(InputWorkspaces=workspace_list, OutputWorkspace=group_name)
+
+    def new_workspace_group(self, group_name):
+        if group_name not in self.grouping:
+            self.grouping[group_name] = set()
+
+    def add_workspaces_to_group(self, group_name, workspace_names):
+        self.new_workspace_group(group_name)
+        for workspace_name in workspace_names:
+            self.grouping[group_name].add(workspace_name)
+
+    def __enter__(self):
+        self.__saveState = True
+        self.grouping.clear()
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.__saveState = False
+        self.execute_grouping()
+        self.grouping.clear()

scripts/Muon/GUI/Common/calculate_pair_and_group.py

@@ -8,7 +8,7 @@ import Muon.GUI.Common.utilities.algorithm_utils as algorithm_utils
 
 
 def calculate_group_data(context, group_name, run, rebin, workspace_name):
-    processed_data = _run_pre_processing(context, run, rebin)
+    processed_data = get_pre_process_workspace_name(run, context)
 
     params = _get_MuonGroupingCounts_parameters(context, group_name, run)
     params["InputWorkspace"] = processed_data
@@ -19,7 +19,7 @@ def calculate_group_data(context, group_name, run, rebin, workspace_name):
 
 
 def calculate_pair_data(context, pair_name, run, rebin, workspace_name):
-    processed_data = _run_pre_processing(context, run, rebin)
+    processed_data = get_pre_process_workspace_name(run, context)
 
     params = _get_MuonPairingAsymmetry_parameters(context, pair_name, run)
     params["InputWorkspace"] = processed_data
@@ -29,22 +29,29 @@ def calculate_pair_data(context, pair_name, run, rebin, workspace_name):
 
 
 def estimate_group_asymmetry_data(context, group_name, run, rebin, workspace_name, unormalised_workspace_name):
-    processed_data = _run_pre_processing(context, run, rebin)
+    processed_data = get_pre_process_workspace_name(run, context)
 
     params = _get_MuonGroupingAsymmetry_parameters(context, group_name, run)
     params["InputWorkspace"] = processed_data
-    group_asymmetry, group_asymmetry_unnorm = algorithm_utils.run_MuonGroupingAsymmetry(params, workspace_name, unormalised_workspace_name)
+    group_asymmetry, group_asymmetry_unnorm = algorithm_utils.run_MuonGroupingAsymmetry(params, workspace_name,
+                                                                                        unormalised_workspace_name)
 
     return group_asymmetry, group_asymmetry_unnorm
 
 
-def _run_pre_processing(context, run, rebin):
+def run_pre_processing(context, run, rebin):
     params = _get_pre_processing_params(context, run, rebin)
     params["InputWorkspace"] = context.data_context.loaded_workspace_as_group(run)
     processed_data = algorithm_utils.run_MuonPreProcess(params)
     return processed_data
 
 
+def get_pre_process_workspace_name(run, context) -> str:
+    instrument = context.data_context.instrument
+    workspace_name = "".join(["__", instrument, str(run[0]), "_pre_processed_data"])
+    return workspace_name
+
+
 def _get_pre_processing_params(context, run, rebin):
     pre_process_params = {}
 
@@ -61,7 +68,8 @@ def _get_pre_processing_params(context, run, rebin):
         if context.gui_context['TimeZeroFromFile']:
             time_offset = 0.0
         else:
-            time_offset = context.data_context.get_loaded_data_for_run(run)["TimeZero"] - context.gui_context['TimeZero']
+            time_offset = context.data_context.get_loaded_data_for_run(run)["TimeZero"] - context.gui_context[
+                'TimeZero']
         pre_process_params["TimeOffset"] = time_offset
     except KeyError:
         pass
@@ -81,6 +89,9 @@ def _get_pre_processing_params(context, run, rebin):
             pre_process_params["DeadTimeTable"] = dead_time_table
     except KeyError:
         pass
+
+    pre_process_params["OutputWorkspace"] = get_pre_process_workspace_name(run, context)
+
     return pre_process_params
 
 
@@ -134,7 +145,8 @@ def _get_MuonGroupingAsymmetry_parameters(context, group_name, run):
     if 'GroupRangeMax' in context.gui_context:
         params['AsymmetryTimeMax'] = context.gui_context['GroupRangeMax']
     else:
-        params['AsymmetryTimeMax'] = max(context.data_context.get_loaded_data_for_run(run)['OutputWorkspace'][0].workspace.dataX(0))
+        params['AsymmetryTimeMax'] = max(
+            context.data_context.get_loaded_data_for_run(run)['OutputWorkspace'][0].workspace.dataX(0))
 
     if context.data_context.is_multi_period() and 'SummedPeriods' in context.gui_context:
         summed_periods = context.gui_context["SummedPeriods"]

scripts/Muon/GUI/Common/contexts/muon_context.py

@@ -10,12 +10,12 @@ from Muon.GUI.Common.ADSHandler.workspace_naming import (get_raw_data_workspace_
                                                          get_group_asymmetry_unnorm_name,
                                                          get_deadtime_data_workspace_name)
 from Muon.GUI.Common.calculate_pair_and_group import calculate_group_data, calculate_pair_data, \
-    estimate_group_asymmetry_data
+    estimate_group_asymmetry_data, run_pre_processing
 from Muon.GUI.Common.utilities.run_string_utils import run_list_to_string, run_string_to_list
 import Muon.GUI.Common.ADSHandler.workspace_naming as wsName
 from Muon.GUI.Common.contexts.muon_group_pair_context import get_default_grouping
 from Muon.GUI.Common.contexts.muon_context_ADS_observer import MuonContextADSObserver
-from Muon.GUI.Common.ADSHandler.muon_workspace_wrapper import MuonWorkspaceWrapper
+from Muon.GUI.Common.ADSHandler.muon_workspace_wrapper import MuonWorkspaceWrapper, WorkspaceGroupDefinition
 from mantidqt.utils.observer_pattern import Observable
 
 
@@ -92,54 +92,57 @@ class MuonContext(object):
     def show_all_groups(self):
         self.calculate_all_groups()
         for run in self._data_context.current_runs:
-            for group_name in self._group_pair_context.group_names:
-                run_as_string = run_list_to_string(run)
+            with WorkspaceGroupDefinition():
+                for group_name in self._group_pair_context.group_names:
+                    run_as_string = run_list_to_string(run)
 
-                directory = get_base_data_directory(self, run_as_string)
+                    directory = get_base_data_directory(self, run_as_string)
 
-                name = get_group_data_workspace_name(self, group_name, run_as_string, rebin=False)
-                asym_name = get_group_asymmetry_name(self, group_name, run_as_string, rebin=False)
-                asym_name_unnorm = get_group_asymmetry_unnorm_name(self, group_name, run_as_string, rebin=False)
+                    name = get_group_data_workspace_name(self, group_name, run_as_string, rebin=False)
+                    asym_name = get_group_asymmetry_name(self, group_name, run_as_string, rebin=False)
+                    asym_name_unnorm = get_group_asymmetry_unnorm_name(self, group_name, run_as_string, rebin=False)
 
-                self.group_pair_context[group_name].show_raw(run, directory + name, directory + asym_name,
-                                                             asym_name_unnorm)
+                    self.group_pair_context[group_name].show_raw(run, directory + name, directory + asym_name,
+                                                                 asym_name_unnorm)
 
-                if self._do_rebin():
-                    name = get_group_data_workspace_name(self, group_name, run_as_string, rebin=True)
-                    asym_name = get_group_asymmetry_name(self, group_name, run_as_string, rebin=True)
-                    asym_name_unnorm = get_group_asymmetry_unnorm_name(self, group_name, run_as_string, rebin=True)
+                    if self._do_rebin():
+                        name = get_group_data_workspace_name(self, group_name, run_as_string, rebin=True)
+                        asym_name = get_group_asymmetry_name(self, group_name, run_as_string, rebin=True)
+                        asym_name_unnorm = get_group_asymmetry_unnorm_name(self, group_name, run_as_string, rebin=True)
 
-                    self.group_pair_context[group_name].show_rebin(run, directory + name, directory + asym_name,
-                                                                   asym_name_unnorm)
+                        self.group_pair_context[group_name].show_rebin(run, directory + name, directory + asym_name,
+                                                                       asym_name_unnorm)
 
     def show_all_pairs(self):
         self.calculate_all_pairs()
         for run in self._data_context.current_runs:
-            for pair_name in self._group_pair_context.pair_names:
-                run_as_string = run_list_to_string(run)
-                name = get_pair_data_workspace_name(
-                    self,
-                    pair_name,
-                    run_as_string,
-                    rebin=False)
-                directory = get_base_data_directory(
-                    self,
-                    run_as_string)
-
-                self.group_pair_context[
-                    pair_name].show_raw(run, directory + name)
-
-                if self._do_rebin():
+            with WorkspaceGroupDefinition():
+                for pair_name in self._group_pair_context.pair_names:
+                    run_as_string = run_list_to_string(run)
                     name = get_pair_data_workspace_name(
                         self,
                         pair_name,
                         run_as_string,
-                        rebin=True)
+                        rebin=False)
+                    directory = get_base_data_directory(
+                        self,
+                        run_as_string)
+
                     self.group_pair_context[
-                        pair_name].show_rebin(run, directory + name)
+                        pair_name].show_raw(run, directory + name)
+
+                    if self._do_rebin():
+                        name = get_pair_data_workspace_name(
+                            self,
+                            pair_name,
+                            run_as_string,
+                            rebin=True)
+                        self.group_pair_context[
+                            pair_name].show_rebin(run, directory + name)
 
     def calculate_all_pairs(self):
         for run in self._data_context.current_runs:
+            run_pre_processing(context=self, run=run, rebin=self._do_rebin())
             for pair_name in self._group_pair_context.pair_names:
                 pair_asymmetry_workspace = self.calculate_pair(pair_name, run)
                 self.group_pair_context[
@@ -158,8 +161,8 @@ class MuonContext(object):
 
     def calculate_all_groups(self):
         for run in self._data_context.current_runs:
+            run_pre_processing(context=self, run=run, rebin=self._do_rebin())
             for group_name in self._group_pair_context.group_names:
-
                 group_workspace, group_asymmetry, group_asymmetry_unormalised = self.calculate_group(group_name, run)
                 self.group_pair_context[group_name].update_workspaces(run, group_workspace, group_asymmetry,
                                                                       group_asymmetry_unormalised, rebin=False)
@@ -188,36 +191,37 @@ class MuonContext(object):
     def show_raw_data(self):
         self.ads_observer.observeRename(False)
         for run in self.data_context.current_runs:
-            run_string = run_list_to_string(run)
-            loaded_workspace = \
-                self.data_context._loaded_data.get_data(run=run, instrument=self.data_context.instrument)['workspace'][
-                    'OutputWorkspace']
-            loaded_workspace_deadtime_table = self.data_context._loaded_data.get_data(
-                run=run, instrument=self.data_context.instrument)['workspace']['DataDeadTimeTable']
-            directory = get_base_data_directory(
-                self,
-                run_string)
-
-            deadtime_name = get_deadtime_data_workspace_name(self.data_context.instrument,
-                                                             str(run[0]), workspace_suffix=self.workspace_suffix)
-            MuonWorkspaceWrapper(loaded_workspace_deadtime_table).show(directory + deadtime_name)
-            self.data_context._loaded_data.get_data(
-                run=run, instrument=self.data_context.instrument)['workspace']['DataDeadTimeTable'] = deadtime_name
-
-            if len(loaded_workspace) > 1:
-                # Multi-period data
-                for i, single_ws in enumerate(loaded_workspace):
+            with WorkspaceGroupDefinition():
+                run_string = run_list_to_string(run)
+                loaded_workspace = \
+                    self.data_context._loaded_data.get_data(run=run, instrument=self.data_context.instrument)['workspace'][
+                        'OutputWorkspace']
+                loaded_workspace_deadtime_table = self.data_context._loaded_data.get_data(
+                    run=run, instrument=self.data_context.instrument)['workspace']['DataDeadTimeTable']
+                directory = get_base_data_directory(
+                    self,
+                    run_string)
+
+                deadtime_name = get_deadtime_data_workspace_name(self.data_context.instrument,
+                                                                 str(run[0]), workspace_suffix=self.workspace_suffix)
+                MuonWorkspaceWrapper(loaded_workspace_deadtime_table).show(directory + deadtime_name)
+                self.data_context._loaded_data.get_data(
+                    run=run, instrument=self.data_context.instrument)['workspace']['DataDeadTimeTable'] = deadtime_name
+
+                if len(loaded_workspace) > 1:
+                    # Multi-period data
+                    for i, single_ws in enumerate(loaded_workspace):
+                        name = directory + get_raw_data_workspace_name(self.data_context.instrument, run_string,
+                                                                       self.data_context.is_multi_period(),
+                                                                       period=str(i + 1),
+                                                                       workspace_suffix=self.workspace_suffix)
+                        single_ws.show(name)
+                else:
+                    # Single period data
                     name = directory + get_raw_data_workspace_name(self.data_context.instrument, run_string,
                                                                    self.data_context.is_multi_period(),
-                                                                   period=str(i + 1),
                                                                    workspace_suffix=self.workspace_suffix)
-                    single_ws.show(name)
-            else:
-                # Single period data
-                name = directory + get_raw_data_workspace_name(self.data_context.instrument, run_string,
-                                                               self.data_context.is_multi_period(),
-                                                               workspace_suffix=self.workspace_suffix)
-                loaded_workspace[0].show(name)
+                    loaded_workspace[0].show(name)
 
         self.ads_observer.observeRename(True)
 

scripts/Muon/GUI/Common/utilities/algorithm_utils.py

@@ -19,16 +19,15 @@ def run_MuonPreProcess(parameter_dict):
     alg = mantid.AlgorithmManager.create("MuonPreProcess")
     alg.initialize()
     alg.setAlwaysStoreInADS(True)
-    alg.setProperty("OutputWorkspace", "__pre_processed_data")
     alg.setProperties(parameter_dict)
     alg.execute()
-    return "__pre_processed_data"
+    return parameter_dict["OutputWorkspace"]
 
 
 def run_MuonGroupingCounts(parameter_dict, workspace_name):
     """
     Apply the MuonGroupingCounts algorithm with the properties supplied through
-    the input dictionary of {proeprty_name:property_value} pairs.
+    the input dictionary of {property_name:property_value} pairs.
     Returns the calculated workspace name.
     """
     alg = mantid.AlgorithmManager.create("MuonGroupingCounts")
@@ -44,7 +43,7 @@ def run_MuonGroupingCounts(parameter_dict, workspace_name):
 def run_MuonPairingAsymmetry(parameter_dict, workspace_name):
     """
     Apply the MuonPairingAsymmetry algorithm with the properties supplied through
-    the input dictionary of {proeprty_name:property_value} pairs.
+    the input dictionary of {property_name:property_value} pairs.
     Returns the calculated workspace name.
     """
     alg = mantid.AlgorithmManager.create("MuonPairingAsymmetry")
@@ -59,7 +58,7 @@ def run_MuonPairingAsymmetry(parameter_dict, workspace_name):
 def run_MuonGroupingAsymmetry(parameter_dict, workspace_name, unormalised_workspace_name):
     """
     Apply the MuonGroupingCounts algorithm with the properties supplied through
-    the input dictionary of {proeprty_name:property_value} pairs.
+    the input dictionary of {property_name:property_value} pairs.
     Returns the calculated workspace name.
     """
     alg = mantid.AlgorithmManager.create("MuonGroupingAsymmetry")
@@ -141,7 +140,8 @@ def run_Fit(parameters_dict, alg):
     alg.setProperty('StartX', parameters_dict['StartX'])
     alg.setProperty('EndX', parameters_dict['EndX'])
     alg.execute()
-    return alg.getProperty("OutputWorkspace").valueAsStr, alg.getProperty("OutputParameters").valueAsStr, alg.getProperty(
+    return alg.getProperty("OutputWorkspace").valueAsStr, alg.getProperty(
+        "OutputParameters").valueAsStr, alg.getProperty(
         "Function").value, alg.getProperty('OutputStatus').value, alg.getProperty('OutputChi2overDoF').value, \
         alg.getProperty("OutputNormalisedCovarianceMatrix").valueAsStr
 
@@ -163,8 +163,9 @@ def run_simultaneous_Fit(parameters_dict, alg):
 
     alg.execute()
 
-    return alg.getProperty('OutputWorkspace').valueAsStr, alg.getProperty('OutputParameters').valueAsStr,\
-        alg.getProperty('Function').value, alg.getProperty('OutputStatus').value, alg.getProperty('OutputChi2overDoF').value,\
+    return alg.getProperty('OutputWorkspace').valueAsStr, alg.getProperty('OutputParameters').valueAsStr, \
+        alg.getProperty('Function').value, alg.getProperty('OutputStatus').value, alg.getProperty(
+        'OutputChi2overDoF').value, \
         alg.getProperty("OutputNormalisedCovarianceMatrix").valueAsStr
 
 
@@ -174,8 +175,8 @@ def run_CalculateMuonAsymmetry(parameters_dict, alg):
     alg.setRethrows(True)
     alg.setProperties(parameters_dict)
     alg.execute()
-    return alg.getProperty('OutputWorkspace').valueAsStr, alg.getProperty('OutputParameters').valueAsStr,\
-        alg.getProperty("OutputFunction").value, alg.getProperty('OutputStatus').value,\
+    return alg.getProperty('OutputWorkspace').valueAsStr, alg.getProperty('OutputParameters').valueAsStr, \
+        alg.getProperty("OutputFunction").value, alg.getProperty('OutputStatus').value, \
         alg.getProperty('ChiSquared').value, alg.getProperty("OutputNormalisedCovarianceMatrix").valueAsStr
 
 
@@ -240,7 +241,6 @@ def convert_to_field(workspace_name):
 
 
 def extract_single_spec(ws, spec, output_workspace_name):
-
     alg = mantid.AlgorithmManager.create("ExtractSingleSpectrum")
     alg.initialize()
     alg.setAlwaysStoreInADS(True)

scripts/Muon/GUI/FrequencyDomainAnalysis/frequency_domain_analysis_2.py

@@ -324,5 +324,6 @@ class FrequencyAnalysisGui(QtWidgets.QMainWindow):
 
     def closeEvent(self, event):
         self.tabs.closeEvent(event)
+        self.context.ads_observer.unsubscribe()
         self.context.ads_observer = None
         super(FrequencyAnalysisGui, self).closeEvent(event)

scripts/Muon/GUI/MuonAnalysis/muon_analysis_2.py

@@ -317,5 +317,6 @@ class MuonAnalysisGui(QtWidgets.QMainWindow):
     def closeEvent(self, event):
         self.removeDockWidget(self.dockable_plot_widget_window)
         self.tabs.closeEvent(event)
+        self.context.ads_observer.unsubscribe()
         self.context.ads_observer = None
         super(MuonAnalysisGui, self).closeEvent(event)

scripts/test/Muon/muon_context_test.py

@@ -5,6 +5,8 @@
 #   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
 # SPDX - License - Identifier: GPL - 3.0 +
 import unittest
+
+from Muon.GUI.Common.calculate_pair_and_group import run_pre_processing
 from mantidqt.utils.qt.testing import start_qapplication
 
 from mantid.api import AnalysisDataService, FileFinder
@@ -44,6 +46,7 @@ class MuonContextTest(unittest.TestCase):
 
     def tearDown(self):
         ConfigService['MantidOptions.InvisibleWorkspaces'] = 'False'
+        self.context.ads_observer.unsubscribe()
 
     def populate_ADS(self):
         self.context.calculate_all_groups()
@@ -67,22 +70,24 @@ class MuonContextTest(unittest.TestCase):
         self.assertEquals(runs, [[19489]])
 
     def test_get_group_or_pair(self):
-         group_and_pair = self.context.get_group_and_pair("All")
-         self.assertEquals(group_and_pair,(["fwd","bwd"],["long"]))
+        group_and_pair = self.context.get_group_and_pair("All")
+        self.assertEquals(group_and_pair, (["fwd", "bwd"], ["long"]))
 
     def test_get_group(self):
-         group_and_pair = self.context.get_group_and_pair(" fwd , bwd ")
-         self.assertEquals(group_and_pair,(["fwd","bwd"],[]))
+        group_and_pair = self.context.get_group_and_pair(" fwd , bwd ")
+        self.assertEquals(group_and_pair, (["fwd", "bwd"], []))
 
     def test_get_pair(self):
-         group_and_pair = self.context.get_group_and_pair(" long ")
-         self.assertEquals(group_and_pair,([],["long"]))
+        group_and_pair = self.context.get_group_and_pair(" long ")
+        self.assertEquals(group_and_pair, ([], ["long"]))
 
     def test_reset_groups_and_pairs_to_default(self):
         self.assertEqual(self.group_pair_context.group_names, ['fwd', 'bwd'])
         self.assertEqual(self.group_pair_context.pair_names, ['long'])
 
     def test_calculate_group_calculates_group_for_given_run(self):
+        # Generate the pre_process_data workspace
+        run_pre_processing(self.context, [self.run_number], rebin=False)
         counts_workspace, asymmetry_workspace, group_asymmetry_unormalised = self.context.calculate_group('fwd',
                                                                                                           run=[19489])
 
@@ -91,6 +96,8 @@ class MuonContextTest(unittest.TestCase):
         self.assertEqual(group_asymmetry_unormalised, '__EMU19489; Group; fwd; Asymmetry; MA_unnorm')
 
     def test_calculate_pair_calculates_pair_for_given_run(self):
+        # Generate the pre_process_data workspace
+        run_pre_processing(self.context, [self.run_number], rebin=False)
         pair_asymmetry = self.context.calculate_pair('long', run=[19489])
 
         self.assertEqual(pair_asymmetry, 'EMU19489; Pair Asym; long; MA')
@@ -99,10 +106,10 @@ class MuonContextTest(unittest.TestCase):
         self.context.show_all_groups()
 
         self._assert_list_in_ADS(['__EMU19489; Group; bwd; Asymmetry; MA_unnorm',
-                                   '__EMU19489; Group; fwd; Asymmetry; MA_unnorm',
-                                   'EMU19489 MA', 'EMU19489; Group; bwd; Asymmetry; MA',
-                                   'EMU19489; Group; bwd; Counts; MA', 'EMU19489; Group; fwd; Asymmetry; MA',
-                                   'EMU19489; Group; fwd; Counts; MA'])
+                                  '__EMU19489; Group; fwd; Asymmetry; MA_unnorm',
+                                  'EMU19489 MA', 'EMU19489; Group; bwd; Asymmetry; MA',
+                                  'EMU19489; Group; bwd; Counts; MA', 'EMU19489; Group; fwd; Asymmetry; MA',
+                                  'EMU19489; Group; fwd; Counts; MA'])
 
     def test_that_show_all_calculates_and_shows_all_groups_with_rebin(self):
         self.gui_context['RebinType'] = 'Fixed'
@@ -111,14 +118,14 @@ class MuonContextTest(unittest.TestCase):
         self.context.show_all_groups()
 
         self._assert_list_in_ADS(['__EMU19489; Group; bwd; Asymmetry; MA_unnorm',
-                                   '__EMU19489; Group; bwd; Asymmetry; Rebin; MA_unnorm',
-                                   '__EMU19489; Group; fwd; Asymmetry; MA_unnorm',
-                                   '__EMU19489; Group; fwd; Asymmetry; Rebin; MA_unnorm',
-                                   'EMU19489 MA',
-                                   'EMU19489; Group; bwd; Asymmetry; MA', 'EMU19489; Group; bwd; Asymmetry; Rebin; MA',
-                                   'EMU19489; Group; bwd; Counts; MA', 'EMU19489; Group; bwd; Counts; Rebin; MA',
-                                   'EMU19489; Group; fwd; Asymmetry; MA', 'EMU19489; Group; fwd; Asymmetry; Rebin; MA',
-                                   'EMU19489; Group; fwd; Counts; MA', 'EMU19489; Group; fwd; Counts; Rebin; MA'])
+                                  '__EMU19489; Group; bwd; Asymmetry; Rebin; MA_unnorm',
+                                  '__EMU19489; Group; fwd; Asymmetry; MA_unnorm',
+                                  '__EMU19489; Group; fwd; Asymmetry; Rebin; MA_unnorm',
+                                  'EMU19489 MA',
+                                  'EMU19489; Group; bwd; Asymmetry; MA', 'EMU19489; Group; bwd; Asymmetry; Rebin; MA',
+                                  'EMU19489; Group; bwd; Counts; MA', 'EMU19489; Group; bwd; Counts; Rebin; MA',
+                                  'EMU19489; Group; fwd; Asymmetry; MA', 'EMU19489; Group; fwd; Asymmetry; Rebin; MA',
+                                  'EMU19489; Group; fwd; Counts; MA', 'EMU19489; Group; fwd; Counts; Rebin; MA'])
 
     def test_show_all_pairs_calculates_and_shows_all_pairs(self):
         self.context.show_all_pairs()