Re #18108 Update run details parsing caching method

scripts/Diffraction/isis_powder/abstract_inst.py

@@ -98,7 +98,7 @@ class AbstractInst(object):
     # Instrument specific properties
 
     @abstractmethod
-    def get_run_details(self, run_number):
+    def get_run_details(self, run_number_string):
         pass
 
     @staticmethod

scripts/Diffraction/isis_powder/mock_instrument.py

@@ -20,7 +20,7 @@ class MockInstrument(AbstractInst):
     def get_default_group_names(self):
         return None
 
-    def get_run_details(self, run_number):
+    def get_run_details(self, run_number_string):
         # This is here to help remind people of the dict that is expected
         calibration_details = {"calibration": "cal",
                                "grouping": "group",

scripts/Diffraction/isis_powder/pearl.py

@@ -11,14 +11,6 @@ from isis_powder.pearl_routines import pearl_algs, pearl_output, pearl_spline, P
 
 class Pearl(AbstractInst):
 
-    # Instrument default settings
-    _default_input_ext = '.raw'
-    _default_group_names = "bank1,bank2,bank3,bank4"
-
-    _focus_tof_binning = "1500,-0.0006,19900"
-
-    _create_van_tof_binning = "1500,-0.0006,19900"
-
     def __init__(self, user_name, config_file=None, **kwargs):
 
         expected_keys = ["calibration_directory", "output_directory", "attenuation_file_name",
@@ -35,6 +27,8 @@ class Pearl(AbstractInst):
 
         self._run_settings = None
         self._ads_workaround = 0
+        self._cached_run_details = None
+        self._cached_run_details_number = None
 
     def focus(self, run_number, **kwargs):
         self._run_settings = _get_settings_focus_kwargs(config_file_path=self._basic_config_file_path, kwargs=kwargs)
@@ -45,7 +39,8 @@ class Pearl(AbstractInst):
         self._run_settings = _get_settings_van_calib_kwargs(config_file_path=self._basic_config_file_path,
                                                             kwargs=kwargs)
         self._run_settings.number_of_splines = kwargs.get("num_of_splines", 60)
-        run_details = self.get_run_details(run_number=int(run_in_range))
+        run_details = self.get_run_details(run_number_string=int(run_in_range))
+        run_details.run_number = run_details.vanadium_run_numbers
 
         return self._create_calibration_vanadium(vanadium_runs=run_details.vanadium_run_numbers,
                                                  empty_runs=run_details.empty_runs,
@@ -58,17 +53,23 @@ class Pearl(AbstractInst):
     def _get_lambda_range(self):
         return self._lambda_lower, self._lambda_upper
 
-    def get_run_details(self, run_number):
-        # TODO once we migrate this to another format (i.e. not the if/elif/else) implement cached val
+    def get_run_details(self, run_number_string):
+        input_run_number_list = common.generate_run_numbers(run_number_string=run_number_string)
+        first_run = input_run_number_list[0]
+        if self._cached_run_details_number == first_run:
+            return self._cached_run_details
+
         run_settings = self._run_settings
         run_details = pearl_algs.get_run_details(absorb_on=run_settings.absorption_corrections,
                                                  long_mode_on=run_settings.divide_by_vanadium,
-                                                 run_number_string=run_number,
+                                                 run_number_string=run_number_string,
                                                  calibration_dir=self._calibration_dir,
                                                  mapping_file=self._calibration_mapping_path)
 
         run_details = pearl_algs.set_advanced_run_details(run_details=run_details, tt_mode=self._run_settings.tt_mode,
                                                           calibration_dir=self._calibration_dir)
+        self._cached_run_details_number = first_run
+        self._cached_run_details = run_details
         return run_details
 
     @staticmethod
@@ -108,7 +109,7 @@ class Pearl(AbstractInst):
             pearl_output.generate_and_save_focus_output(self, processed_spectra=processed_spectra,
                                                         run_details=run_details, focus_mode=output_mode,
                                                         perform_attenuation=self._run_settings.perform_attenuation)
-        group_name = "PEARL" + run_details.run_number + "-Results-D-Grp"
+        group_name = "PEARL" + str(run_details.run_number) + "-Results-D-Grp"
         grouped_d_spacing = mantid.GroupWorkspaces(InputWorkspaces=output_spectra, OutputWorkspace=group_name)
         return grouped_d_spacing
 

scripts/Diffraction/isis_powder/polaris.py

@@ -38,7 +38,8 @@ class Polaris(AbstractInst):
         return self._focus(run_number=run_number, input_batching=input_mode, do_van_normalisation=do_van_normalisation)
 
     def create_calibration_vanadium(self, run_in_range, do_absorb_corrections=True, gen_absorb_correction=False):
-        run_details = self.get_run_details(run_number=int(run_in_range))
+        run_details = self.get_run_details(run_number_string=int(run_in_range))
+        run_details.run_number = run_details.vanadium_run_numbers
         return self._create_calibration_vanadium(vanadium_runs=run_details.vanadium_run_numbers,
                                                  empty_runs=run_details.empty_runs,
                                                  do_absorb_corrections=do_absorb_corrections,
@@ -49,16 +50,18 @@ class Polaris(AbstractInst):
 
     # Abstract implementation
 
-    def get_run_details(self, run_number):
-        if self._run_details_last_run_number == run_number:
+    def get_run_details(self, run_number_string):
+        input_run_number_list = common.generate_run_numbers(run_number_string=run_number_string)
+        first_run = input_run_number_list[0]
+        if self._run_details_last_run_number == first_run:
             return self._run_details_cached_obj
 
         run_details = polaris_algs.get_run_details(chopper_on=self._chopper_on, sac_on=self._apply_solid_angle,
-                                                   run_number_string=run_number, calibration_dir=self._calibration_dir,
+                                                   run_number=first_run, calibration_dir=self._calibration_dir,
                                                    mapping_path=self._calibration_mapping_path)
 
         # Hold obj in case same run range is requested
-        self._run_details_last_run_number = run_number
+        self._run_details_last_run_number = first_run
         self._run_details_cached_obj = run_details
 
         return run_details

scripts/Diffraction/isis_powder/polaris_routines/polaris_algs.py

@@ -68,9 +68,8 @@ def generate_solid_angle_corrections(run_details, instrument):
     return corrections
 
 
-def get_run_details(chopper_on, sac_on, run_number_string, calibration_dir, mapping_path):
-    input_run_number_list = common.generate_run_numbers(run_number_string=run_number_string)
-    yaml_dict = yaml_parser.get_run_dictionary(run_number=input_run_number_list[0], file_path=mapping_path)
+def get_run_details(chopper_on, sac_on, run_number, calibration_dir, mapping_path):
+    yaml_dict = yaml_parser.get_run_dictionary(run_number=run_number, file_path=mapping_path)
 
     if chopper_on:
         chopper_config = yaml_dict["chopper_on"]
@@ -92,7 +91,7 @@ def get_run_details(chopper_on, sac_on, run_number_string, calibration_dir, mapp
     solid_angle_file_path = os.path.join(in_calib_dir, solid_angle_file_name)
     splined_vanadium = os.path.join(in_calib_dir, splined_vanadium_name)
 
-    run_details = RunDetails(run_number=run_number_string)
+    run_details = RunDetails(run_number=run_number)
     run_details.empty_runs = empty_runs
     run_details.vanadium_run_numbers = vanadium_runs
     run_details.label = label

scripts/Diffraction/isis_powder/routines/calibrate.py

@@ -7,7 +7,7 @@ from isis_powder.routines.common_enums import InputBatchingEnum
 
 
 def create_van(instrument, van, empty, absorb, gen_absorb):
-    run_details = instrument.get_run_details(run_number=van)
+    run_details = instrument.get_run_details(run_number_string=van)
     # Always sum a range of inputs as its a vanadium run over multiple captures
     input_van_ws_list = common.load_current_normalised_ws_list(run_number_string=van, instrument=instrument,
                                                                input_batching=InputBatchingEnum.Summed)

scripts/Diffraction/isis_powder/routines/common.py

@@ -91,7 +91,7 @@ def get_monitor_ws(ws_to_process, run_number_string, instrument):
 
 
 def load_current_normalised_ws_list(run_number_string, instrument, input_batching):
-    run_information = instrument.get_run_details(run_number=run_number_string)
+    run_information = instrument.get_run_details(run_number_string=run_number_string)
     raw_ws_list = _load_raw_files(run_number_string=run_number_string, instrument=instrument)
 
     if input_batching.lower() == InputBatchingEnum.Summed.lower() and len(raw_ws_list) > 1:

scripts/Diffraction/isis_powder/routines/focus.py

@@ -16,7 +16,7 @@ def focus(run_number, instrument, input_batching, perform_vanadium_norm=True):
 
 
 def _focus_one_ws(ws, run_number, instrument, perform_vanadium_norm):
-    run_details = instrument.get_run_details(run_number=run_number)
+    run_details = instrument.get_run_details(run_number_string=run_number)
 
     # Check the necessary splined vanadium file has been created
     if not os.path.isfile(run_details.splined_vanadium_file_path):
@@ -67,7 +67,7 @@ def _batched_run_focusing(input_batching, instrument, perform_vanadium_norm, run
 
 def _divide_sample_by_vanadium(instrument, run_number, input_workspace, perform_vanadium_norm):
     processed_spectra = []
-    run_details = instrument.get_run_details(run_number=run_number)
+    run_details = instrument.get_run_details(run_number_string=run_number)
     split_ws = common.extract_and_crop_spectra(input_workspace, instrument=instrument)
 
     if perform_vanadium_norm: