GridDetector.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/GridDetector.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/ComponentVisitor.h"
#include "MantidGeometry/Instrument/Detector.h"
#include "MantidGeometry/Instrument/GridDetectorPixel.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 Mantid::Geometry {
 
using Kernel::Matrix;
using Kernel::V3D;
 
GridDetector::GridDetector(const GridDetector *base, const ParameterMap *map)
    : CompAssembly(base, map), IObjComponent(nullptr), m_gridBase(base), m_minDetId(0), m_maxDetId(0) {
  init();
  setGeometryHandler(new GeometryHandler(this));
}
 
GridDetector::GridDetector(const std::string &n, IComponent *reference)
    : CompAssembly(n, reference), IObjComponent(nullptr), m_gridBase(nullptr), m_minDetId(0), m_maxDetId(0) {
  init();
  this->setName(n);
  setGeometryHandler(new GeometryHandler(this));
}
 
bool GridDetector::compareName(const std::string &proposedMatch) {
  static const boost::regex exp("grid_?detector", boost::regex::icase);
  return boost::regex_match(proposedMatch, exp);
}
 
void GridDetector::init() {
  m_xpixels = m_ypixels = m_zpixels = 0;
  m_xsize = m_ysize = m_zsize = 0;
  m_xstart = m_ystart = m_zstart = 0;
  m_xstep = m_ystep = m_zstep = 0;
  m_minDetId = m_maxDetId = 0;
  m_idstart = 0;
  m_idfillbyfirst_y = false;
  m_idstepbyrow = 0;
  m_idstep = 0;
}
 
GridDetector *GridDetector::clone() const { return new GridDetector(*this); }
 
bool GridDetector::inBoundsXYZ(const int x, const int y, const int z) const {
  if ((xpixels() <= 0) || (ypixels() <= 0))
    throw std::runtime_error("GridDetector::inBoundsXYZ: invalid X or Y "
                             "width set in the object.");
  if ((x < 0) || (x >= xpixels()))
    return false;
  if ((y < 0) || (y >= ypixels()))
    return false;
  if (zpixels() > 0) {
    if ((z < 0) || (z >= zpixels()))
      return false;
  }
  return true;
}
 
//-------------------------------------------------------------------------------------------------
std::shared_ptr<Detector> GridDetector::getAtXYZ(const int x, const int y, const int z) const {
  if ((xpixels() <= 0) || (ypixels() <= 0))
    throw std::runtime_error("GridDetector::getAtXY: invalid X or Y "
                             "width set in the object.");
  if ((x < 0) || (x >= xpixels()))
    throw std::runtime_error("GridDetector::getAtXYZ: x specified is out of range.");
  if ((y < 0) || (y >= ypixels()))
    throw std::runtime_error("GridDetector::getAtXYZ: y specified is out of range.");
  if (zpixels() > 0) {
    if ((z < 0) || (z >= zpixels()))
      throw std::runtime_error("GridDetector::getAtXYZ: z specified is out of range.");
  }
 
  // Find the index and return that.
  std::shared_ptr<ICompAssembly> xCol;
  // Get to layer
  if (this->zpixels() > 0) {
    auto zLayer = std::dynamic_pointer_cast<ICompAssembly>(this->getChild(z));
    if (!zLayer)
      throw std::runtime_error("GridDetector::getAtXYZ: z specified is out of range.");
 
    xCol = std::dynamic_pointer_cast<ICompAssembly>(zLayer->getChild(x));
  } else
    xCol = std::dynamic_pointer_cast<ICompAssembly>(this->getChild(x));
 
  if (!xCol)
    throw std::runtime_error("GridDetector::getAtXYZ: x specified is out of range.");
  return std::dynamic_pointer_cast<Detector>(xCol->getChild(y));
}
 
namespace {
int const &orderXYZ(char const order, int const &x, int const &y, int const &z) {
  switch (order) {
  case 'x':
    return x;
  case 'y':
    return y;
  case 'z':
    return z;
  default:
    throw std::runtime_error("Not a dimensional label: " + std::to_string(order));
  }
}
 
int const &pixelsXYZ(char const order, GridDetector const *const me) {
  switch (order) {
  case 'x':
    return me->xpixels();
  case 'y':
    return me->ypixels();
  case 'z':
    return me->zpixels();
  default:
    throw std::runtime_error(std::string("Not a dimensional label: ") + order);
  }
}
} // namespace
 
//-------------------------------------------------------------------------------------------------
detid_t GridDetector::getDetectorIDAtXYZ(const int x, const int y, const int z) const {
  if (!inBoundsXYZ(x, y, z))
    throw std::out_of_range("GridDetector::getDetectorIDAtXYZ: pixel indices are out of range.");
 
  auto order = idFillOrder();
 
  int const &first = orderXYZ(order[0], x, y, z);
  int const &second = orderXYZ(order[1], x, y, z);
  int const &third = orderXYZ(order[2], x, y, z);
 
  return idstart() + first * idstep() + second * idstepbyrow() + third * (pixelsXYZ(order[1], this) * idstepbyrow());
}
 
namespace {
std::tuple<int, int, int> getXYZFillFirstZ(const GridDetector *me, int col, int id) {
  if (me->idFillOrder()[1] == 'y') {
    int row = (id / me->idstepbyrow()) % me->ypixels();
    auto layer = (id / me->idstepbyrow()) / me->ypixels();
    return std::tuple<int, int, int>(layer, row, col);
  } else {
    int row = (id / me->idstepbyrow()) % me->xpixels();
    auto layer = (id / me->idstepbyrow()) / me->xpixels();
    return std::tuple<int, int, int>(row, layer, col);
  }
}
 
std::tuple<int, int, int> getXYZFillFirstY(const GridDetector *me, int col, int id) {
  if (me->idFillOrder()[1] == 'z') {
    int row = (id / me->idstepbyrow()) % me->zpixels();
    auto layer = (id / me->idstepbyrow()) / me->zpixels();
    return std::tuple<int, int, int>(layer, col, row);
  } else {
    int row = (id / me->idstepbyrow()) % me->xpixels();
    auto layer = (id / me->idstepbyrow()) / me->xpixels();
    return std::tuple<int, int, int>(row, col, layer);
  }
}
 
std::tuple<int, int, int> getXYZFillFirstX(const GridDetector *me, int col, int id) {
  if (me->idFillOrder()[1] == 'y') {
    int row = (id / me->idstepbyrow()) % me->ypixels();
    auto layer = (id / me->idstepbyrow()) / me->ypixels();
    return std::tuple<int, int, int>(col, row, layer);
  } else {
    int row = (id / me->idstepbyrow()) % me->zpixels();
    auto layer = (id / me->idstepbyrow()) / me->zpixels();
    return std::tuple<int, int, int>(col, layer, row);
  }
}
} // end namespace
 
//-------------------------------------------------------------------------------------------------
std::tuple<int, int, int> GridDetector::getXYZForDetectorID(const detid_t detectorID) const {
  const GridDetector *me = this;
  if (isParametrized())
    me = this->m_gridBase;
 
  int id = detectorID - me->m_idstart;
  if ((me->m_idstepbyrow == 0) || (me->m_idstep == 0))
    return std::tuple<int, int, int>(-1, -1, -1);
  int col = (id % me->m_idstepbyrow) / me->m_idstep;
 
  if (me->m_idFillOrder[0] == 'z')
    return getXYZFillFirstZ(me, col, id);
  else if (me->m_idFillOrder[0] == 'y')
    return getXYZFillFirstY(me, col, id);
  else
    return getXYZFillFirstX(me, col, id);
}
 
//-------------------------------------------------------------------------------------------------
int const &GridDetector::xpixels() const {
  if (isParametrized())
    return m_gridBase->xpixels();
  else
    return this->m_xpixels;
}
 
//-------------------------------------------------------------------------------------------------
int const &GridDetector::ypixels() const {
  if (isParametrized())
    return m_gridBase->ypixels();
  else
    return this->m_ypixels;
}
 
//-------------------------------------------------------------------------------------------------
int const &GridDetector::zpixels() const {
  if (isParametrized())
    return m_gridBase->zpixels();
  else
    return this->m_zpixels;
}
 
//-------------------------------------------------------------------------------------------------
double GridDetector::xstep() const {
  if (isParametrized()) {
    double scaling = 1.0;
    if (m_map->contains(m_gridBase, "scalex"))
      scaling = m_map->get(m_gridBase, "scalex")->value<double>();
    return m_gridBase->xstep() * scaling;
  } else
    return this->m_xstep;
}
 
//-------------------------------------------------------------------------------------------------
double GridDetector::ystep() const {
  if (isParametrized()) {
    double scaling = 1.0;
    if (m_map->contains(m_gridBase, "scaley"))
      scaling = m_map->get(m_gridBase, "scaley")->value<double>();
    return m_gridBase->ystep() * scaling;
  } else
    return this->m_ystep;
}
 
//-------------------------------------------------------------------------------------------------
double GridDetector::zstep() const {
  if (isParametrized()) {
    double scaling = 1.0;
    if (m_map->contains(m_gridBase, "scalez"))
      scaling = m_map->get(m_gridBase, "scalez")->value<double>();
    return m_gridBase->zstep() * scaling;
  } else
    return this->m_zstep;
}
 
//-------------------------------------------------------------------------------------------------
double GridDetector::xstart() const {
  if (isParametrized()) {
    double scaling = 1.0;
    if (m_map->contains(m_gridBase, "scalex"))
      scaling = m_map->get(m_gridBase, "scalex")->value<double>();
    return m_gridBase->xstart() * scaling;
  } else
    return this->m_xstart;
}
 
//-------------------------------------------------------------------------------------------------
double GridDetector::ystart() const {
  if (isParametrized()) {
    double scaling = 1.0;
    if (m_map->contains(m_gridBase, "scaley"))
      scaling = m_map->get(m_gridBase, "scaley")->value<double>();
    return m_gridBase->ystart() * scaling;
  } else
    return this->m_ystart;
}
 
//-------------------------------------------------------------------------------------------------
double GridDetector::zstart() const {
  if (isParametrized()) {
    double scaling = 1.0;
    if (m_map->contains(m_gridBase, "scalez"))
      scaling = m_map->get(m_gridBase, "scalez")->value<double>();
    return m_gridBase->zstart() * scaling;
  } else
    return this->m_zstart;
}
 
//-------------------------------------------------------------------------------------------------
double GridDetector::xsize() const {
  if (isParametrized()) {
    double scaling = 1.0;
    if (m_map->contains(m_gridBase, "scalex"))
      scaling = m_map->get(m_gridBase, "scalex")->value<double>();
    return m_gridBase->xsize() * scaling;
  } else
    return this->m_xsize;
}
 
//-------------------------------------------------------------------------------------------------
double GridDetector::ysize() const {
  if (isParametrized()) {
    double scaling = 1.0;
    if (m_map->contains(m_gridBase, "scaley"))
      scaling = m_map->get(m_gridBase, "scaley")->value<double>();
    return m_gridBase->ysize() * scaling;
  } else
    return this->m_ysize;
}
 
//-------------------------------------------------------------------------------------------------
double GridDetector::zsize() const {
  if (isParametrized()) {
    double scaling = 1.0;
    if (m_map->contains(m_gridBase, "scalez"))
      scaling = m_map->get(m_gridBase, "scalez")->value<double>();
    return m_gridBase->zsize() * scaling;
  } else
    return this->m_zsize;
}
 
//-------------------------------------------------------------------------------------------------
int const &GridDetector::idstart() const {
  if (isParametrized())
    return m_gridBase->idstart();
  else
    return this->m_idstart;
}
 
//-------------------------------------------------------------------------------------------------
bool const &GridDetector::idfillbyfirst_y() const {
  if (isParametrized())
    return m_gridBase->idfillbyfirst_y();
  else
    return this->m_idfillbyfirst_y;
}
 
std::array<char, 3UL> const &GridDetector::idFillOrder() const {
  if (isParametrized())
    return m_gridBase->idFillOrder();
  else
    return this->m_idFillOrder;
}
 
//-------------------------------------------------------------------------------------------------
int const &GridDetector::idstepbyrow() const {
  if (isParametrized())
    return m_gridBase->idstepbyrow();
  else
    return this->m_idstepbyrow;
}
 
//-------------------------------------------------------------------------------------------------
int const &GridDetector::idstep() const {
  if (isParametrized())
    return m_gridBase->idstep();
  else
    return this->m_idstep;
}
 
//-------------------------------------------------------------------------------------------------
V3D GridDetector::getPosAtXYZ(int x, int y, int z) const {
  if (!inBoundsXYZ(x, y, z))
    throw std::out_of_range("GridDetector::getPosAtXYZ: pixel indices are out of range.");
  V3D relPos = getRelativePosAtXYZ(x, y, z);
  this->getRotation().rotate(relPos);
  return this->getPos() + relPos;
}
 
//-------------------------------------------------------------------------------------------------
V3D GridDetector::getRelativePosAtXYZ(int x, int y, int z) const {
  if (isParametrized()) {
    double scalex = 1.0;
    if (m_map->contains(m_gridBase, "scalex"))
      scalex = m_map->get(m_gridBase, "scalex")->value<double>();
    double scaley = 1.0;
    if (m_map->contains(m_gridBase, "scaley"))
      scaley = m_map->get(m_gridBase, "scaley")->value<double>();
    double scalez = 1.0;
    if (m_map->contains(m_gridBase, "scalez"))
      scalez = m_map->get(m_gridBase, "scalez")->value<double>();
    return m_gridBase->getRelativePosAtXYZ(x, y, z) * V3D(scalex, scaley, scalez);
  } else
    return V3D(m_xstart + m_xstep * x, m_ystart + m_ystep * y, m_zstart + m_zstep * z);
}
 
void GridDetector::createLayer(const std::string &name, CompAssembly *parent, int iz, int &minDetID, int &maxDetID) {
  const double z = m_zstart + iz * m_zstep;
  const std::string z_pixel_str = (m_zpixels > 0) ? "," + std::to_string(iz) + ")" : ")";
  const std::string z_layer_str = (m_zpixels > 0) ? name + "(z=" + std::to_string(iz) + ",x=" : name + "(x=";
  for (int ix = 0; ix < m_xpixels; ++ix) {
    const std::string x_pixel_str = name + "(" + std::to_string(ix) + ",";
    const std::string name_layer = z_layer_str + std::to_string(ix) + ")";
 
    // Create an ICompAssembly for each x-column
    auto *xColumn = new CompAssembly(name_layer, parent);
 
    const double x = m_xstart + ix * m_xstep;
    for (int iy = 0; iy < m_ypixels; ++iy) {
      // Make the name
      const std::string name_pixel = x_pixel_str + std::to_string(iy) + z_pixel_str;
 
      // Calculate its id and set it.
      const auto id = this->getDetectorIDAtXYZ(ix, iy, iz);
 
      // minimum grid detector id
      if (id < minDetID) {
        minDetID = id;
      }
      // maximum grid detector id
      if (id > maxDetID) {
        maxDetID = id;
      }
      // Create the detector from the given id & shape and with xColumn as the parent
      auto *detector =
          new GridDetectorPixel(name_pixel, id, m_shape, xColumn, this, size_t(ix), size_t(iy), size_t(iz));
 
      const double y = m_ystart + iy * m_ystep;
      // Translate (relative to parent). This gives the un-parametrized position
      detector->translate(x, y, z);
 
      // Add it to the x-column
      xColumn->add(detector);
    }
  }
}
 
namespace {
bool checkValidOrderString(std::array<char, 3UL> const &order) {
  return std::all_of(order.cbegin(), order.cend(), [](char const &c) { return (c >= 'x') && (c <= 'z'); });
}
} // end namespace
 
void GridDetector::validateInput() const {
  // Some safety checks
  if (!checkValidOrderString(m_idFillOrder))
    throw std::invalid_argument(
        "GridDetector::initialize(): order string should only comprise exactly 3 letters x, y, and z in any order.");
  if (m_xpixels <= 0)
    throw std::invalid_argument("GridDetector::initialize(): xpixels should be > 0");
  if (m_ypixels <= 0)
    throw std::invalid_argument("GridDetector::initialize(): ypixels should be > 0");
}
 
void GridDetector::initializeValues(std::shared_ptr<IObject> shape, int xpixels, double xstart, double xstep,
                                    int ypixels, double ystart, double ystep, int zpixels, double zstart, double zstep,
                                    int idstart, const std::string &idFillOrder, int idstepbyrow, int idstep) {
 
  m_xpixels = xpixels;
  m_ypixels = ypixels;
  m_zpixels = zpixels;
  m_xsize = xpixels * xstep;
  m_ysize = ypixels * ystep;
  m_zsize = zpixels * zstep;
  m_xstart = xstart;
  m_ystart = ystart;
  m_zstart = zstart;
  m_xstep = xstep;
  m_ystep = ystep;
  m_zstep = zstep;
  m_shape = std::move(shape);
 
  m_idstart = idstart;
  m_idfillbyfirst_y = idFillOrder[0] == 'y';
  m_idFillOrder = std::array<char, 3>{idFillOrder[0], idFillOrder[1], idFillOrder[2]};
  m_idstepbyrow = idstepbyrow;
  m_idstep = idstep;
 
  validateInput();
}
 
//-------------------------------------------------------------------------------------------------
void GridDetector::initialize(std::shared_ptr<IObject> shape, int xpixels, double xstart, double xstep, int ypixels,
                              double ystart, double ystep, int zpixels, double zstart, double zstep, int idstart,
                              const std::string &idFillOrder, int idstepbyrow, int idstep) {
 
  if (isParametrized())
    throw std::runtime_error("GridDetector::initialize() called for a parametrized GridDetector");
 
  initializeValues(std::move(shape), xpixels, xstart, xstep, ypixels, ystart, ystep, zpixels, zstart, zstep, idstart,
                   idFillOrder, idstepbyrow, idstep);
 
  std::string name = this->getName();
  int minDetId = idstart, maxDetId = idstart;
  // Loop through all the pixels
  if (m_zpixels > 0) {
    for (int iz = 0; iz < m_zpixels; ++iz) {
      // Create an ICompAssembly for each z-layer
      std::ostringstream oss_layer;
      oss_layer << name << "(z=" << iz << ")";
      createLayer(name, new CompAssembly(oss_layer.str(), this), iz, minDetId, maxDetId);
    }
  } else
    createLayer(name, this, 0, minDetId, maxDetId);
 
  m_minDetId = minDetId;
  m_maxDetId = maxDetId;
}
 
//-------------------------------------------------------------------------------------------------
detid_t const &GridDetector::minDetectorID() const {
  if (isParametrized())
    return m_gridBase->minDetectorID();
  return m_minDetId;
}
 
//-------------------------------------------------------------------------------------------------
detid_t const &GridDetector::maxDetectorID() const {
  if (isParametrized())
    return m_gridBase->maxDetectorID();
  return m_maxDetId;
}
 
//-------------------------------------------------------------------------------------------------
std::shared_ptr<const IComponent> GridDetector::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);
  }
}
 
//------------------------------------------------------------------------------------------------
void GridDetector::testIntersectionWithChildren(Track &testRay,
                                                std::deque<IComponent_const_sptr> & /*searchQueue*/) const {
  V3D const basePoint = getRelativePosAtXYZ(0, 0, 0);
 
  V3D const vertical = getRelativePosAtXYZ(0, ypixels() - 1, 0) - basePoint;
 
  V3D horizontal = getRelativePosAtXYZ(xpixels() - 1, 0, 0) - basePoint;
 
  // The beam direction
  V3D const beam = testRay.direction() * (-1.0);
 
  // 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);
  mat.setColumn(1, horizontal);
  mat.setColumn(2, vertical);
  mat.Invert();
 
  // Multiply by the inverted matrix to find t,u,v
  V3D const tuv = mat * (testRay.startPoint() - basePoint);
  //  std::cout << tuv << "\n";
 
  // Intersection point
  V3D const intersec = beam * (tuv[0] * -1.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;
 
  // All pixels share the same pixel shape stored on the detector.
  // The parametrized form delegates to the base detector's shape.
  std::shared_ptr<IObject> const &pixelShape = isParametrized() ? m_gridBase->m_shape : m_shape;
 
  auto comp = getAtXYZ(xIndex, yIndex, 0);
  testRay.addLink(intersec, intersec, 0.0, *pixelShape, comp->getComponentID());
}
 
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// ------------ IObjComponent methods ----------------
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
 
//-------------------------------------------------------------------------------------------------
bool GridDetector::isValid(const V3D & /*point*/) const {
  throw Kernel::Exception::NotImplementedError("GridDetector::isValid() is not implemented.");
}
 
//-------------------------------------------------------------------------------------------------
bool GridDetector::isOnSide(const V3D & /*point*/) const {
  throw Kernel::Exception::NotImplementedError("GridDetector::isOnSide() is not implemented.");
}
 
//-------------------------------------------------------------------------------------------------
int GridDetector::interceptSurface(Track & /*track*/) const {
  throw Kernel::Exception::NotImplementedError("GridDetector::interceptSurface() is not implemented.");
}
 
//-------------------------------------------------------------------------------------------------
double GridDetector::solidAngle(const Geometry::SolidAngleParams & /*params*/) const {
  throw Kernel::Exception::NotImplementedError("GridDetector::solidAngle() is not implemented.");
}
 
//-------------------------------------------------------------------------------------------------
int GridDetector::getPointInObject(V3D & /*point*/) const {
  throw Kernel::Exception::NotImplementedError("GridDetector::getPointInObject() is not implemented.");
}
 
void GridDetector::getBoundingBoxAtXYZ(int const x, int const y, int const z, BoundingBox &box) const {
  // Compute the pixel bounding box analytically, replicating ObjComponent::getBoundingBox
  // without needing an actual child Detector object.  Each pixel shares the same shape
  // (m_shape) and inherits the GridDetector's rotation with no additional per-pixel rotation.
 
  // For a parametrized detector the shape lives on the base.
  std::shared_ptr<IObject> const &pixelShape = isParametrized() ? m_gridBase->m_shape : m_shape;
  if (!pixelShape || !pixelShape->hasValidShape()) {
    box = BoundingBox();
    return;
  }
 
  const BoundingBox &shapeBox = pixelShape->getBoundingBox();
  if (shapeBox.isNull()) {
    box = BoundingBox();
    return;
  }
 
  // 1. Copy the shape's axis-aligned bounding box in the local (pixel) frame.
  box = BoundingBox(shapeBox);
 
  // 1a. For parametrized detectors, scale the shape extents by scalex/scaley/scalez
  //     so the per-pixel box matches the scaled pixel size (consistent with getPosAtXYZ).
  if (isParametrized()) {
    double scalex = 1.0, scaley = 1.0, scalez = 1.0;
    if (m_map->contains(m_gridBase, "scalex"))
      scalex = m_map->get(m_gridBase, "scalex")->value<double>();
    if (m_map->contains(m_gridBase, "scaley"))
      scaley = m_map->get(m_gridBase, "scaley")->value<double>();
    if (m_map->contains(m_gridBase, "scalez"))
      scalez = m_map->get(m_gridBase, "scalez")->value<double>();
    box.xMin() *= scalex;
    box.xMax() *= scalex;
    box.yMin() *= scaley;
    box.yMax() *= scaley;
    box.zMin() *= scalez;
    box.zMax() *= scalez;
  }
 
  // 2. Rotate: pixels have the same orientation as the parent GridDetector; there
  //    is no additional per-pixel rotation, so we apply the detector's own rotation.
  this->getRotation().rotateBB(box.xMin(), box.yMin(), box.zMin(), box.xMax(), box.yMax(), box.zMax());
 
  // 3. Translate to the pixel's absolute position in the instrument frame.
  Kernel::V3D const pixelPos = getPosAtXYZ(x, y, z);
  box.xMin() += pixelPos.X();
  box.xMax() += pixelPos.X();
  box.yMin() += pixelPos.Y();
  box.yMax() += pixelPos.Y();
  box.zMin() += pixelPos.Z();
  box.zMax() += pixelPos.Z();
}
 
//-------------------------------------------------------------------------------------------------
void GridDetector::getBoundingBox(BoundingBox &assemblyBox) const {
  if (isParametrized()) {
    if (hasComponentInfo()) {
      assemblyBox = m_map->componentInfo().boundingBox(index(), &assemblyBox);
      return;
    }
  }
  BoundingBox bb;
  BoundingBox compBox;
  getBoundingBoxAtXYZ(0, 0, 0, compBox);
  bb.grow(compBox);
  getBoundingBoxAtXYZ(this->xpixels() - 1, 0, 0, compBox);
  bb.grow(compBox);
  getBoundingBoxAtXYZ(this->xpixels() - 1, this->ypixels() - 1, 0, compBox);
  bb.grow(compBox);
  getBoundingBoxAtXYZ(0, this->ypixels() - 1, 0, compBox);
  bb.grow(compBox);
  getBoundingBoxAtXYZ(0, 0, this->zpixels() - 1, compBox);
  bb.grow(compBox);
  getBoundingBoxAtXYZ(this->xpixels() - 1, 0, this->zpixels() - 1, compBox);
  bb.grow(compBox);
  getBoundingBoxAtXYZ(this->xpixels() - 1, this->ypixels() - 1, this->zpixels() - 1, compBox);
  bb.grow(compBox);
  getBoundingBoxAtXYZ(0, this->ypixels() - 1, this->zpixels() - 1, compBox);
  bb.grow(compBox);
 
  assemblyBox = bb;
}
 
void GridDetector::draw() const {
  if (Handle() == nullptr)
    return;
  Handle()->render();
}
 
void GridDetector::drawObject() const { draw(); }
 
void GridDetector::initDraw() const {
  if (Handle() == nullptr)
    return;
  Handle()->initialize();
}
 
//-------------------------------------------------------------------------------------------------
const std::shared_ptr<const IObject> GridDetector::shape() const {
  // --- Create a cuboid shape for your pixels ----
  double szX = xpixels();
  double szY = ypixels();
  double szZ = zpixels() == 0 ? 0.5 : zpixels();
  std::ostringstream xmlShapeStream;
  xmlShapeStream << " <cuboid id=\"detector-shape\"> "
                 << "<left-front-bottom-point x=\"" << szX << "\" y=\"" << -szY << "\" z=\"" << -szZ << "\"  /> "
                 << "<left-front-top-point  x=\"" << szX << "\" y=\"" << -szY << "\" z=\"" << szZ << "\"  /> "
                 << "<left-back-bottom-point  x=\"" << -szX << "\" y=\"" << -szY << "\" z=\"" << -szZ << "\"  /> "
                 << "<right-front-bottom-point  x=\"" << szX << "\" y=\"" << szY << "\" z=\"" << -szZ << "\"  /> "
                 << "</cuboid>";
 
  std::string xmlCuboidShape(xmlShapeStream.str());
  Geometry::ShapeFactory shapeCreator;
  std::shared_ptr<Geometry::IObject> cuboidShape = shapeCreator.createShape(xmlCuboidShape);
 
  return cuboidShape;
}
 
const Kernel::Material GridDetector::material() const { return Kernel::Material(); }
 
size_t GridDetector::registerContents(ComponentVisitor &componentVisitor) const {
  return componentVisitor.registerGridBank(*this);
}
 
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// ------------ END OF IObjComponent methods ----------------
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
 
std::ostream &operator<<(std::ostream &os, const GridDetector &ass) {
  ass.printSelf(os);
  os << "************************\n";
  os << "Number of children :" << ass.nelements() << '\n';
  ass.printChildren(os);
  return os;
}
 
} // namespace Mantid::Geometry