LeanElasticPeak.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 "MantidDataObjects/LeanElasticPeak.h"
#include "MantidDataObjects/NoShape.h"
#include "MantidGeometry/Objects/InstrumentRayTracer.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/Strings.h"
 
#include "boost/make_shared.hpp"
 
#include <algorithm>
#include <cctype>
#include <string>
#include <utility>
 
using namespace Mantid;
using namespace Mantid::Kernel;
using namespace Mantid::Geometry;
 
namespace Mantid::DataObjects {
 
//----------------------------------------------------------------------------------------------
LeanElasticPeak::LeanElasticPeak() : BasePeak(), m_Qsample(V3D(0, 0, 0)), m_wavelength(0.) {}
 
//----------------------------------------------------------------------------------------------
LeanElasticPeak::LeanElasticPeak(const Mantid::Kernel::V3D &QSampleFrame)
    : BasePeak(), m_Qsample(QSampleFrame), m_wavelength(0.) {}
 
//----------------------------------------------------------------------------------------------
LeanElasticPeak::LeanElasticPeak(const Mantid::Kernel::V3D &QSampleFrame,
                                 const Mantid::Kernel::Matrix<double> &goniometer,
                                 boost::optional<std::shared_ptr<const Geometry::ReferenceFrame>> refFrame)
    : BasePeak() {
  if (refFrame.is_initialized())
    setReferenceFrame(refFrame.get());
  setQSampleFrame(QSampleFrame, goniometer);
}
 
//----------------------------------------------------------------------------------------------
LeanElasticPeak::LeanElasticPeak(const Mantid::Kernel::V3D &QSampleFrame, double wavelength)
    : BasePeak(), m_Qsample(QSampleFrame), m_wavelength(wavelength) {}
 
LeanElasticPeak::LeanElasticPeak(const LeanElasticPeak &other) = default;
 
//----------------------------------------------------------------------------------------------
LeanElasticPeak::LeanElasticPeak(const Geometry::IPeak &ipeak)
    : BasePeak(ipeak), m_Qsample(ipeak.getQSampleFrame()), m_wavelength(ipeak.getWavelength()) {}
 
//----------------------------------------------------------------------------------------------
void LeanElasticPeak::setWavelength(double wavelength) { m_wavelength = wavelength; }
 
std::shared_ptr<const Geometry::ReferenceFrame> LeanElasticPeak::getReferenceFrame() const {
  return (m_refFrame) ? m_refFrame : std::make_shared<const ReferenceFrame>();
}
 
void LeanElasticPeak::setReferenceFrame(std::shared_ptr<const ReferenceFrame> frame) { m_refFrame = std::move(frame); }
 
// -------------------------------------------------------------------------------------
double LeanElasticPeak::getWavelength() const { return m_wavelength; }
 
// -------------------------------------------------------------------------------------
double LeanElasticPeak::getTOF() const {
  throw Exception::NotImplementedError("LeanElasticPeak::getTOF(): no detector infomation in LeanElasticPeak");
}
 
int LeanElasticPeak::getRow() const {
  throw Exception::NotImplementedError("LeanElasticPeak::getRow(): no detector infomation in LeanElasticPeak");
}
 
int LeanElasticPeak::getCol() const {
  throw Exception::NotImplementedError("LeanElasticPeak::getCol(): no detector infomation in LeanElasticPeak");
}
 
// -------------------------------------------------------------------------------------
double LeanElasticPeak::getScattering() const { return asin(getWavelength() / (2 * getDSpacing())) * 2; }
 
// -------------------------------------------------------------------------------------
double LeanElasticPeak::getAzimuthal() const {
  const V3D qLab = getQLabFrame();
  std::shared_ptr<const ReferenceFrame> refFrame = getReferenceFrame();
  const double qSign = (m_convention != "Crystallography") ? 1.0 : -1.0;
  const V3D detectorDir = -qLab * qSign;
  if (refFrame)
    return atan2(detectorDir[refFrame->pointingUp()], detectorDir[refFrame->pointingHorizontal()]);
  else
    return atan2(detectorDir[1], detectorDir[0]);
}
 
// -------------------------------------------------------------------------------------
double LeanElasticPeak::getDSpacing() const { return 2 * M_PI / m_Qsample.norm(); }
 
//----------------------------------------------------------------------------------------------
Mantid::Kernel::V3D LeanElasticPeak::getQLabFrame() const { return getGoniometerMatrix() * m_Qsample; }
 
//----------------------------------------------------------------------------------------------
Mantid::Kernel::V3D LeanElasticPeak::getQSampleFrame() const { return m_Qsample; }
 
//----------------------------------------------------------------------------------------------
void LeanElasticPeak::setQSampleFrame(const Mantid::Kernel::V3D &QSampleFrame, boost::optional<double>) {
  m_Qsample = QSampleFrame;
}
 
void LeanElasticPeak::setQSampleFrame(const Mantid::Kernel::V3D &QSampleFrame,
                                      const Mantid::Kernel::Matrix<double> &goniometer) {
  m_Qsample = QSampleFrame;
  setGoniometerMatrix(goniometer);
 
  const V3D qLab = getQLabFrame();
 
  try {
    double wl = calculateWavelengthFromQLab(qLab);
    setWavelength(wl);
  } catch (std::exception &e) {
    g_log.information() << "Unable to automatically determine wavelength from q-lab\n"
                        << e.what() << ", goniometer is likely not correct\n";
  }
}
 
//----------------------------------------------------------------------------------------------
void LeanElasticPeak::setQLabFrame(const Mantid::Kernel::V3D &qLab, boost::optional<double>) {
  this->setQSampleFrame(getInverseGoniometerMatrix() * qLab);
}
 
//----------------------------------------------------------------------------------------------
double LeanElasticPeak::getFinalEnergy() const {
  // Velocity of the neutron (non-relativistic)
  const double velocity = PhysicalConstants::h / (m_wavelength * 1e-10 * PhysicalConstants::NeutronMass);
  // Energy in J of the neutron
  const double energy = PhysicalConstants::NeutronMass * velocity * velocity / 2.0;
  // Convert to meV
  return energy / PhysicalConstants::meV;
}
 
double LeanElasticPeak::getInitialEnergy() const { return getFinalEnergy(); }
 
double LeanElasticPeak::getEnergyTransfer() const { return 0.; }
 
void LeanElasticPeak::setFinalEnergy(double) {
  throw Exception::NotImplementedError("Use LeanElasticPeak::setWavelength");
}
 
void LeanElasticPeak::setInitialEnergy(double) {
  throw Exception::NotImplementedError("Use LeanElasticPeak::setWavelength");
}
 
// -------------------------------------------------------------------------------------
double LeanElasticPeak::getL1() const {
  throw Exception::NotImplementedError("LeanElasticPeak has no detector information");
}
 
// -------------------------------------------------------------------------------------
double LeanElasticPeak::getL2() const {
  throw Exception::NotImplementedError("LeanElasticPeak has no detector information");
}
 
LeanElasticPeak &LeanElasticPeak::operator=(const LeanElasticPeak &other) {
  if (&other != this) {
    BasePeak::operator=(other);
    m_Qsample = other.m_Qsample;
    m_wavelength = other.m_wavelength;
  }
  return *this;
}
 
Mantid::Kernel::Logger LeanElasticPeak::g_log("PeakLogger");
 
} // namespace Mantid::DataObjects