Torus.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 <algorithm>
#include <cmath>
#include <fstream>
#include <list>
#include <map>
#include <sstream>
#include <stack>
#include <vector>
 
#include "MantidGeometry/Surfaces/BaseVisit.h"
#include "MantidGeometry/Surfaces/Surface.h"
#include "MantidGeometry/Surfaces/Torus.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/Matrix.h"
#include "MantidKernel/Strings.h"
#include "MantidKernel/Tolerance.h"
#include "MantidKernel/V3D.h"
 
#ifdef ENABLE_OPENCASCADE
// Opencascade defines _USE_MATH_DEFINES without checking whether it is already
// used.
// Undefine it here before we include the headers to avoid a warning
#ifdef _MSC_VER
#undef _USE_MATH_DEFINES
#ifdef M_SQRT1_2
#undef M_SQRT1_2
#endif
#endif
 
#include "MantidKernel/WarningSuppressions.h"
GNU_DIAG_OFF("conversion")
GNU_DIAG_OFF("cast-qual")
#include <TopoDS_Shape.hxx>
GNU_DIAG_ON("conversion")
GNU_DIAG_ON("cast-qual")
#endif
 
namespace Mantid::Geometry {
using Kernel::Tolerance;
using Kernel::V3D;
 
Torus::Torus()
    : Surface(), Centre(), Normal(1, 0, 0), Iradius(0), Dradius(0), Displacement(0)
{
  throw Kernel::Exception::NotImplementedError("Torus is not implemented.");
}
 
Torus *Torus::doClone() const
{
  return new Torus(*this);
}
 
std::unique_ptr<Torus> Torus::clone() const
{
  return std::unique_ptr<Torus>(doClone());
}
 
int Torus::operator==(const Torus &A) const
{
  if (this == &A)
    return 1;
 
  if ((fabs(Displacement - A.Displacement) > Tolerance) || (fabs(Iradius - A.Iradius) > Tolerance) ||
      (fabs(Dradius - A.Dradius) > Tolerance))
    return 0;
 
  if (Centre.distance(A.Centre) > Tolerance)
    return 0;
  if (Normal.distance(A.Normal) > Tolerance)
    return 0;
 
  return 1;
}
 
/*
  takes a character string and evaluates
  the first <T> object. The string is then filled with
  spaces upto the end of the <T> object
  @param out :: place for output
  @param A :: string for input and output.
  @return 1 on success 0 on failure
*/
int sectionV3D(std::string &A, Mantid::Kernel::V3D &out) {
  if (A.empty())
    return 0;
  std::istringstream cx;
  Mantid::Kernel::V3D retval;
  cx.str(A);
  cx.clear();
  cx >> retval;
  if (cx.fail())
    return 0;
  const std::streamoff xpt = cx.tellg();
  const auto xc = static_cast<char>(cx.get());
  if (!cx.fail() && !isspace(xc))
    return 0;
  A.erase(0, static_cast<unsigned int>(xpt));
  out = retval;
  return 1;
}
 
int Torus::setSurface(const std::string &Pstr)
{
  enum { errDesc = -1, errAxis = -2, errCent = -3, errNormal = -4 };
 
  std::string Line = Pstr;
 
  std::string item;
  if (!Mantid::Kernel::Strings::section(Line, item) || tolower(item[0]) != 't' || item.length() != 3)
    return errDesc;
 
  // Torus on X/Y/Z axis
  const auto ptype = static_cast<std::size_t>(tolower(item[2]) - 'x');
  if (ptype >= 3)
    return errAxis;
 
  Kernel::V3D PtVec;
 
  // Torus on X/Y/Z axis
  if (!sectionV3D(Line, Centre))
    return errCent;
  if (!sectionV3D(Line, PtVec))
    return errNormal;
 
  Iradius = PtVec[1];
  Dradius = PtVec[2];
  Displacement = PtVec[0];
  return 0;
}
 
void Torus::rotate(const Kernel::Matrix<double> &R)
{
  Centre.rotate(R);
  Normal.rotate(R);
}
 
void Torus::displace(const Kernel::V3D &A)
{
  Centre += A;
}
 
void Torus::setCentre(const Kernel::V3D &A)
{
  Centre = A;
}
 
void Torus::setNorm(const Kernel::V3D &A)
{
  const auto length = A.norm();
  if (length > Tolerance) {
    Normal = A / length;
  }
}
 
Kernel::V3D Torus::surfaceNormal(const Kernel::V3D &Pt) const
{
  UNUSED_ARG(Pt);
  return Normal;
}
 
double Torus::distance(const Kernel::V3D &Pt) const
{
  const Kernel::V3D Px = Pt - Centre;
  // test is the centre to point distance is zero
  if (Px.norm() < Tolerance)
    return 0;
  return Px.norm();
}
 
int Torus::side(const Kernel::V3D &R) const
 
{
  UNUSED_ARG(R);
  return -1;
}
 
bool Torus::onSurface(const Kernel::V3D &R) const {
  UNUSED_ARG(R);
  // was formerly alwasy returning -1 which bool(-1) == true
  // which appears to be an accidental bug
 
  // the previous doxygen comment was
  // return 1 if on surface and -1 if not no surface
  return false;
}
 
void Torus::write(std::ostream &OX) const
{
  //               -3 -2 -1 0 1 2 3
  const char Tailends[] = "zyx xyz";
  const int Ndir = Normal.masterDir(Tolerance);
  if (Ndir == 0) {
    Surface::write(OX);
    return;
  }
  std::ostringstream cx;
  Surface::writeHeader(cx);
  cx << "t" << Tailends[Ndir + 3] << " ";
  cx.precision(Surface::Nprecision);
  // Name and transform
 
  cx << Centre << " " << Displacement << " " << Iradius << " " << Dradius;
  Mantid::Kernel::Strings::writeMCNPX(cx.str(), OX);
}
 
void Torus::getBoundingBox(double &xmax, double &ymax, double &zmax, double &xmin, double &ymin, double &zmin) {
  UNUSED_ARG(xmax);
  UNUSED_ARG(ymax);
  UNUSED_ARG(zmax);
  UNUSED_ARG(xmin);
  UNUSED_ARG(ymin);
  UNUSED_ARG(zmin);
  Kernel::Logger log("Torus");
  log.warning("Torus::getBoundingBox is not implemented.");
}
 
void Torus::setDistanceFromCentreToTube(double dist) { Iradius = dist; }
 
void Torus::setTubeRadius(double dist) { Dradius = dist; }
 
#ifdef ENABLE_OPENCASCADE
TopoDS_Shape Torus::createShape() {
  // NOTE:: Not yet implemented
  return TopoDS_Shape();
}
#endif
 
} // namespace Mantid::Geometry