RectangularDetector.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/RectangularDetector.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/ComponentVisitor.h"
#include "MantidGeometry/Instrument/Detector.h"
#include "MantidGeometry/Objects/BoundingBox.h"
#include "MantidGeometry/Objects/CSGObject.h"
#include "MantidGeometry/Objects/IObject.h"
#include "MantidGeometry/Objects/ShapeFactory.h"
#include "MantidGeometry/Objects/Track.h"
#include "MantidGeometry/Rendering/GeometryHandler.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/Material.h"
#include "MantidKernel/Matrix.h"
#include <algorithm>
#include <boost/regex.hpp>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <utility>
 
namespace {
int getOneTextureSize(int desired) {
  int size = 2;
  while (desired > size) {
    size = size * 2;
  }
  return size;
}
} // namespace
 
namespace Mantid::Geometry {
 
using Kernel::Matrix;
using Kernel::V3D;
 
RectangularDetector::RectangularDetector(const RectangularDetector *base, const ParameterMap *map)
    : GridDetector(base, map) {
  init();
}
 
RectangularDetector::RectangularDetector(const std::string &n, IComponent *reference) : GridDetector(n, reference) {
  init();
  m_textureID = 0;
  this->setName(n);
  setGeometryHandler(new GeometryHandler(this));
}
 
bool RectangularDetector::compareName(const std::string &proposedMatch) {
  static const boost::regex exp("RectangularDetector|rectangularDetector|"
                                "rectangulardetector|rectangular_detector");
 
  return boost::regex_match(proposedMatch, exp);
}
 
RectangularDetector *RectangularDetector::clone() const { return new RectangularDetector(*this); }
 
//-------------------------------------------------------------------------------------------------
std::shared_ptr<Detector> RectangularDetector::getAtXY(const int X, const int Y) const {
  return GridDetector::getAtXYZ(X, Y, 0);
}
 
//-------------------------------------------------------------------------------------------------
detid_t RectangularDetector::getDetectorIDAtXY(const int X, const int Y) const {
  return GridDetector::getDetectorIDAtXYZ(X, Y, 0);
}
 
//-------------------------------------------------------------------------------------------------
std::pair<int, int> RectangularDetector::getXYForDetectorID(const int detectorID) const {
  auto xyz = GridDetector::getXYZForDetectorID(detectorID);
  return std::pair<int, int>(std::get<0>(xyz), std::get<1>(xyz));
}
 
//-------------------------------------------------------------------------------------------------
V3D RectangularDetector::getRelativePosAtXY(int x, int y) const { return GridDetector::getRelativePosAtXYZ(x, y, 0); }
 
//-------------------------------------------------------------------------------------------------
void RectangularDetector::initialize(std::shared_ptr<IObject> shape, int xpixels, double xstart, double xstep,
                                     int ypixels, double ystart, double ystep, int idstart, bool idfillbyfirst_y,
                                     int idstepbyrow, int idstep) {
 
  GridDetector::initialize(std::move(shape), xpixels, xstart, xstep, ypixels, ystart, ystep, 0, 0, 0, idstart,
                           idfillbyfirst_y ? "yxz" : "xyz", idstepbyrow, idstep);
}
 
//------------------------------------------------------------------------------------------------
void RectangularDetector::testIntersectionWithChildren(Track &testRay,
                                                       std::deque<IComponent_const_sptr> & /*searchQueue*/) const {
  V3D basePoint;
 
  V3D vertical;
 
  V3D horizontal;
 
  basePoint = getAtXY(0, 0)->getPos();
  horizontal = getAtXY(xpixels() - 1, 0)->getPos() - basePoint;
  vertical = getAtXY(0, ypixels() - 1)->getPos() - basePoint;
 
  // The beam direction
  V3D beam = testRay.direction();
 
  // From: http://en.wikipedia.org/wiki/Line-plane_intersection (taken on May 4,
  // 2011),
  // We build a matrix to solve the linear equation:
  Matrix<double> mat(3, 3);
  mat.setColumn(0, beam * -1.0);
  mat.setColumn(1, horizontal);
  mat.setColumn(2, vertical);
  mat.Invert();
 
  // Multiply by the inverted matrix to find t,u,v
  V3D tuv = mat * (testRay.startPoint() - basePoint);
  //  std::cout << tuv << "\n";
 
  // Intersection point
  V3D intersec = beam;
  intersec *= tuv[0];
 
  // t = coordinate along the line
  // u,v = coordinates along horizontal, vertical
  // (and correct for it being between 0, xpixels-1).  The +0.5 is because the
  // base point is at the CENTER of pixel 0,0.
  double u = (double(xpixels() - 1) * tuv[1] + 0.5);
  double v = (double(ypixels() - 1) * tuv[2] + 0.5);
 
  //  std::cout << u << ", " << v << "\n";
 
  // In indices
  auto xIndex = int(u);
  auto yIndex = int(v);
 
  // Out of range?
  if (xIndex < 0)
    return;
  if (yIndex < 0)
    return;
  if (xIndex >= xpixels())
    return;
  if (yIndex >= ypixels())
    return;
 
  // TODO: Do I need to put something smart here for the first 3 parameters?
  auto comp = getAtXY(xIndex, yIndex);
  testRay.addLink(intersec, intersec, 0.0, *(comp->shape()), comp->getComponentID());
}
 
void RectangularDetector::getTextureSize(int &xsize, int &ysize) const {
  xsize = getOneTextureSize(this->xpixels());
  ysize = getOneTextureSize(this->ypixels());
}
 
void RectangularDetector::setTextureID(unsigned int textureID) { m_textureID = textureID; }
 
unsigned int RectangularDetector::getTextureID() const { return m_textureID; }
 
const Kernel::Material RectangularDetector::material() const { return Kernel::Material(); }
 
size_t RectangularDetector::registerContents(ComponentVisitor &componentVisitor) const {
  return componentVisitor.registerRectangularBank(*this);
}
 
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// ------------ END OF IObjComponent methods ----------------
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
 
std::ostream &operator<<(std::ostream &os, const RectangularDetector &ass) {
  ass.printSelf(os);
  os << "************************\n";
  os << "Number of children :" << ass.nelements() << '\n';
  ass.printChildren(os);
  return os;
}
 
} // namespace Mantid::Geometry