SofQW.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2010 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 +
#pragma once
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/DataProcessorAlgorithm.h"
 
#include "MantidAPI/BinEdgeAxis.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAlgorithms/SofQCommon.h"
#include "MantidDataObjects/WorkspaceCreation.h"
#include "MantidKernel/UnitFactory.h"
#include "MantidKernel/VectorHelper.h"
 
namespace Mantid {
namespace Algorithms {
struct SofQCommon;
 
class MANTID_ALGORITHMS_DLL SofQW : public API::DataProcessorAlgorithm {
public:
  const std::string name() const override { return "SofQW"; }
  const std::string summary() const override;
 
  int version() const override { return (1); }
  const std::vector<std::string> seeAlso() const override {
    return {"SofQWCentre", "SofQWPolygon", "SofQWNormalisedPolygon", "Rebin2D"};
  }
  const std::string category() const override { return "Inelastic\\SofQW"; }
  template <typename Workspace>
  static std::unique_ptr<Workspace>
  setUpOutputWorkspace(const API::MatrixWorkspace &inputWorkspace, const std::vector<double> &qbinParams,
                       std::vector<double> &qAxis, const std::vector<double> &ebinParams,
                       const SofQCommon &emodeProperties);
  static void createCommonInputProperties(API::Algorithm &alg);
 
private:
  void init() override;
  void exec() override;
};
 
template <typename Workspace>
std::unique_ptr<Workspace>
SofQW::setUpOutputWorkspace(const API::MatrixWorkspace &inputWorkspace, const std::vector<double> &qbinParams,
                            std::vector<double> &qAxis, const std::vector<double> &ebinParams,
                            const SofQCommon &emodeProperties) {
  using Kernel::VectorHelper::createAxisFromRebinParams;
  // Create vector to hold the new X axis values
  HistogramData::BinEdges xAxis(0);
  double eMin{std::nan("")};
  double eMax{std::nan("")};
  if (ebinParams.empty()) {
    xAxis = inputWorkspace.binEdges(0);
  } else if (ebinParams.size() == 1) {
    inputWorkspace.getXMinMax(eMin, eMax);
    createAxisFromRebinParams(ebinParams, xAxis.mutableRawData(), true, true, eMin, eMax);
  } else {
    createAxisFromRebinParams(ebinParams, xAxis.mutableRawData());
  }
  // Create a vector to temporarily hold the vertical ('y') axis and populate
  // that
  int yLength;
  if (qbinParams.size() == 1) {
    if (std::isnan(eMin)) {
      inputWorkspace.getXMinMax(eMin, eMax);
    }
    double qMin;
    double qMax;
    std::tie(qMin, qMax) = emodeProperties.qBinHints(inputWorkspace, eMin, eMax);
    yLength = createAxisFromRebinParams(qbinParams, qAxis, true, true, qMin, qMax);
  } else {
    yLength = createAxisFromRebinParams(qbinParams, qAxis);
  }
 
  // Create output workspace, bin edges are same as in inputWorkspace index 0
  auto outputWorkspace = DataObjects::create<Workspace>(inputWorkspace, yLength - 1, xAxis);
 
  // Create a binned numeric axis to replace the default vertical one
  auto verticalAxis = std::make_unique<API::BinEdgeAxis>(qAxis);
  auto verticalAxisRaw = verticalAxis.get();
  outputWorkspace->replaceAxis(1, std::move(verticalAxis));
 
  // Set the axis units
  verticalAxisRaw->unit() = Kernel::UnitFactory::Instance().create("MomentumTransfer");
  verticalAxisRaw->title() = "|Q|";
 
  // Set the X axis title (for conversion to MD)
  outputWorkspace->getAxis(0)->title() = "Energy transfer";
 
  outputWorkspace->setYUnit("");
  outputWorkspace->setYUnitLabel("Intensity");
 
  return outputWorkspace;
}
 
} // namespace Algorithms
} // namespace Mantid