generate unfocussed after the preprocessingrecipe, as well as rebin it (#656)

* generate unfocussed after the preprocessingrecipe, as well as rebin it

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* update unit tests

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: walshmm

pixi.lock

@@ -158,6 +158,29 @@ def _prepareUnfocusedData(
                 OutputWorkspace=preOutputUnfocWs,
             )
 
+        self.mantidSnapper.ConvertUnits(
+            "Converting unfocused data to TOF",
+            InputWorkspace=preOutputUnfocWs,
+            OutputWorkspace=preOutputUnfocWs,
+            Target="TOF",
+        )
+
+        self.mantidSnapper.Rebin(
+            "Rebin in log TOF",
+            InputWorkspace=preOutputUnfocWs,
+            Params=Config["constants.ReductionRecipe.unfocussed.Rebin.Params"],
+            PreserveEvents=Config["constants.ReductionRecipe.unfocussed.Rebin.PreserveEvents"],
+            OutputWorkspace=preOutputUnfocWs,
+            BinningMode="Logarithmic",
+        )
+
+        self.mantidSnapper.ConvertUnits(
+            "Converting unfocused data to dSpacing",
+            InputWorkspace=preOutputUnfocWs,
+            OutputWorkspace=preOutputUnfocWs,
+            Target="dSpacing",
+        )
+
         self.mantidSnapper.ConvertUnits(
             f"Converting unfocused data to {units}",
             InputWorkspace=preOutputUnfocWs,
@@ -266,10 +289,6 @@ def queueAlgos(self):
     def execute(self):
         data: Dict[str, Any] = {"result": False}
 
-        # Retain unfocused data for comparison.
-        if self.keepUnfocused:
-            data["unfocusedWS"] = self._prepareUnfocusedData(self.sampleWs, self.maskWs, self.convertUnitsTo)
-
         outputs = []
 
         if bool(self.maskWs) and all(
@@ -306,6 +325,10 @@ def execute(self):
         )
         self._cloneIntermediateWorkspace(self.sampleWs, "sample_preprocessed")
 
+        # Retain unfocused data for comparison.
+        if self.keepUnfocused:
+            data["unfocusedWS"] = self._prepareUnfocusedData(self.sampleWs, None, self.convertUnitsTo)
+
         if self.normalizationWs:
             # If artificial normalization is being used, there won't be any incoming normalization workspace.
             # NOTE: This MASKS the ws, this is not reversible.

src/snapred/backend/recipe/ReductionRecipe.py

@@ -336,6 +336,11 @@ constants:
   RawVanadiumCorrection:
     numberOfSlices: 10
     numberOfAnnuli: 10
+  ReductionRecipe:
+    unfocussed:
+      Rebin:
+        Params: "-0.002"
+        PreserveEvents: true
   ResampleX:
     NumberBins: 1500
 

src/snapred/resources/application.yml

@@ -323,6 +323,12 @@ constants:
   m2cm: 10000.0 # conversion factor for m^2 to cm^2
   maskedPixelThreshold: 0.15
 
+  ReductionRecipe:
+    unfocussed:
+      Rebin:
+        Params: "-0.002"
+        PreserveEvents: true
+
   CrystallographicInfo:
     crystalDMin: 0.4
     crystalDMax: 100.0

tests/resources/application.yml

@@ -152,49 +152,121 @@ def test_prepareUnfocusedData(self):
 
         # TODO: All units are tested here for now, this will be changed when EWM 6615 is completed
         units = "dSpacing"
-        msg = f"Converting unfocused data to {units}"
         recipe._prepareUnfocusedData(workspace, None, units)
         outputWs = (
             wng.run().runNumber("555").lite(True).unit(wng.Units.DSP).group(wng.Groups.UNFOC).hidden(True).build()
         )
-        recipe.mantidSnapper.ConvertUnits.assert_called_once_with(
-            msg, InputWorkspace=outputWs, OutputWorkspace=outputWs, Target=units
+        recipe.mantidSnapper.ConvertUnits.assert_has_calls(
+            [
+                mock.call(
+                    "Converting unfocused data to TOF",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target="TOF",
+                ),
+                mock.call(
+                    "Converting unfocused data to dSpacing",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target="dSpacing",
+                ),
+                mock.call(
+                    f"Converting unfocused data to {units}",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target=units,
+                ),
+            ]
         )
         recipe.mantidSnapper.executeQueue.assert_called()
         recipe.mantidSnapper.reset_mock()
 
         units = "MomentumTransfer"
-        msg = f"Converting unfocused data to {units}"
         recipe._prepareUnfocusedData(workspace, None, units)
         outputWs = (
             wng.run().runNumber("555").lite(True).unit(wng.Units.QSP).group(wng.Groups.UNFOC).hidden(True).build()
         )
-        recipe.mantidSnapper.ConvertUnits.assert_called_once_with(
-            msg, InputWorkspace=outputWs, OutputWorkspace=outputWs, Target=units
+        recipe.mantidSnapper.ConvertUnits.assert_has_calls(
+            [
+                mock.call(
+                    "Converting unfocused data to TOF",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target="TOF",
+                ),
+                mock.call(
+                    "Converting unfocused data to dSpacing",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target="dSpacing",
+                ),
+                mock.call(
+                    f"Converting unfocused data to {units}",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target=units,
+                ),
+            ]
         )
         recipe.mantidSnapper.executeQueue.assert_called()
         recipe.mantidSnapper.reset_mock()
 
         units = "Wavelength"
-        msg = f"Converting unfocused data to {units}"
         recipe._prepareUnfocusedData(workspace, None, units)
         outputWs = (
             wng.run().runNumber("555").lite(True).unit(wng.Units.LAM).group(wng.Groups.UNFOC).hidden(True).build()
         )
-        recipe.mantidSnapper.ConvertUnits.assert_called_once_with(
-            msg, InputWorkspace=outputWs, OutputWorkspace=outputWs, Target=units
+        recipe.mantidSnapper.ConvertUnits.assert_has_calls(
+            [
+                mock.call(
+                    "Converting unfocused data to TOF",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target="TOF",
+                ),
+                mock.call(
+                    "Converting unfocused data to dSpacing",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target="dSpacing",
+                ),
+                mock.call(
+                    f"Converting unfocused data to {units}",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target=units,
+                ),
+            ]
         )
         recipe.mantidSnapper.executeQueue.assert_called()
         recipe.mantidSnapper.reset_mock()
 
         units = "TOF"
-        msg = f"Converting unfocused data to {units}"
         recipe._prepareUnfocusedData(workspace, None, units)
         outputWs = (
             wng.run().runNumber("555").lite(True).unit(wng.Units.TOF).group(wng.Groups.UNFOC).hidden(True).build()
         )
-        recipe.mantidSnapper.ConvertUnits.assert_called_once_with(
-            msg, InputWorkspace=outputWs, OutputWorkspace=outputWs, Target=units
+        recipe.mantidSnapper.ConvertUnits.assert_has_calls(
+            [
+                mock.call(
+                    "Converting unfocused data to TOF",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target="TOF",
+                ),
+                mock.call(
+                    "Converting unfocused data to dSpacing",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target="dSpacing",
+                ),
+                mock.call(
+                    f"Converting unfocused data to {units}",
+                    InputWorkspace=outputWs,
+                    OutputWorkspace=outputWs,
+                    Target=units,
+                ),
+            ]
         )
         recipe.mantidSnapper.executeQueue.assert_called()
         recipe.mantidSnapper.reset_mock()
@@ -228,11 +300,28 @@ def test_prepareUnfocusedData_masking(self):
         recipe.mantidSnapper.MaskDetectorFlags.assert_called_once_with(
             "Applying pixel mask to unfocused data", MaskWorkspace=maskWs, OutputWorkspace=preOutputWs
         )
-        recipe.mantidSnapper.ConvertUnits.assert_called_once_with(
-            f"Converting unfocused data to {units}",
-            InputWorkspace=preOutputWs,
-            OutputWorkspace=preOutputWs,
-            Target=units,
+
+        recipe.mantidSnapper.ConvertUnits.assert_has_calls(
+            [
+                mock.call(
+                    "Converting unfocused data to TOF",
+                    InputWorkspace=preOutputWs,
+                    OutputWorkspace=preOutputWs,
+                    Target="TOF",
+                ),
+                mock.call(
+                    "Converting unfocused data to dSpacing",
+                    InputWorkspace=preOutputWs,
+                    OutputWorkspace=preOutputWs,
+                    Target="dSpacing",
+                ),
+                mock.call(
+                    f"Converting unfocused data to {units}",
+                    InputWorkspace=preOutputWs,
+                    OutputWorkspace=preOutputWs,
+                    Target=units,
+                ),
+            ]
         )
 
         # Test the output add-or-replace sequence.
@@ -320,7 +409,7 @@ def test_keepUnfocusedData(self, mockMtd):
         result = recipe.execute()
 
         # Assertions
-        recipe._prepareUnfocusedData.assert_called_once_with("sample", "mask", "dSpacing")
+        recipe._prepareUnfocusedData.assert_called_once_with("sample", None, "dSpacing")
         # Delete the group clones (sample + norm), and the masked normalization clone.
         assert recipe._deleteWorkspace.call_count == 3
         recipe._deleteWorkspace.assert_called_with(recipe.normalizationWsMasked)