ExtractQENSMembers.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidWorkflowAlgorithms/ExtractQENSMembers.h"
 
#include "MantidAPI/ADSValidator.h"
#include "MantidAPI/Axis.h"
#include "MantidAPI/NumericAxis.h"
#include "MantidKernel/ArrayProperty.h"
 
#include <algorithm>
#include <boost/numeric/conversion/cast.hpp>
 
namespace {
Mantid::Kernel::Logger g_log("ExtractQENSMembers");
}
 
namespace Mantid::Algorithms {
 
using namespace API;
using namespace Kernel;
 
// Register the algorithm into the AlgorithmFactory
DECLARE_ALGORITHM(ExtractQENSMembers)
 
//----------------------------------------------------------------------------------------------
 
 
const std::string ExtractQENSMembers::name() const { return "ExtractQENSMembers"; }
 
int ExtractQENSMembers::version() const { return 1; }
 
const std::string ExtractQENSMembers::category() const { return "Workflow\\MIDAS"; }
 
const std::string ExtractQENSMembers::summary() const { return "Extracts the fit members from a QENS fit"; }
 
//----------------------------------------------------------------------------------------------
void ExtractQENSMembers::init() {
  declareProperty(std::make_unique<WorkspaceProperty<>>("InputWorkspace", "", Direction::Input, PropertyMode::Optional),
                  "The input workspace used in the fit. Ignored if 'InputWorkspaces' "
                  "property is provided.");
  declareProperty(std::make_unique<ArrayProperty<std::string>>("InputWorkspaces", ""),
                  "List of the workspaces used in the fit.");
  declareProperty(std::make_unique<WorkspaceProperty<WorkspaceGroup>>("ResultWorkspace", "", Direction::Input),
                  "The result group workspace produced in a QENS fit.");
  declareProperty("RenameConvolvedMembers", false,
                  "If true, renames the n-th 'Convolution' member, to the n-th "
                  "supplied name in the ConvolvedMembers property.");
  declareProperty(std::make_unique<ArrayProperty<std::string>>("ConvolvedMembers"),
                  "A list of the names of the members which were convolved "
                  "before being output by the fit routine. These must be "
                  "provided in the same order as originally provided to the "
                  "fit.");
  declareProperty(std::make_unique<WorkspaceProperty<WorkspaceGroup>>("OutputWorkspace", "", Direction::Output),
                  "The output workspace group, containing the fit members.");
}
 
std::map<std::string, std::string> ExtractQENSMembers::validateInputs() {
  std::map<std::string, std::string> errors;
  std::vector<std::string> workspaceNames = getProperty("InputWorkspaces");
  MatrixWorkspace_sptr inputWorkspace = getProperty("InputWorkspace");
 
  if (workspaceNames.empty() && !inputWorkspace)
    errors["InputWorkspace"] = "Neither the InputWorkspace or InputWorkspaces "
                               "property have been defined.";
  return errors;
}
 
void ExtractQENSMembers::exec() {
  auto inputWorkspaces = getInputWorkspaces();
  WorkspaceGroup_sptr resultWS = getProperty("ResultWorkspace");
  MatrixWorkspace_sptr initialWS = std::dynamic_pointer_cast<MatrixWorkspace>(resultWS->getItem(0));
  const auto qValues = getQValues(inputWorkspaces);
  auto members = getAxisLabels(initialWS, 1);
 
  bool renameConvolved = getProperty("RenameConvolvedMembers");
  if (renameConvolved)
    members = renameConvolvedMembers(members, getProperty("ConvolvedMembers"));
 
  auto memberWorkspaces = createMembersWorkspaces(initialWS, members);
 
  for (auto i = 1u; i < resultWS->size(); ++i)
    appendToMembers(std::dynamic_pointer_cast<MatrixWorkspace>(resultWS->getItem(i)), memberWorkspaces);
  setNumericAxis(memberWorkspaces, qValues, 1);
 
  std::string outputWSName = getProperty("OutputWorkspace");
  auto workspaceNames = addMembersToADS(members, memberWorkspaces, outputWSName);
  setProperty("OutputWorkspace", groupWorkspaces(workspaceNames));
}
 
std::vector<MatrixWorkspace_sptr> ExtractQENSMembers::getInputWorkspaces() const {
  const std::vector<std::string> workspaceNames = getProperty("InputWorkspaces");
  std::vector<MatrixWorkspace_sptr> workspaces;
 
  if (!workspaceNames.empty()) {
    workspaces.reserve(workspaceNames.size());
    auto &ADS = AnalysisDataService::Instance();
    std::transform(workspaceNames.cbegin(), workspaceNames.cend(), std::back_inserter(workspaces),
                   [&ADS](const auto &name) { return ADS.retrieveWS<MatrixWorkspace>(name); });
  } else
    workspaces.emplace_back(getProperty("InputWorkspace"));
  return workspaces;
}
 
std::vector<double> ExtractQENSMembers::getQValues(const std::vector<MatrixWorkspace_sptr> &workspaces) {
  std::vector<double> qValues;
 
  for (const auto &workspace : workspaces) {
    auto getQs = createChildAlgorithm("GetQsInQENSData", -1.0, -1.0, false);
    getQs->setProperty("InputWorkspace", workspace);
    getQs->executeAsChildAlg();
    const std::vector<double> values = getQs->getProperty("Qvalues");
    qValues.insert(std::end(qValues), std::begin(values), std::end(values));
  }
  return qValues;
}
 
std::vector<std::string> ExtractQENSMembers::getAxisLabels(const MatrixWorkspace_sptr &workspace,
                                                           size_t axisIndex) const {
  auto axis = workspace->getAxis(axisIndex);
  std::vector<std::string> labels;
  labels.reserve(axis->length());
 
  for (auto i = 0u; i < axis->length(); ++i)
    labels.emplace_back(axis->label(i));
  return labels;
}
 
std::vector<std::string> ExtractQENSMembers::renameConvolvedMembers(const std::vector<std::string> &members,
                                                                    const std::vector<std::string> &newNames) const {
  std::vector<std::string> newMembers;
  newMembers.reserve(members.size());
  auto index = 0u;
 
  for (const auto &member : members) {
    if (member == "Convolution" && index < newNames.size())
      newMembers.emplace_back(newNames[index++]);
    else
      newMembers.emplace_back(member);
  }
  return newMembers;
}
 
MatrixWorkspace_sptr ExtractQENSMembers::extractSpectrum(const MatrixWorkspace_sptr &inputWS, size_t spectrum) {
  auto extractAlg = createChildAlgorithm("ExtractSpectra", -1.0, -1.0, false);
  extractAlg->setProperty("InputWorkspace", inputWS);
  extractAlg->setProperty("OutputWorkspace", "__extracted");
  extractAlg->setProperty("StartWorkspaceIndex", boost::numeric_cast<int>(spectrum));
  extractAlg->setProperty("EndWorkspaceIndex", boost::numeric_cast<int>(spectrum));
  extractAlg->executeAsChildAlg();
  return extractAlg->getProperty("OutputWorkspace");
}
 
MatrixWorkspace_sptr ExtractQENSMembers::appendSpectra(const MatrixWorkspace_sptr &inputWS,
                                                       const MatrixWorkspace_sptr &spectraWorkspace) {
  auto appendAlg = createChildAlgorithm("AppendSpectra", -1.0, -1.0, false);
  appendAlg->setProperty("InputWorkspace1", inputWS);
  appendAlg->setProperty("InputWorkspace2", spectraWorkspace);
  appendAlg->setProperty("OutputWorkspace", inputWS);
  appendAlg->executeAsChildAlg();
  return appendAlg->getProperty("OutputWorkspace");
}
 
WorkspaceGroup_sptr ExtractQENSMembers::groupWorkspaces(const std::vector<std::string> &workspaceNames) {
  auto groupAlg = createChildAlgorithm("GroupWorkspaces", -1.0, -1.0, false);
  groupAlg->setProperty("InputWorkspaces", workspaceNames);
  groupAlg->setProperty("OutputWorkspace", "__grouped");
  groupAlg->execute();
  return groupAlg->getProperty("OutputWorkspace");
}
 
std::vector<MatrixWorkspace_sptr> ExtractQENSMembers::createMembersWorkspaces(const MatrixWorkspace_sptr &initialWS,
                                                                              const std::vector<std::string> &members) {
  std::vector<MatrixWorkspace_sptr> memberWorkspaces;
  memberWorkspaces.reserve(members.size());
  for (auto i = 0u; i < members.size(); ++i)
    memberWorkspaces.emplace_back(extractSpectrum(initialWS, i));
  return memberWorkspaces;
}
 
void ExtractQENSMembers::appendToMembers(const MatrixWorkspace_sptr &resultWS,
                                         std::vector<Mantid::API::MatrixWorkspace_sptr> &members) {
  for (auto i = 0u; i < members.size(); ++i)
    members[i] = appendSpectra(members[i], extractSpectrum(resultWS, i));
}
 
void ExtractQENSMembers::setNumericAxis(const std::vector<MatrixWorkspace_sptr> &workspaces,
                                        const std::vector<double> &values, size_t axisIndex) const {
  auto qAxis = NumericAxis(values.size());
  for (auto i = 0u; i < values.size(); ++i)
    qAxis.setValue(i, values[i]);
 
  for (auto &workspace : workspaces) {
    workspace->replaceAxis(axisIndex, std::make_unique<NumericAxis>(qAxis));
    workspace->setYUnitLabel("MomentumTransfer");
  }
}
 
std::vector<std::string>
ExtractQENSMembers::addMembersToADS(const std::vector<std::string> &members,
                                    const std::vector<Mantid::API::MatrixWorkspace_sptr> &memberWorkspaces,
                                    const std::string &outputWSName) {
  std::unordered_map<std::string, size_t> nameCounts;
  std::vector<std::string> workspaceNames;
  workspaceNames.reserve(members.size());
 
  for (auto i = 0u; i < members.size(); ++i) {
    std::string count = "";
 
    if (nameCounts.find(members[i]) == nameCounts.end())
      nameCounts[members[i]] = 1;
    else
      count = std::to_string(++nameCounts[members[i]]);
 
    const auto name = outputWSName + "_" + members[i] + count;
    AnalysisDataService::Instance().addOrReplace(name, memberWorkspaces[i]);
    workspaceNames.emplace_back(name);
  }
  return workspaceNames;
}
 
} // namespace Mantid::Algorithms