Merge pull request #145 from neutrons/magnetic_form_factor_correction

Add magnetic structure factor correction

Author: rosswhitfield

Diff for: .github/workflows/actions.yml

@@ -14,8 +14,8 @@ jobs:
       run:
         shell: bash -l {0}
     steps:
-    - uses: actions/checkout@v3
-    - uses: mamba-org/setup-micromamba@v1
+    - uses: actions/checkout@v4
+    - uses: mamba-org/setup-micromamba@v2
       with:
         environment-file: environment.yml
     - name: pylint
@@ -25,16 +25,18 @@ jobs:
     - name: Run tests
       run: xvfb-run --server-args="-screen 0 1920x1080x24" -a python -m pytest --cov=src --cov-report=xml --cov-report=term
     - name: Upload coverage reports to Codecov
-      uses: codecov/codecov-action@v3
+      uses: codecov/codecov-action@v5
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
 
   conda-build:
     runs-on: ubuntu-latest
     defaults:
       run:
         shell: bash -l {0}
     steps:
-    - uses: actions/checkout@v3
-    - uses: mamba-org/setup-micromamba@v1
+    - uses: actions/checkout@v4
+    - uses: mamba-org/setup-micromamba@v2
       with:
         environment-file: environment.yml
         condarc: |

Diff for: environment.yml

@@ -1,7 +1,7 @@
 name: shiver
 channels:
   - conda-forge
-  - mantid
+  - mantid/label/nightly
   - oncat
   - neutrons
 dependencies:
@@ -11,7 +11,7 @@ dependencies:
   - conda-verify
   - check-wheel-contents
   - wheel
-  - mantidworkbench
+  - mantidworkbench>6.11.20241216.1838
   - pre-commit
   - versioningit
   - pylint=2.17.3

Diff for: src/shiver/models/corrections.py

@@ -15,13 +15,16 @@ class CorrectionsModel:
     def __init__(self) -> None:
         self.algorithms_observers = set()  # need to add them here so they stay in scope
         self.error_callback = None
+        self.algorithm_running = False
 
     def apply(
         self,
         ws_name: str,
         detailed_balance: bool,
         hyspec_polarizer_transmission: bool,
         temperature: str = "",
+        magentic_structure_factor: bool = False,
+        ion_name: str = "",
     ) -> None:
         """Apply corrections.
 
@@ -52,6 +55,8 @@ def apply(
             output_ws_name = f"{ws_name}_DB"
         if hyspec_polarizer_transmission:
             output_ws_name = f"{output_ws_name}_PT"
+        if magentic_structure_factor:
+            output_ws_name = f"{output_ws_name}_MSF"
 
         if detailed_balance:
             self.apply_detailed_balance(
@@ -64,14 +69,27 @@ def apply(
             input_ws_name = ws_name
             if detailed_balance:
                 # wait for detailed balance to finish
-                while not mtd.doesExist(output_ws_name):
+                while self.algorithm_running:
                     time.sleep(0.1)
                 input_ws_name = output_ws_name
             self.apply_scattered_transmission_correction(
                 input_ws_name,
                 output_ws_name,
             )
 
+        if magentic_structure_factor:
+            input_ws_name = ws_name
+            if hyspec_polarizer_transmission or detailed_balance:
+                # wait for others to finish
+                while self.algorithm_running:
+                    time.sleep(0.1)
+                input_ws_name = output_ws_name
+            self.apply_magnetic_form_factor_correction(
+                input_ws_name,
+                ion_name,
+                output_ws_name,
+            )
+
     def apply_detailed_balance(
         self,
         ws_name: str,
@@ -99,6 +117,8 @@ def apply_detailed_balance(
         )
         self.algorithms_observers.add(alg_obs)
 
+        self.algorithm_running = True
+
         alg = AlgorithmManager.create("ApplyDetailedBalanceMD")
 
         alg_obs.observeFinish(alg)
@@ -115,6 +135,7 @@ def apply_detailed_balance(
             logger.error(str(err))
             if self.error_callback:
                 self.error_callback(str(err))
+            self.algorithm_running = False
 
     def apply_scattered_transmission_correction(
         self,
@@ -143,6 +164,8 @@ def apply_scattered_transmission_correction(
         )
         self.algorithms_observers.add(alg_obs)
 
+        self.algorithm_running = True
+
         exponent_factor = 1.0 / 11.0  # see ref above
 
         logger.information(f"Applying DGS Scattered Transmission Correction with exponent factor {exponent_factor}")
@@ -162,6 +185,56 @@ def apply_scattered_transmission_correction(
             logger.error(str(err))
             if self.error_callback:
                 self.error_callback(str(err))
+            self.algorithm_running = False
+
+    def apply_magnetic_form_factor_correction(
+        self,
+        ws_name: str,
+        ion_name: str,
+        output_ws_name: str,
+    ) -> None:
+        """Apply MagneticFormFactorCorrection to the workspace.
+
+        Parameters
+        ----------
+        ws_name : str
+            Workspace name
+        ion_name : str
+            Ion name
+        output_ws_name : str
+            Output workspace name
+
+        Returns
+        -------
+        None
+        """
+
+        alg_obs = MagneticFormFactorCorrectionMDObserver(
+            parent=self,
+            ws_name=ws_name,
+        )
+        self.algorithms_observers.add(alg_obs)
+
+        self.algorithm_running = True
+
+        logger.information(f"Applying Magnetic Form Factor Correction with ion name {ion_name}")
+
+        alg = AlgorithmManager.create("MagneticFormFactorCorrectionMD")
+        alg_obs.observeFinish(alg)
+        alg_obs.observeError(alg)
+
+        alg.initialize()
+        alg.setLogging(False)
+        try:
+            alg.setProperty("InputWorkspace", ws_name)
+            alg.setProperty("IonName", ion_name)
+            alg.setProperty("OutputWorkspace", output_ws_name)
+            alg.execute()
+        except RuntimeError as err:
+            logger.error(str(err))
+            if self.error_callback:
+                self.error_callback(str(err))
+            self.algorithm_running = False
 
     def connect_error_message(self, callback):
         """Set the callback function for error messages.
@@ -208,6 +281,7 @@ def apply_detailed_balance_finished(
         else:
             logger.information(f"Finished ApplyDetailedBalanceMD for {ws_name}")
         self.algorithms_observers.remove(alg)
+        self.algorithm_running = False
 
     def apply_scattered_transmission_correction_finished(
         self,
@@ -240,6 +314,40 @@ def apply_scattered_transmission_correction_finished(
         else:
             logger.information(f"Finished DgsScatteredTransmissionCorrectionMD for {ws_name}")
         self.algorithms_observers.remove(alg)
+        self.algorithm_running = False
+
+    def apply_magnetic_form_factor_correction_finished(
+        self,
+        ws_name: str,
+        alg: "MagneticFormFactorCorrectionMDObserver",
+        error: bool = False,
+        msg="",
+    ) -> None:
+        """Call when MagneticFormFactorCorrectionMD finishes.
+
+        Parameters
+        ----------
+        ws_name : str
+            Workspace name
+        alg : MagneticFormFactorCorrectionMDObserver
+            Observer
+        error : bool, optional
+            Error flag, by default False
+        msg : str, optional
+            Error message, by default ""
+
+        Returns
+        -------
+        None
+        """
+        if error:
+            logger.error(f"Error in MagneticFormFactorCorrectionMD for {ws_name}")
+            if self.error_callback:
+                self.error_callback(msg)
+        else:
+            logger.information(f"Finished MagneticFormFactorCorrectionMD for {ws_name}")
+        self.algorithms_observers.remove(alg)
+        self.algorithm_running = False
 
     def get_ws_alg_histories(self, ws_name: str) -> list:
         """Get algorithm histories of the workspace.
@@ -297,6 +405,26 @@ def has_scattered_transmission_correction(self, ws_name: str) -> bool:
                 return True
         return False
 
+    def has_magnetic_form_factor_correction(self, ws_name: str) -> Tuple[bool, str]:
+        """Check if the workspace has MagneticFormFactorCorrectionMD applied.
+
+        Parameters
+        ----------
+        ws_name : str
+            Workspace name
+
+        Returns
+        -------
+        Tuple[bool, str]
+            True if the workspace has MagneticFormFactorCorrectionMD applied.
+            Ion name if the workspace has MagneticFormFactorCorrectionMD applied.
+        """
+        alg_histories = self.get_ws_alg_histories(ws_name)
+        for alg_history in alg_histories:
+            if alg_history.name() == "MagneticFormFactorCorrectionMD":
+                return True, alg_history.getPropertyValue("IonName")
+        return False, ""
+
 
 class ApplyDetailedBalanceMDObserver(AlgorithmObserver):
     """Observer for ApplyDetailedBalanceMD algorithm"""
@@ -334,3 +462,31 @@ def errorHandle(self, msg):  # pylint: disable=invalid-name
         self.parent.apply_scattered_transmission_correction_finished(
             ws_name=self.ws_name, alg=self, error=True, msg=msg
         )
+
+
+class MagneticFormFactorCorrectionMDObserver(AlgorithmObserver):
+    """Observer for MagneticFormFactorCorrectionMD algorithm"""
+
+    def __init__(self, parent, ws_name: str) -> None:
+        super().__init__()
+        self.parent = parent
+        self.ws_name = ws_name
+
+    def finishHandle(self):  # pylint: disable=invalid-name
+        """Call upon algorithm finishing"""
+        self.parent.apply_magnetic_form_factor_correction_finished(ws_name=self.ws_name, alg=self, error=False, msg="")
+
+    def errorHandle(self, msg):  # pylint: disable=invalid-name
+        """Call upon algorithm error"""
+        self.parent.apply_magnetic_form_factor_correction_finished(ws_name=self.ws_name, alg=self, error=True, msg=msg)
+
+
+def get_ions_list():
+    """Get the list of allowed ions from the MagneticFormFactorCorrectionMD algorithm"""
+    try:
+        alg = AlgorithmManager.create("MagneticFormFactorCorrectionMD")
+    except RuntimeError as err:
+        logger.error(str(err))
+        return []
+    alg.initialize()
+    return sorted(alg.getProperty("IonName").allowedValues)

Diff for: src/shiver/presenters/histogram.py

@@ -3,7 +3,7 @@
 import os
 from qtpy.QtWidgets import QWidget
 from shiver.views.corrections import Corrections
-from shiver.models.corrections import CorrectionsModel
+from shiver.models.corrections import CorrectionsModel, get_ions_list
 from shiver.models.generate import gather_mde_config_dict, save_mde_config_dict
 
 from shiver.models.generate import GenerateModel
@@ -270,9 +270,19 @@ def create_corrections_tab(self, name):
             # create a new model
             corrections_tab_model = CorrectionsModel()
 
+            # populate valid ions
+            ions = get_ions_list()
+            if ions:
+                corrections_tab_view.ion_name.addItems(ions)
+            else:
+                # disable the magnetic structure factor correction if MagneticFormFactorCorrectionMD is not available
+                corrections_tab_view.magnetic_structure_factor.setEnabled(False)
+                corrections_tab_view.ion_name.setEnabled(False)
+
             # populate initial values
             has_detailed_balance, temperature = corrections_tab_model.has_apply_detailed_balance(name)
             has_scattered_transmission_correction = corrections_tab_model.has_scattered_transmission_correction(name)
+            has_magnetic_form_factor, ion_name = corrections_tab_model.has_magnetic_form_factor_correction(name)
             if has_detailed_balance:
                 corrections_tab_view.detailed_balance.setChecked(True)
                 corrections_tab_view.temperature.setText(str(temperature))
@@ -281,6 +291,13 @@ def create_corrections_tab(self, name):
             if has_scattered_transmission_correction:
                 corrections_tab_view.hyspec_polarizer_transmission.setChecked(True)
                 corrections_tab_view.hyspec_polarizer_transmission.setEnabled(False)
+            if has_magnetic_form_factor:
+                corrections_tab_view.magnetic_structure_factor.setChecked(True)
+                idx = corrections_tab_view.ion_name.findText(ion_name)
+                if idx != -1:
+                    corrections_tab_view.ion_name.setCurrentIndex(idx)
+                corrections_tab_view.magnetic_structure_factor.setEnabled(False)
+                corrections_tab_view.ion_name.setEnabled(False)
 
             # inline functions
             def _apply():
@@ -298,6 +315,8 @@ def _apply():
                     do_detail_balance,
                     do_polarizer_transmission,
                     corrections_tab_view.temperature.text(),
+                    corrections_tab_view.magnetic_structure_factor.isChecked(),
+                    corrections_tab_view.ion_name.currentText(),
                 )
                 # clean up
                 tab_widget.setCurrentWidget(self._view)

Diff for: src/shiver/views/corrections.py

@@ -10,6 +10,7 @@
     QLineEdit,
     QSpacerItem,
     QSizePolicy,
+    QComboBox,
 )
 from qtpy.QtCore import Qt
 from .invalid_styles import INVALID_QLINEEDIT, INVALID_QCHECKBOX
@@ -52,8 +53,15 @@ def __init__(self, parent=None, name=None):
         self.debye_waller_correction.setEnabled(False)
 
         # magentic structure factor (disabled for now)
-        self.magentic_structure_factor = QCheckBox("Magentic structure factor")
-        self.magentic_structure_factor.setEnabled(False)
+        self.magnetic_structure_factor = QCheckBox("Magnetic structure factor")
+        self.magnetic_structure_factor.setToolTip(
+            "Correct for the magnetic structure factor.\nSee MagneticFormFactorCorrectionMD algorithm."
+        )
+        self.ion_name = QComboBox()
+        magnetic_structure_layout = QHBoxLayout()
+        magnetic_structure_layout.addWidget(self.magnetic_structure_factor)
+        magnetic_structure_layout.addWidget(self.ion_name)
+        magnetic_structure_layout.addStretch()
 
         # action group
         # add a apply button
@@ -81,7 +89,7 @@ def __init__(self, parent=None, name=None):
         correction_layout.addLayout(detailed_balance_layout)
         correction_layout.addWidget(self.hyspec_polarizer_transmission)
         correction_layout.addWidget(self.debye_waller_correction)
-        correction_layout.addWidget(self.magentic_structure_factor)
+        correction_layout.addLayout(magnetic_structure_layout)
         correction_layout.addSpacerItem(QSpacerItem(0, 0, QSizePolicy.Minimum, QSizePolicy.Expanding))
         correction_layout.addLayout(action_layout)
 

Diff for: src/shiver/views/oncat.py

@@ -422,12 +422,12 @@ def get_dataset_info(  # pylint: disable=too-many-branches
         for idx, datafile in enumerate(datafiles):
             run_number[idx] = datafile["indexed"]["run_number"]
             angle[str(run_number[idx])] = (
-                datafile["metadata"]["entry"].get("daslogs", {}).get(angle_pv, {}).get("average_value", np.NaN)
+                datafile["metadata"]["entry"].get("daslogs", {}).get(angle_pv, {}).get("average_value", np.nan)
             )
             if use_notes:
                 sid = datafile["metadata"]["entry"].get("notes", None)
             else:
-                sid = datafile["metadata"]["entry"].get("daslogs", {}).get("sequencename", {}).get("value", np.NaN)
+                sid = datafile["metadata"]["entry"].get("daslogs", {}).get("sequencename", {}).get("value", np.nan)
             if isinstance(sid, list):
                 sid = sid[-1]
             sequence[idx] = sid