Implement Create Artificial Norm Algo within Reduction Workflow

src/snapred/backend/dao/request/CreateArtificialNormalizationRequest.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+
+from snapred.meta.mantid.WorkspaceNameGenerator import WorkspaceName
+
+
+class CreateArtificialNormalizationRequest(BaseModel):
+    runNumber: str
+    useLiteMode: bool
+    peakWindowClippingSize: int
+    smoothingParameter: float
+    decreaseParameter: bool = True
+    lss: bool = True
+    diffractionWorkspace: WorkspaceName
+
+    class Config:
+        arbitrary_types_allowed = True  # Allow arbitrary types like WorkspaceName
+        extra = "forbid"  # Forbid extra fields

src/snapred/backend/dao/request/ReductionRequest.py

@@ -23,6 +23,7 @@ class ReductionRequest(BaseModel):
     versions: Versions = Versions(None, None)
 
     pixelMasks: List[WorkspaceName] = []
+    artificialNormalization: Optional[WorkspaceName] = None
 
     # TODO: Move to SNAPRequest
     continueFlags: Optional[ContinueWarning.Type] = ContinueWarning.Type.UNSET

src/snapred/backend/dao/response/ArtificialNormResponse.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, ConfigDict
+
+from snapred.meta.mantid.WorkspaceNameGenerator import WorkspaceName
+
+
+class ArtificialNormResponse(BaseModel):
+    diffractionWorkspace: WorkspaceName
+
+    model_config = ConfigDict(
+        extra="forbid",
+        # required in order to use 'WorkspaceName'
+        arbitrary_types_allowed=True,
+    )

src/snapred/backend/error/StateValidationException.py

@@ -11,9 +11,14 @@
 class StateValidationException(Exception):
     "Raised when an Instrument State is invalid"
 
-    def __init__(self, exception: Exception):
-        exceptionStr = str(exception)
-        tb = exception.__traceback__
+    def __init__(self, exception):
+        # Handle both string and Exception types for 'exception'
+        if isinstance(exception, Exception):
+            exceptionStr = str(exception)
+            tb = exception.__traceback__
+        else:
+            exceptionStr = str(exception)
+            tb = None
 
         if tb is not None:
             tb_info = traceback.extract_tb(tb)
@@ -24,7 +29,7 @@ def __init__(self, exception: Exception):
             else:
                 filePath, lineNumber, functionName = None, lineNumber, functionName
         else:
-            filePath, lineNumber, functionName = None, None, None
+            filePath, lineNumber, functionName = None, None, None  # noqa: F841
 
         doesFileExist, hasWritePermission = self._checkFileAndPermissions(filePath)
 

src/snapred/backend/recipe/GenericRecipe.py

@@ -7,6 +7,7 @@
 from snapred.backend.log.logger import snapredLogger
 from snapred.backend.recipe.algorithm.BufferMissingColumnsAlgo import BufferMissingColumnsAlgo
 from snapred.backend.recipe.algorithm.CalibrationMetricExtractionAlgorithm import CalibrationMetricExtractionAlgorithm
+from snapred.backend.recipe.algorithm.CreateArtificialNormalizationAlgo import CreateArtificialNormalizationAlgo
 from snapred.backend.recipe.algorithm.DetectorPeakPredictor import DetectorPeakPredictor
 from snapred.backend.recipe.algorithm.FitMultiplePeaksAlgorithm import FitMultiplePeaksAlgorithm
 from snapred.backend.recipe.algorithm.FocusSpectraAlgorithm import FocusSpectraAlgorithm
@@ -104,3 +105,7 @@ class ConvertTableToMatrixWorkspaceRecipe(GenericRecipe[ConvertTableToMatrixWork
 
 class BufferMissingColumnsRecipe(GenericRecipe[BufferMissingColumnsAlgo]):
     pass
+
+
+class ArtificialNormalizationRecipe(GenericRecipe[CreateArtificialNormalizationAlgo]):
+    pass

src/snapred/backend/recipe/algorithm/CreateArtificialNormalizationAlgo.py

@@ -36,7 +36,7 @@ def PyInit(self):
                 "OutputWorkspace",
                 "",
                 Direction.Output,
-                PropertyMode.Mandatory,
+                PropertyMode.Optional,
                 validator=WorkspaceUnitValidator("dSpacing"),
             ),
             doc="Workspace that contains artificial normalization.",
@@ -58,7 +58,9 @@ def chopInredients(self, ingredientsStr: str):
 
     def unbagGroceries(self):
         self.inputWorkspaceName = self.getPropertyValue("InputWorkspace")
-        self.outputWorkspaceName = self.getPropertyValue("OutputWorkspace")
+        self.outputWorkspaceName = (
+            self.getPropertyValue("OutputWorkspace") or self.inputWorkspaceName + "_artificial_norm"
+        )
 
     def peakClip(self, data, winSize: int, decrese: bool, LLS: bool, smoothing: float):
         # Clipping peaks from the data with optional smoothing and transformations
@@ -135,6 +137,7 @@ def PyExec(self):
                 smoothing=self.smoothingParameter,
             )
             self.outputWorkspace.setY(i, clippedData)
+            self.outputWorkspace.setDistribution(True)
 
         # Set the output workspace property
         self.setProperty("OutputWorkspace", self.outputWorkspaceName)

src/snapred/backend/service/ReductionService.py

@@ -3,14 +3,20 @@
 from pathlib import Path
 from typing import Any, Dict, List
 
-from snapred.backend.dao.ingredients import GroceryListItem, ReductionIngredients
+from snapred.backend.dao.ingredients import (
+    ArtificialNormalizationIngredients,
+    GroceryListItem,
+    ReductionIngredients,
+)
 from snapred.backend.dao.reduction.ReductionRecord import ReductionRecord
 from snapred.backend.dao.request import (
+    CreateArtificialNormalizationRequest,
     FarmFreshIngredients,
     ReductionExportRequest,
     ReductionRequest,
 )
 from snapred.backend.dao.request.ReductionRequest import Versions
+from snapred.backend.dao.response.ArtificialNormResponse import ArtificialNormResponse
 from snapred.backend.dao.response.ReductionResponse import ReductionResponse
 from snapred.backend.dao.SNAPRequest import SNAPRequest
 from snapred.backend.data.DataExportService import DataExportService
@@ -20,6 +26,9 @@
 from snapred.backend.error.StateValidationException import StateValidationException
 from snapred.backend.log.logger import snapredLogger
 from snapred.backend.recipe.algorithm.MantidSnapper import MantidSnapper
+from snapred.backend.recipe.GenericRecipe import (
+    ArtificialNormalizationRecipe,
+)
 from snapred.backend.recipe.ReductionRecipe import ReductionRecipe
 from snapred.backend.service.Service import Service
 from snapred.backend.service.SousChef import SousChef
@@ -72,6 +81,7 @@ def __init__(self):
         self.registerPath("checkWritePermissions", self.checkWritePermissions)
         self.registerPath("getSavePath", self.getSavePath)
         self.registerPath("getStateIds", self.getStateIds)
+        self.registerPath("artificialNormalization", self.artificialNormalization)
         return
 
     @staticmethod
@@ -85,42 +95,67 @@ def validateReduction(self, request: ReductionRequest):
         :param request: a reduction request
         :type request: ReductionRequest
         """
-        continueFlags = ContinueWarning.Type.UNSET
-        # check if a normalization is present
-        if not self.dataFactoryService.normalizationExists(request.runNumber, request.useLiteMode):
-            continueFlags |= ContinueWarning.Type.MISSING_NORMALIZATION
-        # check if a diffraction calibration is present
-        if not self.dataFactoryService.calibrationExists(request.runNumber, request.useLiteMode):
-            continueFlags |= ContinueWarning.Type.MISSING_DIFFRACTION_CALIBRATION
-
-        # remove any continue flags that are present in the request by xor-ing with the flags
-        if request.continueFlags:
-            continueFlags = continueFlags ^ (request.continueFlags & continueFlags)
-
-        if continueFlags:
-            raise ContinueWarning(
-                "Reduction is missing calibration data, continue in uncalibrated mode?", continueFlags
-            )
+        if request.artificialNormalization is not None:
+            continueFlags = ContinueWarning.Type.UNSET
+
+            # check that the user has write permissions to the save directory
+            if not self.checkWritePermissions(request.runNumber):
+                continueFlags |= ContinueWarning.Type.NO_WRITE_PERMISSIONS
+
+            # remove any continue flags that are present in the request by xor-ing with the flags
+            if request.continueFlags:
+                continueFlags = continueFlags ^ (request.continueFlags & continueFlags)
+
+            if continueFlags:
+                raise ContinueWarning(
+                    f"<p>Remeber, you don't have permissions to write to "
+                    f"<br><b>{self.getSavePath(request.runNumber)}</b>,<br>"
+                    + "but you can still save using the workbench tools.</p>"
+                    + "<p>Would you like to continue anyway?</p>",
+                    continueFlags,
+                )
+        else:
+            continueFlags = ContinueWarning.Type.UNSET
+            warningMessages = []
+
+            # check if a normalization is present
+            if not self.dataFactoryService.normalizationExists(request.runNumber, request.useLiteMode):
+                continueFlags |= ContinueWarning.Type.MISSING_NORMALIZATION
+                warningMessages.append("Normalization is missing, continuing with artificial normalization step.")
+            # check if a diffraction calibration is present
+            if not self.dataFactoryService.calibrationExists(request.runNumber, request.useLiteMode):
+                continueFlags |= ContinueWarning.Type.MISSING_DIFFRACTION_CALIBRATION
+                warningMessages.append("Diffraction calibration is missing, continuing with uncalibrated mode.")
+
+            # remove any continue flags that are present in the request by xor-ing with the flags
+            if request.continueFlags:
+                continueFlags = continueFlags ^ (request.continueFlags & continueFlags)
+
+            if continueFlags:
+                detailedMessage = "\n".join(warningMessages)
+                raise ContinueWarning(
+                    f"The reduction cannot proceed due to missing data:\n{detailedMessage}\n", continueFlags
+                )
 
-        # ... ensure separate continue warnings ...
-        continueFlags = ContinueWarning.Type.UNSET
+            # ... ensure separate continue warnings ...
+            continueFlags = ContinueWarning.Type.UNSET
 
-        # check that the user has write permissions to the save directory
-        if not self.checkWritePermissions(request.runNumber):
-            continueFlags |= ContinueWarning.Type.NO_WRITE_PERMISSIONS
+            # check that the user has write permissions to the save directory
+            if not self.checkWritePermissions(request.runNumber):
+                continueFlags |= ContinueWarning.Type.NO_WRITE_PERMISSIONS
 
-        # remove any continue flags that are present in the request by xor-ing with the flags
-        if request.continueFlags:
-            continueFlags = continueFlags ^ (request.continueFlags & continueFlags)
+            # remove any continue flags that are present in the request by xor-ing with the flags
+            if request.continueFlags:
+                continueFlags = continueFlags ^ (request.continueFlags & continueFlags)
 
-        if continueFlags:
-            raise ContinueWarning(
-                f"<p>It looks like you don't have permissions to write to "
-                f"<br><b>{self.getSavePath(request.runNumber)}</b>,<br>"
-                + "but you can still save using the workbench tools.</p>"
-                + "<p>Would you like to continue anyway?</p>",
-                continueFlags,
-            )
+            if continueFlags:
+                raise ContinueWarning(
+                    f"<p>It looks like you don't have permissions to write to "
+                    f"<br><b>{self.getSavePath(request.runNumber)}</b>,<br>"
+                    + "but you can still save using the workbench tools.</p>"
+                    + "<p>Would you like to continue anyway?</p>",
+                    continueFlags,
+                )
 
     @FromString
     def reduction(self, request: ReductionRequest):
@@ -137,6 +172,9 @@ def reduction(self, request: ReductionRequest):
         ingredients = self.prepReductionIngredients(request)
 
         groceries = self.fetchReductionGroceries(request)
+        if isinstance(groceries, ArtificialNormResponse):
+            return groceries
+
         # attach the list of grouping workspaces to the grocery dictionary
         groceries["groupingWorkspaces"] = groupingResults["groupingWorkspaces"]
 
@@ -308,8 +346,9 @@ def fetchReductionGroceries(self, request: ReductionRequest) -> Dict[str, Any]:
         :rtype: Dict[str, Any]
         """
         # Fetch pixel masks
-        residentMasks = {}
         combinedMask = None
+        residentMasks = {}
+        # Check for existing pixel masks
         if request.pixelMasks:
             for mask in request.pixelMasks:
                 match mask.tokens("workspaceType"):
@@ -341,30 +380,61 @@ def fetchReductionGroceries(self, request: ReductionRequest) -> Dict[str, Any]:
 
         # As an interim solution: set the request "versions" field to the latest calibration and normalization versions.
         #   TODO: set these when the request is initially generated.
-        calVersion = None
-        normVersion = None
-        calVersion = self.dataFactoryService.getThisOrLatestCalibrationVersion(request.runNumber, request.useLiteMode)
-        self.groceryClerk.name("diffcalWorkspace").diffcal_table(request.runNumber, calVersion).useLiteMode(
-            request.useLiteMode
-        ).add()
-
-        if ContinueWarning.Type.MISSING_NORMALIZATION not in request.continueFlags:
-            normVersion = self.dataFactoryService.getThisOrLatestNormalizationVersion(
+        if request.artificialNormalization is not None:
+            calVersion = None
+            normVersion = 0
+            calVersion = self.dataFactoryService.getThisOrLatestCalibrationVersion(
                 request.runNumber, request.useLiteMode
             )
-            self.groceryClerk.name("normalizationWorkspace").normalization(request.runNumber, normVersion).useLiteMode(
+            self.groceryClerk.name("diffcalWorkspace").diffcal_table(request.runNumber, calVersion).useLiteMode(
                 request.useLiteMode
             ).add()
+            return self.groceryService.fetchGroceryDict(
+                groceryDict=self.groceryClerk.buildDict(),
+                normalizationWorkspace=request.artificialNormalization,
+                **({"maskWorkspace": combinedMask} if combinedMask else {}),
+            )
 
-        request.versions = Versions(
-            calVersion,
-            normVersion,
-        )
+        else:
+            calVersion = None
+            normVersion = None
+            calVersion = self.dataFactoryService.getThisOrLatestCalibrationVersion(
+                request.runNumber, request.useLiteMode
+            )
+            self.groceryClerk.name("diffcalWorkspace").diffcal_table(request.runNumber, calVersion).useLiteMode(
+                request.useLiteMode
+            ).add()
 
-        return self.groceryService.fetchGroceryDict(
-            groceryDict=self.groceryClerk.buildDict(),
-            **({"maskWorkspace": combinedMask} if combinedMask else {}),
-        )
+            if ContinueWarning.Type.MISSING_NORMALIZATION not in request.continueFlags:
+                normVersion = self.dataFactoryService.getThisOrLatestNormalizationVersion(
+                    request.runNumber, request.useLiteMode
+                )
+                self.groceryClerk.name("normalizationWorkspace").normalization(
+                    request.runNumber, normVersion
+                ).useLiteMode(request.useLiteMode).add()
+            elif calVersion and normVersion is None:
+                groceryList = (
+                    self.groceryClerk.name("diffractionWorkspace")
+                    .diffcal_output(request.runNumber, calVersion)
+                    .useLiteMode(request.useLiteMode)
+                    .unit(wng.Units.DSP)
+                    .group("column")
+                    .buildDict()
+                )
+
+                groceries = self.groceryService.fetchGroceryDict(groceryList)
+                diffractionWorkspace = groceries.get("diffractionWorkspace")
+                return ArtificialNormResponse(diffractionWorkspace=diffractionWorkspace)
+
+            request.versions = Versions(
+                calVersion,
+                normVersion,
+            )
+
+            return self.groceryService.fetchGroceryDict(
+                groceryDict=self.groceryClerk.buildDict(),
+                **({"maskWorkspace": combinedMask} if combinedMask else {}),
+            )
 
     def saveReduction(self, request: ReductionExportRequest):
         self.dataExportService.exportReductionRecord(request.record)
@@ -424,3 +494,16 @@ def _groupByVanadiumVersion(self, requests: List[SNAPRequest]):
     def getCompatibleMasks(self, request: ReductionRequest) -> List[WorkspaceName]:
         runNumber, useLiteMode = request.runNumber, request.useLiteMode
         return self.dataFactoryService.getCompatibleReductionMasks(runNumber, useLiteMode)
+
+    def artificialNormalization(self, request: CreateArtificialNormalizationRequest):
+        ingredients = ArtificialNormalizationIngredients(
+            peakWindowClippingSize=request.peakWindowClippingSize,
+            smoothingParameter=request.smoothingParameter,
+            decreaseParameter=request.decreaseParameter,
+            lss=request.lss,
+        )
+        artificialNormWorkspace = ArtificialNormalizationRecipe().executeRecipe(
+            InputWorkspace=request.diffractionWorkspace,
+            Ingredients=ingredients,
+        )
+        return artificialNormWorkspace

src/snapred/ui/view/BackendRequestView.py

@@ -6,6 +6,7 @@
 from snapred.ui.widget.LabeledField import LabeledField
 from snapred.ui.widget.MultiSelectDropDown import MultiSelectDropDown
 from snapred.ui.widget.SampleDropDown import SampleDropDown
+from snapred.ui.widget.TrueFalseDropDown import TrueFalseDropDown
 
 
 class BackendRequestView(QWidget):
@@ -33,6 +34,9 @@ def _labeledCheckBox(self, label):
     def _sampleDropDown(self, label, items=[]):
         return SampleDropDown(label, items, self)
 
+    def _trueFalseDropDown(self, label):
+        return TrueFalseDropDown(label, self)
+
     def _multiSelectDropDown(self, label, items=[]):
         return MultiSelectDropDown(label, items, self)