StructuredDetector.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/StructuredDetector.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/ShapeFactory.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>
 
namespace Mantid::Geometry {
 
using Kernel::V3D;
 
StructuredDetector::StructuredDetector() : CompAssembly(), IObjComponent(nullptr), m_base(nullptr) { init(); }
 
StructuredDetector::StructuredDetector(const std::string &name, IComponent *reference)
    : CompAssembly(name, reference), IObjComponent(nullptr), m_base(nullptr) {
  init();
  this->setName(name);
}
 
StructuredDetector::StructuredDetector(const StructuredDetector *base, const ParameterMap *map)
    : CompAssembly(base, map), IObjComponent(nullptr), m_base(base) {
  init();
}
 
bool StructuredDetector::compareName(const std::string &proposedMatch) {
  static const boost::regex exp("StructuredDetector|structuredDetector|"
                                "structureddetector|structured_detector");
 
  return boost::regex_match(proposedMatch, exp);
}
 
void StructuredDetector::init() {
  m_xPixels = 0;
  m_yPixels = 0;
  m_minDetId = 0;
  m_maxDetId = 0;
  m_idStart = 0;
  m_idFillByFirstY = false;
  m_idStepByRow = 0;
  m_idStep = 0;
 
  setGeometryHandler(new GeometryHandler(this));
}
 
IComponent *StructuredDetector::clone() const { return new StructuredDetector(*this); }
 
//-------------------------------------------------------------------------------------------------
std::shared_ptr<Detector> StructuredDetector::getAtXY(const size_t x, const size_t y) const {
  if (x >= xPixels())
    throw std::runtime_error("StructuredDetector::getAtXY: X specified is out of range.");
  if (y >= yPixels())
    throw std::runtime_error("StructuredDetector::getAtXY: Y specified is out of range.");
 
  // Get to column
  ICompAssembly_sptr xCol = std::dynamic_pointer_cast<ICompAssembly>(this->getChild(static_cast<int>(x)));
  if (!xCol)
    throw std::runtime_error("StructuredDetector::getAtXY: X specified is out of range.");
  return std::dynamic_pointer_cast<Detector>(xCol->getChild(static_cast<int>(y)));
}
 
detid_t StructuredDetector::getDetectorIDAtXY(const size_t x, const size_t y) const {
  const StructuredDetector *me = m_map == nullptr ? this : this->m_base;
 
  if (me->m_idFillByFirstY)
    return static_cast<detid_t>(me->m_idStart + x * me->m_idStepByRow + y * me->m_idStep);
  else
    return static_cast<detid_t>(me->m_idStart + y * me->m_idStepByRow + x * me->m_idStep);
}
 
std::pair<size_t, size_t> StructuredDetector::getXYForDetectorID(const detid_t detectorID) const {
  const StructuredDetector *me = this;
  if (m_map)
    me = this->m_base;
 
  int id = detectorID - me->m_idStart;
 
  if ((me->m_idStepByRow == 0) || (me->m_idStep == 0))
    return std::pair<int, int>(-1, -1);
 
  int row = id / me->m_idStepByRow;
  int col = (id % me->m_idStepByRow) / me->m_idStep;
 
  if (me->m_idFillByFirstY) // x is the fast-changing axis
    return std::pair<int, int>(row, col);
  else
    return std::pair<int, int>(col, row);
}
 
size_t StructuredDetector::xPixels() const {
  if (m_map)
    return m_base->m_xPixels;
  else
    return this->m_xPixels;
}
 
void StructuredDetector::setColors(const std::vector<int> &r, const std::vector<int> &g,
                                   const std::vector<int> &b) const {
  if (m_map)
    m_base->setColors(r, g, b);
  else {
    this->r = r;
    this->g = g;
    this->b = b;
  }
}
 
std::vector<int> const &StructuredDetector::getR() const {
  if (m_map)
    return m_base->getR();
  else
    return r;
}
 
std::vector<int> const &StructuredDetector::getG() const {
  if (m_map)
    return m_base->getG();
  else
    return g;
}
 
std::vector<int> const &StructuredDetector::getB() const {
  if (m_map)
    return m_base->getB();
  else
    return b;
}
 
size_t StructuredDetector::yPixels() const {
  if (m_map)
    return m_base->m_yPixels;
  else
    return this->m_yPixels;
}
 
detid_t StructuredDetector::idStart() const {
  if (m_map)
    return m_base->m_idStart;
  else
    return this->m_idStart;
}
 
bool StructuredDetector::idFillByFirstY() const {
  if (m_map)
    return m_base->m_idFillByFirstY;
  else
    return this->m_idFillByFirstY;
}
 
int StructuredDetector::idStepByRow() const {
  if (m_map)
    return m_base->m_idStepByRow;
  else
    return this->m_idStepByRow;
}
 
int StructuredDetector::idStep() const {
  if (m_map)
    return m_base->m_idStep;
  else
    return this->m_idStep;
}
 
std::vector<double> const &StructuredDetector::getXValues() const {
  if (m_map)
    return m_base->getXValues();
  else
    return this->m_xvalues;
}
 
std::vector<double> const &StructuredDetector::getYValues() const {
  if (m_map)
    return m_base->getYValues();
  else
    return this->m_yvalues;
}
 
void StructuredDetector::initialize(size_t xPixels, size_t yPixels, std::vector<double> &&x, std::vector<double> &&y,
                                    bool isZBeam, detid_t idStart, bool idFillByFirstY, int idStepByRow, int idStep) {
  if (m_map)
    throw std::runtime_error("StructuredDetector::initialize() called for a "
                             "parametrized StructuredDetector");
 
  m_xPixels = xPixels;
  m_yPixels = yPixels;
 
  m_idStart = idStart;
  m_idFillByFirstY = idFillByFirstY;
  m_idStepByRow = idStepByRow;
  m_idStep = idStep;
 
  // Some safety checks
  if (m_xPixels == 0)
    throw std::invalid_argument("StructuredDetector::initialize(): xPixels should be > 0");
  if (m_yPixels == 0)
    throw std::invalid_argument("StructuredDetector::initialize(): yPixels should be > 0");
  if (x.size() != y.size())
    throw std::invalid_argument("StructuredDetector::initialize(): x.size() should be = y.size()");
  if (x.size() != (size_t)((m_xPixels + 1) * (m_yPixels + 1)))
    throw std::invalid_argument("StructuredDetector::initialize(): x.size() "
                                "should be = (xPixels+1)*(yPixels+1)");
  if (!isZBeam) // StructuredDetector only allows z-axis aligned beams.
    throw std::invalid_argument("Expecting reference_frame to provide z as "
                                "beam axis. StructuredDetecor only allows "
                                "z-axis aligned beams.");
 
  // Store vertices
  m_xvalues = std::move(x);
  m_yvalues = std::move(y);
 
  createDetectors();
}
 
void StructuredDetector::createDetectors() {
  auto minDetId = m_idStart;
  auto maxDetId = m_idStart;
 
  for (size_t ix = 0; ix < m_xPixels; ix++) {
    // Create an ICompAssembly for each x-column
    std::ostringstream oss_col;
 
    oss_col << this->getName() << "(x=" << ix << ")";
    CompAssembly *xColumn = new CompAssembly(oss_col.str(), this);
 
    for (size_t iy = 0; iy < m_yPixels; iy++) {
      std::ostringstream oss;
      oss << this->getName() << "(" << ix << "," << iy << ")";
 
      // Calculate its id and set it.
      auto id = this->getDetectorIDAtXY(ix, iy);
 
      // Store min and max det IDs
      // minimum structured detector id
      if (id < minDetId) {
        minDetId = id;
      }
      // maximum structured detector id
      if (id > maxDetId) {
        maxDetId = id;
      }
 
      // Create and store detector pixel
      xColumn->add(addDetector(xColumn, oss.str(), ix, iy, id));
    }
  }
 
  m_minDetId = minDetId;
  m_maxDetId = maxDetId;
}
 
Detector *StructuredDetector::addDetector(CompAssembly *parent, const std::string &name, size_t x, size_t y,
                                          detid_t id) {
  auto w = m_xPixels + 1;
 
  // Store hexahedral vertices for detector shape
  auto xlb = m_xvalues[(y * w) + x];
  auto xlf = m_xvalues[(y * w) + x + w];
  auto xrf = m_xvalues[(y * w) + x + w + 1];
  auto xrb = m_xvalues[(y * w) + x + 1];
  auto ylb = m_yvalues[(y * w) + x];
  auto ylf = m_yvalues[(y * w) + x + w];
  auto yrf = m_yvalues[(y * w) + x + w + 1];
  auto yrb = m_yvalues[(y * w) + x + 1];
 
  // calculate midpoint of trapeziod
  auto xpos = (xlb + xlf + xrf + xrb) / 4;
  auto ypos = (ylb + ylf + yrf + yrb) / 4;
 
  // Translate detector shape to origin
  xlf -= xpos;
  xrf -= xpos;
  xrb -= xpos;
  xlb -= xpos;
  ylf -= ypos;
  yrf -= ypos;
  yrb -= ypos;
  ylb -= ypos;
 
  std::shared_ptr<Mantid::Geometry::IObject> shape =
      ShapeFactory{}.createHexahedralShape(xlb, xlf, xrf, xrb, ylb, ylf, yrf, yrb);
 
  // Create detector
  auto detector = new Detector(name, id, shape, parent);
 
  // Set detector position relative to parent
  V3D pos(xpos, ypos, 0);
 
  detector->translate(pos);
 
  return detector;
}
 
int StructuredDetector::minDetectorID() {
  if (m_map)
    return m_base->m_minDetId;
  return m_minDetId;
}
 
//-------------------------------------------------------------------------------------------------
int StructuredDetector::maxDetectorID() {
  if (m_map)
    return m_base->m_maxDetId;
  return m_maxDetId;
}
 
std::shared_ptr<const IComponent> StructuredDetector::getComponentByName(const std::string &cname, int nlevels) const {
  // exact matches
  if (cname == this->getName())
    return std::shared_ptr<const IComponent>(this);
 
  // cache the detector's name as all the other names are longer
  // The extra ( is because all children of this have that as the next character
  // and this prevents Bank11 matching Bank 1
  const std::string MEMBER_NAME = this->getName() + "(";
 
  // check that the searched for name starts with the detector's
  // name as they are generated
  if (cname.substr(0, MEMBER_NAME.length()) != MEMBER_NAME) {
    return std::shared_ptr<const IComponent>();
  } else {
    return CompAssembly::getComponentByName(cname, nlevels);
  }
}
 
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// ------------ IObjComponent methods ----------------
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
 
//-------------------------------------------------------------------------------------------------
bool StructuredDetector::isValid(const V3D & /*point*/) const {
  throw Kernel::Exception::NotImplementedError("StructuredDetector::isValid() is not implemented.");
}
 
bool StructuredDetector::isOnSide(const V3D & /*point*/) const {
  throw Kernel::Exception::NotImplementedError("StructuredDetector::isOnSide() is not implemented.");
}
 
int StructuredDetector::interceptSurface(Track & /*track*/) const {
  throw Kernel::Exception::NotImplementedError("StructuredDetector::interceptSurface() is not implemented.");
}
 
double StructuredDetector::solidAngle(const V3D & /*observer*/) const {
  throw Kernel::Exception::NotImplementedError("StructuredDetector::solidAngle() is not implemented.");
}
 
int StructuredDetector::getPointInObject(V3D & /*point*/) const {
  throw Kernel::Exception::NotImplementedError("StructuredDetector::getPointInObject() is not implemented.");
}
 
void StructuredDetector::getBoundingBox(BoundingBox &assemblyBox) const {
  if (hasComponentInfo()) {
    assemblyBox = m_map->componentInfo().boundingBox(index(), &assemblyBox);
    return;
  }
  if (!m_cachedBoundingBox) {
    m_cachedBoundingBox = new BoundingBox();
    // Get all the corners
    BoundingBox compBox;
 
    std::shared_ptr<Detector> det = getAtXY(0, 0);
    det->getBoundingBox(compBox);
    m_cachedBoundingBox->grow(compBox);
    det = getAtXY(this->xPixels() - 1, 0);
    det->getBoundingBox(compBox);
    m_cachedBoundingBox->grow(compBox);
    det = getAtXY(this->xPixels() - 1, this->yPixels() - 1);
    det->getBoundingBox(compBox);
    m_cachedBoundingBox->grow(compBox);
    det = getAtXY(0, this->yPixels() - 1);
    det->getBoundingBox(compBox);
    m_cachedBoundingBox->grow(compBox);
  }
  // Use cached box
  assemblyBox = *m_cachedBoundingBox;
}
 
void StructuredDetector::draw() const {
  if (Handle() == nullptr)
    return;
  // Render the ObjComponent and then render the object
  Handle()->render();
}
 
void StructuredDetector::drawObject() const {}
 
void StructuredDetector::initDraw() const {
  if (Handle() == nullptr)
    return;
 
  Handle()->initialize();
}
 
const std::shared_ptr<const IObject> StructuredDetector::shape() const {
  // --- Create a hexahedral shape for your pixels ----
  auto w = this->xPixels() + 1;
  auto xlb = m_xvalues[0];
  auto xlf = m_xvalues[w * m_yPixels];
  auto xrf = m_xvalues[(w * m_yPixels) + m_xPixels];
  auto xrb = m_xvalues[w];
  auto ylb = m_yvalues[0];
  auto ylf = m_yvalues[(w * m_yPixels)];
  auto yrf = m_yvalues[(w * m_yPixels) + m_xPixels];
  auto yrb = m_yvalues[w];
 
  std::ostringstream xmlShapeStream;
 
  xmlShapeStream << "<hexahedron id=\"detector-shape\" >"
                 << "<left-back-bottom-point x=\"" << xlb << "\""
                 << " y=\"" << ylb << "\""
                 << " z=\"0\" />"
                 << "<left-front-bottom-point x=\"" << xlf << "\""
                 << " y=\"" << ylf << "\""
                 << " z=\"0\" />"
                 << "<right-front-bottom-point x=\"" << xrf << "\""
                 << " y=\"" << yrf << "\""
                 << " z=\"0\" />"
                 << "<right-back-bottom-point x=\"" << xrb << "\""
                 << " y=\"" << yrb << "\""
                 << " z=\"0\" />"
                 << "<left-back-top-point x=\"" << xlb << "\""
                 << " y=\"" << ylb << "\""
                 << " z=\"0.5\" />"
                 << "<left-front-top-point x=\"" << xlf << "\""
                 << " y=\"" << ylf << "\""
                 << " z=\"0.5\" />"
                 << "<right-front-top-point x=\"" << xrf << "\""
                 << " y=\"" << yrf << "\""
                 << " z=\"0.5\" />"
                 << "<right-back-top-point x=\"" << xrb << "\""
                 << " y=\"" << yrb << "\""
                 << " z=\"0.5\" />"
                 << "</hexahedron>";
 
  std::string xmlHexahedralShape(xmlShapeStream.str());
  Geometry::ShapeFactory shapeCreator;
 
  return shapeCreator.createShape(xmlHexahedralShape);
}
 
const Kernel::Material StructuredDetector::material() const { return Kernel::Material(); }
 
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// ------------ END OF IObjComponent methods ----------------
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
 
std::ostream &operator<<(std::ostream &os, const StructuredDetector &ass) {
  ass.printSelf(os);
  os << "************************\n";
  os << "Number of children :" << ass.nelements() << '\n';
  ass.printChildren(os);
  return os;
}
 
size_t StructuredDetector::registerContents(class ComponentVisitor &componentVisitor) const {
  return componentVisitor.registerStructuredBank(*this);
}
 
} // namespace Mantid::Geometry