Re #17949 Fingerprint calibrated runs and use POL cal lookup

scripts/Diffraction/isis_powder/abstract_inst.py

@@ -77,8 +77,8 @@ class AbstractInst(object):
         self._create_calibration_silicon(calibration_runs=calibration_runs, cal_file_name=cal_file_name,
                                          grouping_file_name=grouping_file_name)
 
-    def create_calibration_vanadium(self, vanadium_runs, empty_runs, output_file_name=None, num_of_splines=None,
-                                    do_absorb_corrections=True, gen_absorb_correction=False):
+    def _create_calibration_vanadium(self, vanadium_runs, empty_runs, output_file_name=None, num_of_splines=None,
+                                     do_absorb_corrections=True, gen_absorb_correction=False):
         calibrate.create_van(instrument=self, van=vanadium_runs, empty=empty_runs,
                              output_van_file_name=output_file_name, num_of_splines=num_of_splines,
                              absorb=do_absorb_corrections, gen_absorb=gen_absorb_correction)
@@ -222,16 +222,13 @@ class AbstractInst(object):
         return True
         # TODO set this to False if they just dump their raw files in one folder
 
-    def _calculate_solid_angle_efficiency_corrections(self, vanadium_ws):
-        return _empty_hook_return_none()
-
     def _do_tof_rebinning_focus(self, input_workspace):
         return input_workspace
 
     def _process_focus_output(self, processed_spectra, run_details, attenuate=False):
         return _empty_hook_return_none()
 
-    def apply_solid_angle_efficiency_corr(self, ws_to_correct, vanadium_number=None, run_details=None):
+    def apply_solid_angle_efficiency_corr(self, ws_to_correct, run_details):
         return ws_to_correct
 
     def _apply_van_calibration_tof_rebinning(self, vanadium_ws, tof_rebin_pass, return_units):

scripts/Diffraction/isis_powder/pearl.py

@@ -53,6 +53,14 @@ class Pearl(AbstractInst):
         return self._focus(run_number=run_number,
                            do_attenuation=do_attenuation, do_van_normalisation=do_van_normalisation)
 
+    def create_calibration_vanadium(self, vanadium_runs, empty_runs, output_file_name=None, num_of_splines=None,
+                                    do_absorb_corrections=True, gen_absorb_correction=False):
+
+        self._create_calibration_vanadium(vanadium_runs=vanadium_runs, empty_runs=empty_runs,
+                                          output_file_name=output_file_name, num_of_splines=num_of_splines,
+                                          do_absorb_corrections=do_absorb_corrections,
+                                          gen_absorb_correction=gen_absorb_correction)
+
     # Params #
     def _get_default_group_names(self):
         return self._default_group_names

scripts/Diffraction/isis_powder/polaris.py

@@ -40,6 +40,12 @@ class Polaris(AbstractInst):
         return self._focus(run_number=run_number, do_attenuation=do_attenuation,
                            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))
+        self._create_calibration_vanadium(vanadium_runs=run_details.vanadium, empty_runs=run_details.sample_empty,
+                                          do_absorb_corrections=do_absorb_corrections,
+                                          gen_absorb_correction=gen_absorb_correction)
+
     # Abstract implementation
     def _get_lambda_range(self):
         return self._lower_lambda_range, self._upper_lambda_range
@@ -64,8 +70,8 @@ class Polaris(AbstractInst):
 
         empty_runs = chopper_config["empty_run_numbers"]
         vanadium_runs = chopper_config["vanadium_run_numbers"]
-        solid_angle_file_name = "SAC_" + vanadium_runs
-        splined_vanadium_name = "SplinedVan_" + vanadium_runs
+        solid_angle_file_name = self._generate_solid_angle_file_name(vanadium_run_string=vanadium_runs)
+        splined_vanadium_name = self._generate_splined_van_name(vanadium_run_string=vanadium_runs)
         cycle = configuration["label"]
 
         calibration_dir = os.path.join(self.calibration_dir, cycle)
@@ -104,34 +110,12 @@ class Polaris(AbstractInst):
         normalised_ws = mantid.NormaliseByCurrent(InputWorkspace=ws_to_correct)
         return normalised_ws
 
-    def _calculate_solid_angle_efficiency_corrections(self, vanadium_ws):
-        solid_angle_ws = mantid.SolidAngle(InputWorkspace=vanadium_ws)
-        solid_angle_multiplicand = mantid.CreateSingleValuedWorkspace(DataValue=str(100))
-        solid_angle_ws = mantid.Multiply(LHSWorkspace=solid_angle_ws, RHSWorkspace=solid_angle_multiplicand)
-        common.remove_intermediate_workspace(solid_angle_multiplicand)
-
-        efficiency_ws = mantid.Divide(LHSWorkspace=vanadium_ws, RHSWorkspace=solid_angle_ws)
-        efficiency_ws = mantid.ConvertUnits(InputWorkspace=efficiency_ws, Target="Wavelength")
-        efficiency_ws = mantid.Integration(InputWorkspace=efficiency_ws)
-
-        corrections_ws = mantid.Multiply(LHSWorkspace=solid_angle_ws, RHSWorkspace=efficiency_ws)
-        corrections_divisor_ws = mantid.CreateSingleValuedWorkspace(DataValue=str(100000))
-        corrections_ws = mantid.Divide(LHSWorkspace=corrections_ws, RHSWorkspace=corrections_divisor_ws)
-
-        common.remove_intermediate_workspace(corrections_divisor_ws)
-        common.remove_intermediate_workspace(solid_angle_ws)
-        common.remove_intermediate_workspace(efficiency_ws)
-
-        return corrections_ws
-
-    def apply_solid_angle_efficiency_corr(self, ws_to_correct, vanadium_number=None, run_details=None):
+    def apply_solid_angle_efficiency_corr(self, ws_to_correct, run_details):
         if not self._apply_solid_angle:
             return ws_to_correct
 
-        assert(vanadium_number or run_details)
-
         if not run_details or not os.path.isfile(run_details.solid_angle_corr):
-            corrections = self.generate_solid_angle_corrections(run_details, vanadium_number)
+            corrections = self.generate_solid_angle_corrections(run_details)
         else:
             corrections = mantid.Load(Filename=run_details.solid_angle_corr)
 
@@ -141,19 +125,12 @@ class Polaris(AbstractInst):
         ws_to_correct = corrected_ws
         return ws_to_correct
 
-    def generate_solid_angle_corrections(self, run_details, vanadium_number):
-        if vanadium_number:
-            solid_angle_vanadium_ws = common.load_current_normalised_ws(run_number_string=vanadium_number,
-                                                                        instrument=self)
-        elif run_details:
-            solid_angle_vanadium_ws = common.load_current_normalised_ws(run_number_string=run_details.vanadium,
-                                                                        instrument=self)
-        else:
-            raise RuntimeError("Got no run_details or vanadium_number in gen solid angle corrections")
+    def generate_solid_angle_corrections(self, run_details):
+        solid_angle_vanadium_ws = common.load_current_normalised_ws(run_number_string=run_details.vanadium,
+                                                                    instrument=self)
 
-        corrections = self._calculate_solid_angle_efficiency_corrections(solid_angle_vanadium_ws)
-        if run_details:
-            mantid.SaveNexusProcessed(InputWorkspace=corrections, Filename=run_details.solid_angle_corr)
+        corrections = _calculate_solid_angle_efficiency_corrections(solid_angle_vanadium_ws)
+        mantid.SaveNexusProcessed(InputWorkspace=corrections, Filename=run_details.solid_angle_corr)
 
         common.remove_intermediate_workspace(solid_angle_vanadium_ws)
         return corrections
@@ -286,6 +263,25 @@ class Polaris(AbstractInst):
 
             mantid.SaveFocusedXYE(InputWorkspace=ws, Filename=full_file_path, SplitFiles=False, IncludeHeader=False)
 
+    def _generate_solid_angle_file_name(self, vanadium_run_string):
+        if self._chopper_on:
+            return "SAC_chopperOn_" + vanadium_run_string + ".nxs"
+        else:
+            return "SAC_chopperOff_" + vanadium_run_string + ".nxs"
+
+    def _generate_splined_van_name(self, vanadium_run_string):
+        output_string = "SVan_" + str(vanadium_run_string) + "_chopper"
+        if self._chopper_on:
+            output_string += "On"
+        else:
+            output_string += "Off"
+
+        if self._apply_solid_angle:
+            output_string += "_SAC"
+        else:
+            output_string += "_noSAC"
+
+        return output_string
 
 # Class private implementation
 
@@ -351,3 +347,24 @@ def _create_d_spacing_tof_output(processed_spectra):
     tof_group = mantid.GroupWorkspaces(InputWorkspaces=tof_output, OutputWorkspace=tof_group_name)
 
     return d_spacing_group, tof_group
+
+
+def _calculate_solid_angle_efficiency_corrections(vanadium_ws):
+    solid_angle_ws = mantid.SolidAngle(InputWorkspace=vanadium_ws)
+    solid_angle_multiplicand = mantid.CreateSingleValuedWorkspace(DataValue=str(100))
+    solid_angle_ws = mantid.Multiply(LHSWorkspace=solid_angle_ws, RHSWorkspace=solid_angle_multiplicand)
+    common.remove_intermediate_workspace(solid_angle_multiplicand)
+
+    efficiency_ws = mantid.Divide(LHSWorkspace=vanadium_ws, RHSWorkspace=solid_angle_ws)
+    efficiency_ws = mantid.ConvertUnits(InputWorkspace=efficiency_ws, Target="Wavelength")
+    efficiency_ws = mantid.Integration(InputWorkspace=efficiency_ws)
+
+    corrections_ws = mantid.Multiply(LHSWorkspace=solid_angle_ws, RHSWorkspace=efficiency_ws)
+    corrections_divisor_ws = mantid.CreateSingleValuedWorkspace(DataValue=str(100000))
+    corrections_ws = mantid.Divide(LHSWorkspace=corrections_ws, RHSWorkspace=corrections_divisor_ws)
+
+    common.remove_intermediate_workspace(corrections_divisor_ws)
+    common.remove_intermediate_workspace(solid_angle_ws)
+    common.remove_intermediate_workspace(efficiency_ws)
+
+    return corrections_ws

scripts/Diffraction/isis_powder/polaris_routines/polaris_calibration.yaml

@@ -12,14 +12,26 @@
     vanadium_run_numbers : "78338"
     empty_run_numbers : "78339"
 
+93104-93106:
+  offset_file_name : "offsets_2011_cycle111b.cal"
+  label : "15_2"
+  chopper_on:
+    vanadium_run_numbers : "93105"
+    empty_run_numbers : "93106"
+
+  chopper_off:
+    vanadium_run_numbers : "93105"
+    empty_run_numbers : "93106"
 
-93105-95614:
+
+95600-95614:
   # Calibration run
   offset_file_name : "offsets_2011_cycle111b.cal"
-  label : "15_2"
+  label : "16_4"
   chopper_on:
     vanadium_run_numbers : "95603-95607,95613-95614"
     empty_run_numbers : "78339"
   chopper_off:
     vanadium_run_numbers : "95603-95607,95613-95614"
-    empty_run_numbers : "78339"
+    empty_run_numbers : "78339"
\ No newline at end of file
+

scripts/Diffraction/isis_powder/routines/calibrate.py

@@ -8,10 +8,10 @@ import isis_powder.routines.common as common
 
 
 def create_van(instrument, van, empty, output_van_file_name, num_of_splines, absorb, gen_absorb):
-    input_van_ws = common.load_current_normalised_ws(run_number_string=van, instrument=instrument)
 
+    input_van_ws = common.load_current_normalised_ws(run_number_string=van, instrument=instrument)
     corrected_van_ws = common.subtract_sample_empty(ws_to_correct=input_van_ws, empty_sample_ws_string=empty,
-                                                instrument=instrument)
+                                                    instrument=instrument)
 
     common.remove_intermediate_workspace(input_van_ws)
 
@@ -24,7 +24,7 @@ def create_van(instrument, van, empty, output_van_file_name, num_of_splines, abs
                                              CalibrationFile=run_details.calibration)
 
     corrected_van_ws = instrument.apply_solid_angle_efficiency_corr(ws_to_correct=corrected_van_ws,
-                                                                    vanadium_number=van)
+                                                                    run_details=run_details)
     if absorb:
         corrected_van_ws = _apply_absorb_corrections(instrument=instrument,
                                                      run_details=run_details,