Re #17949 Added POLARIS focus system test

Testing/SystemTests/tests/analysis/isis_powderPearlVanCalTest.py → Testing/SystemTests/tests/analysis/ISIS_PowderPolarisTest.py

 from __future__ import (absolute_import, division, print_function)
 
-import os.path
+import os
 import stresstesting
 
 import mantid.simpleapi as mantid
@@ -13,32 +13,53 @@ DIRS = config['datasearch.directories'].split(';')
 
 class isis_powder_PolarisVanadiumCalTest(stresstesting.MantidStressTest):
 
-    results = None
+    calibration_results = None
 
     def requiredFiles(self):
         return _gen_required_files()
 
     def runTest(self):
-        self.results = _run_vanadium_calibration()
+        self.calibration_results = _run_vanadium_calibration()
 
     def validate(self):
-        return _validation(self, self.results)
+        return _calibration_validation(self, self.calibration_results)
 
     def cleanup(self):
+        # TODO clean up reference files properly
         _clean_up()
 
 
+class isis_powder_PolarisFocusTest(stresstesting.MantidStressTest):
+
+    focus_results = None
+
+    def requiredFiles(self):
+        return _gen_required_files()
+
+    def runTest(self):
+        # Gen vanadium calibration first
+        _run_vanadium_calibration()
+        self.focus_results = _run_focus()
+
+    def validation(self):
+        return _calibration_validation(self, self.focus_results)
+
+    def cleanup(self):
+        pass
+        # TODO
+
+
 def _gen_required_files():
     input_files = ["POLARIS/POL78338.raw",
-                   "POLARIS/POL78339.raw"]
-
+                   "POLARIS/POL78339.raw",
+                   "POLARIS/POL79514.raw"]
     return input_files
 
 
 def _run_vanadium_calibration():
     vanadium_run = 78338
     empty_run = 78339
-    output_file_name = _get_output_name()
+    output_file_name = _get_calibration_output_name()
     gen_absorb = True
 
     polaris_obj = setup_polaris_instrument()
@@ -47,11 +68,15 @@ def _run_vanadium_calibration():
                                                    output_file_name=output_file_name, gen_absorb_correction=gen_absorb)
 
 
-def _validation(cls, results):
-    cls.disableChecking.append('Instrument')
-    cls.disableChecking.append('Sample')
-    cls.disableChecking.append('SpectraMap')
-    output_full_path = _get_calibration_dir() + _get_output_name()
+def _run_focus():
+    run_number = 79514
+    polaris_obj = setup_polaris_instrument()
+    return polaris_obj.focus(run_number=run_number, focus_mode="")
+
+
+def _calibration_validation(cls, results):
+    _validation_setup(cls)
+    output_full_path = os.path.join(_get_calibration_dir(), _get_calibration_output_name())
     ws_to_validate_output_name = "pearl_van_cal_output"
     mantid.LoadNexus(Filename=output_full_path, OutputWorkspace=ws_to_validate_output_name)
 
@@ -59,8 +84,24 @@ def _validation(cls, results):
     return ws_to_validate_output_name, reference_file_name
 
 
+def _focus_validation(cls, results):
+    _validation_setup(cls)
+
+    reference_file_name = "POLARIS_PowderFocus79514.nxs"
+    focus_output_name = "Focus_results"
+    mantid.GroupWorkspaces(InputWorkspaces=results, OutputWorkspace=focus_output_name)
+
+    return focus_output_name, reference_file_name
+
+
+def _validation_setup(cls):
+    cls.disableChecking.append('Instrument')
+    cls.disableChecking.append('Sample')
+    cls.disableChecking.append('SpectraMap')
+
+
 def _clean_up():
-    output_file_path = _get_calibration_dir() + _get_output_name()
+    output_file_path = _get_calibration_dir() + _get_calibration_output_name()
     try:
         os.remove(output_file_path)
     except OSError:
@@ -79,7 +120,7 @@ def setup_polaris_instrument():
     return polaris_obj
 
 
-def _get_output_name():
+def _get_calibration_output_name():
     return "system_test_polaris_van_cal.nxs"
 
 

scripts/Diffraction/isis_powder/focus.py

@@ -28,14 +28,14 @@ def _run_focus(instrument, run_number, perform_attenuation, perform_vanadium_nor
     input_workspace = instrument._apply_solid_angle_efficiency_corr(ws_to_correct=input_workspace,
                                                                     vanadium_path=calibration_file_paths["vanadium"])
 
-    input_workspace = mantid.DiffractionFocussing(InputWorkspace=input_workspace,
-                                                  GroupingFileName=calibration_file_paths["grouping"])
+    focused_ws = mantid.DiffractionFocussing(InputWorkspace=input_workspace,
+                                             GroupingFileName=calibration_file_paths["grouping"])
 
     # Process
-    rebinning_params = instrument.calculate_focus_binning_params(sample=input_workspace)
+    rebinning_params = instrument.calculate_focus_binning_params(sample=focused_ws)
 
     calibrated_spectra = _divide_sample_by_vanadium(instrument=instrument, run_number=run_number,
-                                                    input_workspace=input_workspace,
+                                                    input_workspace=focused_ws,
                                                     perform_vanadium_norm=perform_vanadium_norm)
 
     _apply_binning_to_spectra(spectra_list=calibrated_spectra, binning_list=rebinning_params)
@@ -46,8 +46,9 @@ def _run_focus(instrument, run_number, perform_attenuation, perform_vanadium_nor
     # Tidy
     common.remove_intermediate_workspace(read_ws)
     common.remove_intermediate_workspace(input_workspace)
+    common.remove_intermediate_workspace(focused_ws)
     for ws in calibrated_spectra:
-        #  common.remove_intermediate_workspace(ws)
+        common.remove_intermediate_workspace(ws)
         pass
 
     return processed_nexus_files

scripts/Diffraction/isis_powder/polaris.py

@@ -130,11 +130,12 @@ class Polaris(AbstractInst):
         else:
             solid_angle_vanadium_ws = mantid.Load(Filename=vanadium_path)
 
-        solid_angle_vanadium_ws = self._normalise_ws(solid_angle_vanadium_ws)
-        corrections = self._calculate_solid_angle_efficiency_corrections(solid_angle_vanadium_ws)
+        normalised_vanadium_ws = self._normalise_ws(solid_angle_vanadium_ws)
+        corrections = self._calculate_solid_angle_efficiency_corrections(normalised_vanadium_ws)
 
         corrected_ws = mantid.Divide(LHSWorkspace=ws_to_correct, RHSWorkspace=corrections)
         common.remove_intermediate_workspace(solid_angle_vanadium_ws)
+        common.remove_intermediate_workspace(normalised_vanadium_ws)
         common.remove_intermediate_workspace(corrections)
         common.remove_intermediate_workspace(ws_to_correct)
         ws_to_correct = corrected_ws
@@ -216,6 +217,10 @@ class Polaris(AbstractInst):
 
         return calculated_binning_params
 
+    def _process_focus_output(self, processed_spectra, run_number, attenuate=False):
+        return _create_d_spacing_tof_output(processed_spectra)
+        # TODO saving out to GSS/XYE/..etc.
+
     def _read_masking_file(self):
         all_banks_masking_list = []
         bank_masking_list = []
@@ -306,3 +311,25 @@ def _calculate_focus_bin_width(bin_data):
     rebin_width = math.exp(avg_delta) - 1
     rebin_width = -1 * math.fabs(rebin_width)
     return rebin_width
+
+
+def _create_d_spacing_tof_output(processed_spectra):
+    name_index = 1
+    d_spacing_output = []
+    tof_output = []
+    for ws in processed_spectra:
+        d_spacing_out_name = "ResultD-" + str(name_index)
+        tof_out_name = "ResultTOF-" + str(name_index)
+        name_index += 1
+        # Rename d-spacing workspaces
+        d_spacing_output.append(mantid.CloneWorkspace(InputWorkspace=ws, OutputWorkspace=d_spacing_out_name))
+        # Convert to TOF
+        tof_output.append(mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=tof_out_name, Target="TOF"))
+
+    # Group the outputs
+    d_spacing_group_name = "Results-D-Grp"
+    d_spacing_group = mantid.GroupWorkspaces(InputWorkspaces=d_spacing_output, OutputWorkspace=d_spacing_group_name)
+    tof_group_name = "Results-TOF-Grp"
+    tof_group = mantid.GroupWorkspaces(InputWorkspaces=tof_output, OutputWorkspace=tof_group_name)
+
+    return d_spacing_group, tof_group