V3D.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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
 
#include "MantidKernel/DllConfig.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/Tolerance.h"
#include "MantidKernel/V3D_fwd.h"
#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <numeric>
#include <sstream>
#include <vector>
 
namespace Mantid::Nexus {
class File;
}
 
namespace Mantid {
namespace Kernel {
template <class T> class Matrix;
class MANTID_KERNEL_DLL V3D final {
public:
  constexpr V3D() noexcept : m_pt({{0., 0., 0.}}) {}
  constexpr V3D(double xx, double yy, double zz) noexcept : m_pt({{xx, yy, zz}}) {}
 
  static bool compareMagnitude(const Kernel::V3D &v1, const Kernel::V3D &v2);
 
  // explicit conversion into vector
  operator std::vector<double>() const { return std::vector<double>(m_pt.cbegin(), m_pt.cend()); }
 
  std::size_t size() const noexcept { return m_pt.size(); }
 
  constexpr V3D operator+(const V3D &v) const noexcept {
    return V3D(m_pt[0] + v.m_pt[0], m_pt[1] + v.m_pt[1], m_pt[2] + v.m_pt[2]);
  }
 
  constexpr V3D operator-(const V3D &v) const noexcept {
    return V3D(m_pt[0] - v.m_pt[0], m_pt[1] - v.m_pt[1], m_pt[2] - v.m_pt[2]);
  }
 
  constexpr V3D operator*(const V3D &v) const noexcept {
    return V3D(m_pt[0] * v.m_pt[0], m_pt[1] * v.m_pt[1], m_pt[2] * v.m_pt[2]);
  }
 
  constexpr V3D operator/(const V3D &v) const noexcept {
    return V3D(m_pt[0] / v.m_pt[0], m_pt[1] / v.m_pt[1], m_pt[2] / v.m_pt[2]);
  }
 
  V3D &operator+=(const V3D &v) noexcept {
    for (size_t i = 0; i < m_pt.size(); ++i) {
      m_pt[i] += v.m_pt[i];
    }
    return *this;
  }
 
  V3D &operator-=(const V3D &v) noexcept {
    for (size_t i = 0; i < m_pt.size(); ++i) {
      m_pt[i] -= v.m_pt[i];
    }
    return *this;
  }
 
  V3D &operator*=(const V3D &v) noexcept {
    for (size_t i = 0; i < m_pt.size(); ++i) {
      m_pt[i] *= v.m_pt[i];
    }
    return *this;
  }
 
  V3D &operator/=(const V3D &v) noexcept {
    for (size_t i = 0; i < m_pt.size(); ++i) {
      m_pt[i] /= v.m_pt[i];
    }
    return *this;
  }
 
  constexpr V3D operator*(const double D) const noexcept { return V3D(m_pt[0] * D, m_pt[1] * D, m_pt[2] * D); }
 
  constexpr V3D operator/(const double D) const noexcept { return V3D(m_pt[0] / D, m_pt[1] / D, m_pt[2] / D); }
 
  V3D &operator*=(const double D) noexcept {
    std::for_each(m_pt.begin(), m_pt.end(), [D](auto &pt) { pt *= D; });
    return *this;
  }
 
  V3D &operator/=(const double D) noexcept {
    std::for_each(m_pt.begin(), m_pt.end(), [D](auto &pt) { pt /= D; });
    return *this;
  }
 
  constexpr V3D operator-() const noexcept { return V3D(-m_pt[0], -m_pt[1], -m_pt[2]); }
 
  bool operator==(const V3D &v) const noexcept {
    return !(std::abs(m_pt[0] - v.m_pt[0]) > Tolerance || std::abs(m_pt[1] - v.m_pt[1]) > Tolerance ||
             std::abs(m_pt[2] - v.m_pt[2]) > Tolerance);
  }
 
  bool operator!=(const V3D &other) const noexcept { return !(this->operator==(other)); }
 
  constexpr bool operator<(const V3D &V) const noexcept {
    if (m_pt[0] != V.m_pt[0])
      return m_pt[0] < V.m_pt[0];
    if (m_pt[1] != V.m_pt[1])
      return m_pt[1] < V.m_pt[1];
    return m_pt[2] < V.m_pt[2];
  }
 
  constexpr bool operator>(const V3D &rhs) const noexcept { return rhs < *this; }
 
  void operator()(const double xx, const double yy, const double zz) noexcept { m_pt = {{xx, yy, zz}}; }
 
  // Access
  // Setting x, y and z values
  void spherical(const double R, const double theta, const double phi) noexcept;
  void spherical_rad(const double R, const double polar, const double azimuth) noexcept;
  void azimuth_polar_SNS(const double R, const double azimuth, const double polar) noexcept;
  void setX(const double xx) noexcept { m_pt[0] = xx; }
 
  void setY(const double yy) noexcept { m_pt[1] = yy; }
 
  void setZ(const double zz) noexcept { m_pt[2] = zz; }
 
  constexpr double X() const noexcept { return m_pt[0]; } 
  constexpr double Y() const noexcept { return m_pt[1]; } 
  constexpr double Z() const noexcept { return m_pt[2]; } 
 
  constexpr double operator[](const size_t index) const noexcept {
    assert(index < m_pt.size());
    return m_pt[index];
  }
 
  double &operator[](const size_t index) noexcept {
    assert(index < m_pt.size());
    return m_pt[index];
  }
 
  void getSpherical(double &R, double &theta, double &phi) const noexcept;
 
  void rotate(const Matrix<double> &) noexcept;
 
  void round() noexcept;
  double normalize();
  double norm() const noexcept { return sqrt(norm2()); }
  constexpr double norm2() const noexcept { return m_pt[0] * m_pt[0] + m_pt[1] * m_pt[1] + m_pt[2] * m_pt[2]; }
  double toMillerIndexes(double eps = 1.e-3);
  constexpr double scalar_prod(const V3D &v) const noexcept {
    return m_pt[0] * v.m_pt[0] + m_pt[1] * v.m_pt[1] + m_pt[2] * v.m_pt[2];
  }
  constexpr V3D cross_prod(const V3D &v) const noexcept {
    return V3D(m_pt[1] * v.m_pt[2] - m_pt[2] * v.m_pt[1], m_pt[2] * v.m_pt[0] - m_pt[0] * v.m_pt[2],
               m_pt[0] * v.m_pt[1] - m_pt[1] * v.m_pt[0]);
  }
  double distance(const V3D &v) const noexcept { return (*this - v).norm(); }
  double zenith(const V3D &) const noexcept;
  double angle(const V3D &) const;
  double cosAngle(const V3D &) const;
  V3D directionAngles(bool inDegrees = true) const;
  int maxCoeff() const;
  V3D absoluteValue() const;
  double hklError() const;
 
  // Make 2 vectors into 3 orthogonal vectors
  static std::vector<V3D> makeVectorsOrthogonal(const std::vector<V3D> &vectors);
 
  // Send to a stream
  void printSelf(std::ostream &) const;
  void readPrinted(std::istream &);
  void read(std::istream &);
  void write(std::ostream &) const;
  std::string toString() const;
  void fromString(const std::string &str);
 
  double volume() const noexcept { return std::abs(m_pt[0] * m_pt[1] * m_pt[2]); }
  int reBase(const V3D &, const V3D &, const V3D &) noexcept;
  int masterDir(const double Tol = 1e-3) const noexcept;
  bool nullVector(const double tolerance = 1e-3) const noexcept;
  bool unitVector(const double tolerance = Kernel::Tolerance) const noexcept;
  bool coLinear(const V3D &, const V3D &) const noexcept;
 
  void saveNexus(Nexus::File *file, const std::string &name) const;
  void loadNexus(Nexus::File *file, const std::string &name);
 
  static bool isnan(V3D const &vec) { return (std::isnan(vec.X()) || std::isnan(vec.Y()) || std::isnan(vec.Z())); }
 
private:
  std::array<double, 3> m_pt;
};
 
// Overload operator <<
MANTID_KERNEL_DLL std::ostream &operator<<(std::ostream &, const V3D &);
MANTID_KERNEL_DLL std::istream &operator>>(std::istream &, V3D &);
 
inline MANTID_KERNEL_DLL V3D normalize(V3D v) {
  v.normalize();
  return v;
}
 
} // Namespace Kernel
} // Namespace Mantid