FunctionQDepends.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 +
// Mantid Coding standars <http://www.mantidproject.org/Coding_Standards>
 
// Main Module Header
#include "MantidCurveFitting/Functions/FunctionQDepends.h"
// Mantid Headers from the same project
// N/A
// Mantid headers from other projects
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/NumericAxis.h"
#include "MantidAPI/SpectrumInfo.h"
#include "MantidGeometry/IDetector.h"
#include "MantidKernel/UnitConversion.h"
// third party libraries
// N/A
// standard library
// N/A
 
using Attr = Mantid::API::IFunction::Attribute;
 
namespace {
Mantid::Kernel::Logger g_log("FunctionQDepends");
}
 
namespace Mantid::CurveFitting::Functions {
 
/* ===========
   Public
   ===========*/
 
void FunctionQDepends::declareAttributes() {
  this->declareAttribute("Q", Attr(EMPTY_DBL()));
  this->declareAttribute("WorkspaceIndex", Attr(EMPTY_INT()));
}
 
void FunctionQDepends::setAttribute(const std::string &attName, const Attr &attValue) {
  // Q value is tied to WorkspaceIndex if we have a list of Q values
  if (attName == "WorkspaceIndex") {
    size_t wi{static_cast<size_t>(attValue.asInt())}; // ah!, the "joys" of C++ strong typing.
    if (!m_vQ.empty() && wi < m_vQ.size()) {
      Mantid::API::IFunction::setAttribute(attName, attValue);
      auto qAttr = getAttribute("Q");
      qAttr.setDouble(m_vQ.at(wi));
      // Can't call setAttributeValue, as it will recurse back into here
      Mantid::API::IFunction::setAttribute("Q", qAttr);
    }
  }
  // Q can be manually changed by user only if list of Q values is empty
  else if (attName == "Q") {
    if (m_vQ.empty()) {
      Mantid::API::IFunction::setAttribute(attName, attValue);
    }
  } else {
    Mantid::API::IFunction::setAttribute(attName, attValue);
  }
}
 
void FunctionQDepends::setMatrixWorkspace(std::shared_ptr<const Mantid::API::MatrixWorkspace> workspace, size_t wi,
                                          double startX, double endX) {
  UNUSED_ARG(startX);
  UNUSED_ARG(endX);
  // reset attributes if new workspace is passed
  if (!m_vQ.empty()) {
    Mantid::API::IFunction::setAttributeValue("WorkspaceIndex", EMPTY_INT());
    Mantid::API::IFunction::setAttributeValue("Q", EMPTY_DBL());
  }
  // Obtain Q values from the passed workspace, if possible. m_vQ will be
  // cleared if unsuccessful.
  if (workspace) {
    m_vQ = this->extractQValues(*workspace);
  }
  if (!m_vQ.empty()) {
    this->setAttributeValue("WorkspaceIndex", static_cast<int>(wi));
  }
}
 
/* ===========
   Private
   ===========*/
 
std::vector<double> FunctionQDepends::extractQValues(const Mantid::API::MatrixWorkspace &workspace) {
  std::vector<double> qs;
  // Check if the vertical axis has units of momentum transfer, then extract Q
  // values...
  auto axis_ptr = dynamic_cast<Mantid::API::NumericAxis *>(workspace.getAxis(1));
  if (axis_ptr) {
    const std::shared_ptr<Kernel::Unit> &unit_ptr = axis_ptr->unit();
    if (unit_ptr->unitID() == "MomentumTransfer") {
      qs = axis_ptr->getValues();
    }
  }
  // ...otherwise, compute the momentum transfer for each spectrum, if possible
  else {
    const auto &spectrumInfo = workspace.spectrumInfo();
    size_t numHist = workspace.getNumberHistograms();
    for (size_t wi = 0; wi < numHist; wi++) {
      if (spectrumInfo.hasDetectors(wi)) {
        const auto detID = spectrumInfo.detector(wi).getID();
        double efixed = workspace.getEFixed(detID);
        double usignTheta = 0.5 * spectrumInfo.twoTheta(wi);
        double q = Mantid::Kernel::UnitConversion::convertToElasticQ(usignTheta, efixed);
        qs.emplace_back(q);
      } else {
        g_log.debug("Cannot populate Q values from workspace");
        qs.clear();
        break;
      }
    }
  }
  return qs;
}
 
} // namespace Mantid::CurveFitting::Functions