Merge pull request #38322 from rbauststfc/38264_add_output_spin_state_to_Wildes

Add option for PolarizationCorrectionWildes to include output spin state in log

Author: cailafinn

Framework/Algorithms/inc/MantidAlgorithms/PolarizationCorrectionWildes.h

@@ -60,14 +60,15 @@ class MANTID_ALGORITHMS_DLL PolarizationCorrectionWildes final : public API::Alg
   WorkspaceMap twoInputCorrections(const WorkspaceMap &inputs, const EfficiencyMap &efficiencies);
   WorkspaceMap threeInputCorrections(const WorkspaceMap &inputs, const EfficiencyMap &efficiencies);
   WorkspaceMap fullCorrections(const WorkspaceMap &inputs, const EfficiencyMap &efficiencies);
-  API::WorkspaceGroup_sptr groupOutput(const WorkspaceMap &outputs);
+  API::WorkspaceGroup_sptr groupOutput(const WorkspaceMap &outputs, const bool hasAnalyser);
   WorkspaceMap mapInputsToDirections(const std::vector<std::string> &flippers);
   void threeInputsSolve01(WorkspaceMap &inputs, const EfficiencyMap &efficiencies);
   void threeInputsSolve10(WorkspaceMap &inputs, const EfficiencyMap &efficiencies);
   void twoInputsSolve01And10(WorkspaceMap &fullInputs, const WorkspaceMap &inputs, const EfficiencyMap &efficiencies);
   void addSpinStateOutput(std::vector<std::string> &names, const std::string &spinStateOrder,
                           const std::string &baseName, const API::MatrixWorkspace_sptr &ws,
-                          const std::string &spinState);
+                          const std::string &spinState, const bool addSpinStateLog, const bool hasAnalyser);
+  void addSpinStateLogToWs(const API::MatrixWorkspace_sptr &ws, const std::string &spinState, const bool hasAnalyser);
 };
 } // namespace Algorithms
 } // namespace Mantid

Framework/Algorithms/inc/MantidAlgorithms/PolarizationCorrections/PolarizationCorrectionsHelpers.h

@@ -23,30 +23,47 @@ MANTID_ALGORITHMS_DLL std::vector<std::string> splitSpinStateString(const std::s
 } // namespace PolarizationCorrectionsHelpers
 
 namespace FlipperConfigurations {
-auto constexpr OFF_ON = "01";
-auto constexpr ON_OFF = "10";
-auto constexpr OFF_OFF = "00";
-auto constexpr ON_ON = "11";
-auto constexpr OFF = "0";
-auto constexpr ON = "1";
+static const std::string OFF_ON = "01";
+static const std::string ON_OFF = "10";
+static const std::string OFF_OFF = "00";
+static const std::string ON_ON = "11";
+static const std::string OFF = "0";
+static const std::string ON = "1";
 } // namespace FlipperConfigurations
 
 namespace SpinStateConfigurationsFredrikze {
-auto constexpr PARA_ANTI = "pa";
-auto constexpr ANTI_PARA = "ap";
-auto constexpr PARA_PARA = "pp";
-auto constexpr ANTI_ANTI = "aa";
-auto constexpr PARA = "p";
-auto constexpr ANTI = "a";
+static const std::string PARA_ANTI = "pa";
+static const std::string ANTI_PARA = "ap";
+static const std::string PARA_PARA = "pp";
+static const std::string ANTI_ANTI = "aa";
+static const std::string PARA = "p";
+static const std::string ANTI = "a";
 } // namespace SpinStateConfigurationsFredrikze
 
 namespace SpinStateConfigurationsWildes {
-auto constexpr MINUS_PLUS = "-+";
-auto constexpr PLUS_MINUS = "+-";
-auto constexpr MINUS_MINUS = "--";
-auto constexpr PLUS_PLUS = "++";
-auto constexpr MINUS = "-";
-auto constexpr PLUS = "+";
+static const std::string MINUS_PLUS = "-+";
+static const std::string PLUS_MINUS = "+-";
+static const std::string MINUS_MINUS = "--";
+static const std::string PLUS_PLUS = "++";
+static const std::string MINUS = "-";
+static const std::string PLUS = "+";
 } // namespace SpinStateConfigurationsWildes
 
+namespace SpinStatesORSO {
+/*
+ * Polarization constants and helper methods to support the Reflectometry ORSO file format
+ */
+static const std::string PP = "pp";
+static const std::string PM = "pm";
+static const std::string MP = "mp";
+static const std::string MM = "mm";
+static const std::string PO = "po";
+static const std::string MO = "mo";
+
+static const std::string LOG_NAME = "spin_state_ORSO";
+
+MANTID_ALGORITHMS_DLL const std::string &getORSONotationForSpinState(const std::string &spinState);
+MANTID_ALGORITHMS_DLL void addORSOLogForSpinState(const Mantid::API::MatrixWorkspace_sptr &ws,
+                                                  const std::string &spinState);
+} // namespace SpinStatesORSO
 } // namespace Mantid::Algorithms

Framework/Algorithms/src/PolarizationCorrectionWildes.cpp

@@ -29,6 +29,7 @@ static const std::string SPIN_STATES{"SpinStates"};
 static const std::string EFFICIENCIES{"Efficiencies"};
 static const std::string INPUT_WS{"InputWorkspaces"};
 static const std::string OUTPUT_WS{"OutputWorkspace"};
+static const std::string ADD_SPIN_STATE_LOG{"AddSpinStateToLog"};
 } // namespace Prop
 
 /**
@@ -340,6 +341,9 @@ void PolarizationCorrectionWildes::init() {
       std::make_unique<API::WorkspaceProperty<API::MatrixWorkspace>>(Prop::EFFICIENCIES, "", Kernel::Direction::Input),
       "A workspace containing the efficiency factors P1, P2, F1 and F2 as "
       "histograms");
+  declareProperty(
+      Prop::ADD_SPIN_STATE_LOG, false,
+      "Whether to add the final spin state into the sample log of each child workspace in the output group.");
 }
 
 //----------------------------------------------------------------------------------------------
@@ -348,6 +352,8 @@ void PolarizationCorrectionWildes::init() {
 void PolarizationCorrectionWildes::exec() {
   const std::string flipperProperty = getProperty(Prop::FLIPPERS);
   const auto flippers = PolarizationCorrectionsHelpers::splitSpinStateString(flipperProperty);
+  // Check if the input flipper configuration includes an analyser
+  const bool hasAnalyser = flippers.front().size() > 1;
   const auto inputs = mapInputsToDirections(flippers);
   checkConsistentNumberHistograms(inputs);
   const EfficiencyMap efficiencies = efficiencyFactors();
@@ -358,8 +364,7 @@ void PolarizationCorrectionWildes::exec() {
     outputs = directBeamCorrections(inputs, efficiencies);
     break;
   case 2:
-    // Check if the input flipper configuration includes an analyser
-    if (flippers.front().size() > 1) {
+    if (hasAnalyser) {
       outputs = twoInputCorrections(inputs, efficiencies);
     } else {
       outputs = analyzerlessCorrections(inputs, efficiencies);
@@ -371,7 +376,7 @@ void PolarizationCorrectionWildes::exec() {
   case 4:
     outputs = fullCorrections(inputs, efficiencies);
   }
-  setProperty(Prop::OUTPUT_WS, groupOutput(outputs));
+  setProperty(Prop::OUTPUT_WS, groupOutput(outputs, hasAnalyser));
 }
 
 /**
@@ -513,27 +518,35 @@ void PolarizationCorrectionWildes::checkConsistentX(const WorkspaceMap &inputs,
  * The workspaces will be published in the ADS, their names appended by
  * appropriate suffices.
  * @param outputs a set of workspaces to group
+ * @param hasAnalyser whether the flipper configuration included an analyser.
  * @return a group workspace
  */
-API::WorkspaceGroup_sptr PolarizationCorrectionWildes::groupOutput(const WorkspaceMap &outputs) {
+API::WorkspaceGroup_sptr PolarizationCorrectionWildes::groupOutput(const WorkspaceMap &outputs,
+                                                                   const bool hasAnalyser) {
   const auto &outWSName = getPropertyValue(Prop::OUTPUT_WS);
   auto spinStateOrder = getPropertyValue(Prop::SPIN_STATES);
+  const bool addSpinStateLog = getProperty(Prop::ADD_SPIN_STATE_LOG);
+
   std::vector<std::string> names;
   if (!spinStateOrder.empty()) {
     names.resize(PolarizationCorrectionsHelpers::splitSpinStateString(spinStateOrder).size());
   }
 
   if (outputs.ppWS) {
-    addSpinStateOutput(names, spinStateOrder, outWSName, outputs.ppWS, SpinStateConfigurationsWildes::PLUS_PLUS);
+    addSpinStateOutput(names, spinStateOrder, outWSName, outputs.ppWS, SpinStateConfigurationsWildes::PLUS_PLUS,
+                       addSpinStateLog, hasAnalyser);
   }
   if (outputs.pmWS) {
-    addSpinStateOutput(names, spinStateOrder, outWSName, outputs.pmWS, SpinStateConfigurationsWildes::PLUS_MINUS);
+    addSpinStateOutput(names, spinStateOrder, outWSName, outputs.pmWS, SpinStateConfigurationsWildes::PLUS_MINUS,
+                       addSpinStateLog, hasAnalyser);
   }
   if (outputs.mpWS) {
-    addSpinStateOutput(names, spinStateOrder, outWSName, outputs.mpWS, SpinStateConfigurationsWildes::MINUS_PLUS);
+    addSpinStateOutput(names, spinStateOrder, outWSName, outputs.mpWS, SpinStateConfigurationsWildes::MINUS_PLUS,
+                       addSpinStateLog, hasAnalyser);
   }
   if (outputs.mmWS) {
-    addSpinStateOutput(names, spinStateOrder, outWSName, outputs.mmWS, SpinStateConfigurationsWildes::MINUS_MINUS);
+    addSpinStateOutput(names, spinStateOrder, outWSName, outputs.mmWS, SpinStateConfigurationsWildes::MINUS_MINUS,
+                       addSpinStateLog, hasAnalyser);
   }
 
   auto group = createChildAlgorithm("GroupWorkspaces");
@@ -547,16 +560,24 @@ API::WorkspaceGroup_sptr PolarizationCorrectionWildes::groupOutput(const Workspa
 
 /**
  * Add an output name in the correct position in the vector and to the ADS.
+ * Optionally adds a spin state log to the output workspace.
  * @param names A list of the names of the workspaces the algorithm has generated.
  * @param spinStateOrder The order the output should be in.
  * @param baseName The base name for the output workspaces ("BASENAME_SPINSTATE" e.g "OUTNAME_+-")
  * @param ws The workspace to add to the vector and ADS.
  * @param spinState The spin state the workspace represents.
+ * @param addSpinStateLog Whether to add a sample log to the output workspace giving the spin state using the
+ * Reflectometry ORSO notation.
+ * @param hasAnalyser Whether the flipper configuration included an analyser.
  */
 void PolarizationCorrectionWildes::addSpinStateOutput(std::vector<std::string> &names,
                                                       const std::string &spinStateOrder, const std::string &baseName,
-                                                      const API::MatrixWorkspace_sptr &ws,
-                                                      const std::string &spinState) {
+                                                      const API::MatrixWorkspace_sptr &ws, const std::string &spinState,
+                                                      const bool addSpinStateLog, const bool hasAnalyser) {
+  if (addSpinStateLog) {
+    addSpinStateLogToWs(ws, spinState, hasAnalyser);
+  }
+
   if (spinStateOrder.empty()) {
     names.emplace_back(baseName + "_" + spinState);
     API::AnalysisDataService::Instance().addOrReplace(names.back(), ws);
@@ -573,6 +594,29 @@ void PolarizationCorrectionWildes::addSpinStateOutput(std::vector<std::string> &
   }
 }
 
+/**
+ * Adds a sample log to the workspace that gives the spin state of the data using Reflectometry ORSO notation.
+ * @param ws The workspace to add the sample log to.
+ * @param spinState The spin state the workspace represents.
+ * @param hasAnalyser Whether the flipper configuration included an analyser.
+ */
+void PolarizationCorrectionWildes::addSpinStateLogToWs(const API::MatrixWorkspace_sptr &ws,
+                                                       const std::string &spinState, const bool hasAnalyser) {
+  if (!hasAnalyser) {
+    if (spinState == SpinStateConfigurationsWildes::PLUS_PLUS) {
+      SpinStatesORSO::addORSOLogForSpinState(ws, SpinStateConfigurationsWildes::PLUS);
+      return;
+    }
+
+    if (spinState == SpinStateConfigurationsWildes::MINUS_MINUS) {
+      SpinStatesORSO::addORSOLogForSpinState(ws, SpinStateConfigurationsWildes::MINUS);
+      return;
+    }
+  }
+
+  SpinStatesORSO::addORSOLogForSpinState(ws, spinState);
+}
+
 /**
  * Make a convenience access object to the efficiency factors.
  * @return an EfficiencyMap object

Framework/Algorithms/src/PolarizationCorrections/PolarizationCorrectionsHelpers.cpp

@@ -6,14 +6,17 @@
 // SPDX - License - Identifier: GPL - 3.0 +
 
 #include "MantidAlgorithms/PolarizationCorrections/PolarizationCorrectionsHelpers.h"
+#include "MantidAPI/Run.h"
 #include "MantidKernel/StringTokenizer.h"
 
 #include <algorithm>
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <vector>
 
-namespace Mantid::Algorithms::PolarizationCorrectionsHelpers {
+namespace Mantid {
+namespace Algorithms {
+namespace PolarizationCorrectionsHelpers {
 
 /**
  * Returns the workspace in the group associated with the given targetSpinState according to the order defined by
@@ -59,4 +62,57 @@ std::vector<std::string> splitSpinStateString(const std::string &spinStates) {
   StringTokenizer tokens{spinStates, ",", StringTokenizer::TOK_TRIM};
   return std::vector<std::string>{tokens.begin(), tokens.end()};
 }
-} // namespace Mantid::Algorithms::PolarizationCorrectionsHelpers
+} // namespace PolarizationCorrectionsHelpers
+
+namespace SpinStatesORSO {
+/*
+ * For a given polarization spin state, return the corresponding Reflectometry ORSO file format notation.
+ * @param spinState The spin state to find the ORSO notation for.
+ * @return The ORSO notation that represents the given polarization spin state.
+ * @throw std::invalid_argument if no corresponding ORSO notation can be found.
+ */
+const std::string &getORSONotationForSpinState(const std::string &spinState) {
+  if (spinState == SpinStateConfigurationsWildes::PLUS_PLUS ||
+      spinState == SpinStateConfigurationsFredrikze::PARA_PARA) {
+    return SpinStatesORSO::PP;
+  }
+
+  if (spinState == SpinStateConfigurationsWildes::PLUS_MINUS ||
+      spinState == SpinStateConfigurationsFredrikze::PARA_ANTI) {
+    return SpinStatesORSO::PM;
+  }
+
+  if (spinState == SpinStateConfigurationsWildes::MINUS_PLUS ||
+      spinState == SpinStateConfigurationsFredrikze::ANTI_PARA) {
+    return SpinStatesORSO::MP;
+  }
+
+  if (spinState == SpinStateConfigurationsWildes::MINUS_MINUS ||
+      spinState == SpinStateConfigurationsFredrikze::ANTI_ANTI) {
+    return SpinStatesORSO::MM;
+  }
+
+  if (spinState == SpinStateConfigurationsWildes::PLUS || spinState == SpinStateConfigurationsFredrikze::PARA) {
+    return SpinStatesORSO::PO;
+  }
+
+  if (spinState == SpinStateConfigurationsWildes::MINUS || spinState == SpinStateConfigurationsFredrikze::ANTI) {
+    return SpinStatesORSO::MO;
+  }
+
+  throw std::invalid_argument("Cannot convert spin state " + spinState + " into ORSO notation.");
+}
+
+/*
+ * Add a sample log entry for the given polarization spin state using the corresponding Reflectometry ORSO file format
+ * notation.
+ * @param spinState The spin state to add the ORSO spin state sample log for.
+ * @throw std::invalid_argument if no corresponding ORSO spin state notation can be found.
+ */
+void addORSOLogForSpinState(const Mantid::API::MatrixWorkspace_sptr &ws, const std::string &spinState) {
+  const auto &logValue = getORSONotationForSpinState(spinState);
+  ws->mutableRun().addProperty(SpinStatesORSO::LOG_NAME, logValue, true);
+}
+} // namespace SpinStatesORSO
+} // namespace Algorithms
+} // namespace Mantid

Framework/Algorithms/src/PolarizationEfficiencyCor.cpp

@@ -36,7 +36,7 @@ static const std::string OUTPUT_WORKSPACES{"OutputWorkspace"};
 static const std::string CORRECTION_METHOD{"CorrectionMethod"};
 static const std::string INPUT_FRED_SPIN_STATES{"SpinStatesInFredrikze"};
 static const std::string OUTPUT_FRED_SPIN_STATES{"SpinStatesOutFredrikze"};
-
+static const std::string ADD_SPIN_STATE_LOG{"AddSpinStateToLog"};
 } // namespace Prop
 
 namespace CorrectionMethod {
@@ -136,6 +136,10 @@ void PolarizationEfficiencyCor::init() {
       std::make_unique<WorkspaceProperty<WorkspaceGroup>>(Prop::OUTPUT_WORKSPACES, "", Kernel::Direction::Output),
       "A group of polarization efficiency corrected workspaces.");
 
+  declareProperty(Prop::ADD_SPIN_STATE_LOG, false,
+                  "Whether to add the final spin state into the sample log of each child workspace in the output "
+                  "group. (Wildes method only).");
+
   setPropertySettings(
       Prop::OUTPUT_WILDES_SPIN_STATES,
       std::make_unique<EnabledWhenProperty>(Prop::CORRECTION_METHOD, Kernel::IS_EQUAL_TO, CorrectionMethod::WILDES));
@@ -181,6 +185,9 @@ void PolarizationEfficiencyCor::execWildes() {
   if (!isDefault(Prop::FLIPPERS)) {
     alg->setPropertyValue("Flippers", getPropertyValue(Prop::FLIPPERS));
   }
+  if (!isDefault(Prop::ADD_SPIN_STATE_LOG)) {
+    alg->setPropertyValue("AddSpinStateToLog", getPropertyValue(Prop::ADD_SPIN_STATE_LOG));
+  }
   if (!isDefault(Prop::OUTPUT_WILDES_SPIN_STATES)) {
     alg->setPropertyValue("SpinStates", getPropertyValue(Prop::OUTPUT_WILDES_SPIN_STATES));
   }