ReferenceFrame.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 "MantidGeometry/Instrument/ReferenceFrame.h"
#include <stdexcept>
 
using namespace Mantid::Kernel;
 
namespace Mantid::Geometry {
 
namespace {
V3D directionToVector(const PointingAlong &direction) {
  V3D result;
  if (direction == X) {
    result = V3D(1, 0, 0);
  } else if (direction == Y) {
    result = V3D(0, 1, 0);
  } else {
    result = V3D(0, 0, 1);
  }
  return result;
}
 
std::string directionToString(const PointingAlong &direction) {
  std::string result;
  if (direction == X) {
    result = "X";
  } else if (direction == Y) {
    result = "Y";
  } else {
    result = "Z";
  }
  return result;
}
} // namespace
 
ReferenceFrame::ReferenceFrame() : ReferenceFrame(Y, Z, Y, Right, "source") {}
 
ReferenceFrame::ReferenceFrame(PointingAlong up, PointingAlong alongBeam, Handedness handedness, std::string origin)
    : ReferenceFrame(up, alongBeam, up, handedness, std::move(origin)) {}
 
ReferenceFrame::ReferenceFrame(PointingAlong up, PointingAlong alongBeam, PointingAlong thetaSign,
                               Handedness handedness, std::string origin)
    : m_up(up), m_alongBeam(alongBeam), m_thetaSign(thetaSign), m_handedness(handedness), m_origin(std::move(origin)) {
  if (up == alongBeam) {
    throw std::invalid_argument("Cannot have up direction the same as the beam direction");
  }
  if (thetaSign == alongBeam) {
    throw std::invalid_argument("Scattering angle sign axis cannot be the same as the beam direction");
  }
  m_vecPointingUp = directionToVector(m_up);
  m_vecPointingAlongBeam = directionToVector(m_alongBeam);
  m_vecThetaSign = directionToVector(m_thetaSign);
}
 
PointingAlong ReferenceFrame::pointingUp() const { return m_up; }
 
PointingAlong ReferenceFrame::pointingAlongBeam() const { return m_alongBeam; }
 
std::string ReferenceFrame::pointingUpAxis() const { return directionToString(m_up); }
 
std::string ReferenceFrame::pointingAlongBeamAxis() const { return directionToString(m_alongBeam); }
 
std::string ReferenceFrame::pointingHorizontalAxis() const { return directionToString(pointingHorizontal()); }
 
PointingAlong ReferenceFrame::pointingHorizontal() const {
  if (m_up == X) {
    if (m_alongBeam == Y)
      return Z;
    else
      return Y;
  } else if (m_up == Y) {
    if (m_alongBeam == Z)
      return X;
    else
      return Z;
  } else {
    if (m_alongBeam == Y)
      return X;
    else
      return Y;
  }
}
 
Handedness ReferenceFrame::getHandedness() const { return m_handedness; }
 
std::string ReferenceFrame::origin() const { return m_origin; }
 
V3D ReferenceFrame::vecPointingUp() const { return m_vecPointingUp; }
 
V3D ReferenceFrame::vecThetaSign() const { return m_vecThetaSign; }
 
V3D ReferenceFrame::vecPointingAlongBeam() const { return m_vecPointingAlongBeam; }
 
V3D ReferenceFrame::vecPointingHorizontal() const { return directionToVector(pointingHorizontal()); }
 
bool ReferenceFrame::isVectorPointingAlongBeam(const V3D &v) const {
  // Normalized (unit) parallel vectors should produce a scalar product of 1
  return m_vecPointingAlongBeam.scalar_prod(normalize(v)) == 1;
}
 
} // namespace Mantid::Geometry