ComponentInfo.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/ComponentInfo.h"
#include "MantidBeamline/ComponentInfo.h"
#include "MantidBeamline/ComponentType.h"
#include "MantidGeometry/IComponent.h"
#include "MantidGeometry/Instrument/FitParameter.h"
#include "MantidGeometry/Instrument/Parameter.h"
#include "MantidGeometry/Instrument/ParameterFactory.h"
#include "MantidGeometry/Instrument/ParameterInfo.h"
#include "MantidGeometry/Instrument/ParameterMap.h"
#include "MantidGeometry/Objects/BoundingBox.h"
#include "MantidGeometry/Objects/IObject.h"
#include "MantidKernel/EigenConversionHelpers.h"
#include "MantidKernel/Exception.h"
 
#include <Eigen/Geometry>
#include <algorithm>
#include <exception>
#include <iterator>
#include <string>
 
namespace Mantid::Geometry {
 
namespace {
const Eigen::Vector3d undoRotation(const Eigen::Vector3d &point, const Beamline::ComponentInfo &compInfo,
                                   const size_t componentIndex) {
  auto unRotateTransform = Eigen::Affine3d(compInfo.rotation(componentIndex).inverse());
  return unRotateTransform * point;
}
const Kernel::V3D toShapeFrame(const Kernel::V3D &point, const Beamline::ComponentInfo &compInfo,
                               const size_t componentIndex) {
  return Kernel::toV3D(
      undoRotation(Kernel::toVector3d(point) - compInfo.position(componentIndex), compInfo, componentIndex));
}
 
} // namespace
 
ComponentInfo::ComponentInfo(
    std::unique_ptr<Beamline::ComponentInfo> componentInfo,
    std::shared_ptr<const std::vector<Mantid::Geometry::IComponent *>> componentIds,
    std::shared_ptr<const std::unordered_map<Geometry::IComponent const *, size_t>> componentIdToIndexMap,
    std::shared_ptr<std::vector<std::shared_ptr<const Geometry::IObject>>> shapes,
    std::shared_ptr<ParameterInfo> parameterInfo)
    : m_componentInfo(std::move(componentInfo)), m_componentIds(std::move(componentIds)),
      m_compIDToIndex(std::move(componentIdToIndexMap)), m_shapes(std::move(shapes)),
      m_parameterInfo(std::move(parameterInfo)) {
 
  if (m_componentIds->size() != m_compIDToIndex->size()) {
    throw std::invalid_argument("Inconsistent ID and Mapping input containers "
                                "for Geometry::ComponentInfo");
  }
  if (m_componentIds->size() != m_componentInfo->size()) {
    throw std::invalid_argument("Inconsistent ID and base "
                                "Beamline::ComponentInfo sizes for "
                                "Geometry::ComponentInfo");
  }
}
 
std::unique_ptr<Geometry::ComponentInfo> ComponentInfo::cloneWithoutDetectorInfo() const {
 
  return std::unique_ptr<Geometry::ComponentInfo>(new Geometry::ComponentInfo(*this));
}
 
ComponentInfo::ComponentInfo(const ComponentInfo &other)
    : m_componentInfo(other.m_componentInfo->cloneWithoutDetectorInfo()), m_componentIds(other.m_componentIds),
      m_compIDToIndex(other.m_compIDToIndex), m_shapes(other.m_shapes), m_parameterInfo(other.m_parameterInfo) {}
 
// Defined as default in source for forward declaration with std::unique_ptr.
ComponentInfo::~ComponentInfo() = default;
 
std::vector<size_t> ComponentInfo::detectorsInSubtree(size_t componentIndex) const {
  return m_componentInfo->detectorsInSubtree(componentIndex);
}
 
std::vector<size_t> ComponentInfo::componentsInSubtree(size_t componentIndex) const {
  return m_componentInfo->componentsInSubtree(componentIndex);
}
 
const std::vector<size_t> &ComponentInfo::children(size_t componentIndex) const {
  return m_componentInfo->children(componentIndex);
}
 
size_t ComponentInfo::size() const { return m_componentInfo->size(); }
 
ComponentInfo::QuadrilateralComponent ComponentInfo::quadrilateralComponent(const size_t componentIndex) const {
  auto type = componentType(componentIndex);
  auto parentType = componentType(parent(componentIndex));
  if (!(type == Beamline::ComponentType::Structured || type == Beamline::ComponentType::Rectangular ||
        parentType == Beamline::ComponentType::Grid))
    throw std::runtime_error("ComponentType is not Structured or Rectangular "
                             "in ComponentInfo::quadrilateralComponent.");
 
  QuadrilateralComponent corners;
  const auto &innerRangeComp = m_componentInfo->children(componentIndex);
  corners.nX = innerRangeComp.size();
  const auto &firstCol = m_componentInfo->children(innerRangeComp[0]);
  const auto &lastCol = m_componentInfo->children(innerRangeComp[corners.nX - 1]);
  corners.nY = firstCol.size();
  corners.bottomLeft = firstCol.front();
  corners.topRight = lastCol.back();
  corners.topLeft = firstCol.back();
  corners.bottomRight = lastCol.front();
 
  return corners;
}
 
size_t ComponentInfo::indexOf(Geometry::IComponent const *id) const { return m_compIDToIndex->at(id); }
 
size_t ComponentInfo::indexOfOrInvalid(Geometry::IComponent const *id) const {
  auto const found = m_compIDToIndex->find(id);
  return found == m_compIDToIndex->end() ? invalidIndex : found->second;
}
 
size_t ComponentInfo::indexOfAny(const std::string &name) const { return m_componentInfo->indexOfAny(name); }
 
bool ComponentInfo::uniqueName(const std::string &name) const { return m_componentInfo->uniqueName(name); }
 
bool ComponentInfo::isDetector(const size_t componentIndex) const {
  return m_componentInfo->isDetector(componentIndex);
}
 
bool ComponentInfo::hasValidShape(const size_t componentIndex) const {
  const auto *shapeAtIndex = (*m_shapes)[componentIndex].get();
  return shapeAtIndex != nullptr && shapeAtIndex->hasValidShape();
}
 
Kernel::V3D ComponentInfo::position(const size_t componentIndex) const {
  return Kernel::toV3D(m_componentInfo->position(componentIndex));
}
 
Kernel::V3D ComponentInfo::position(const std::pair<size_t, size_t> &index) const {
  return Kernel::toV3D(m_componentInfo->position(index));
}
 
Kernel::Quat ComponentInfo::rotation(const size_t componentIndex) const {
  return Kernel::toQuat(m_componentInfo->rotation(componentIndex));
}
 
Kernel::Quat ComponentInfo::rotation(const std::pair<size_t, size_t> &index) const {
  return Kernel::toQuat(m_componentInfo->rotation(index));
}
 
Kernel::V3D ComponentInfo::relativePosition(const size_t componentIndex) const {
  return Kernel::toV3D(m_componentInfo->relativePosition(componentIndex));
}
 
Kernel::Quat ComponentInfo::relativeRotation(const size_t componentIndex) const {
  return Kernel::toQuat(m_componentInfo->relativeRotation(componentIndex));
}
 
void ComponentInfo::setPosition(const std::pair<size_t, size_t> &index, const Kernel::V3D &newPosition) {
  m_componentInfo->setPosition(index, Kernel::toVector3d(newPosition));
}
 
void ComponentInfo::setRotation(const std::pair<size_t, size_t> &index, const Kernel::Quat &newRotation) {
  m_componentInfo->setRotation(index, Kernel::toQuaterniond(newRotation));
}
 
void ComponentInfo::scaleComponent(const size_t componentIndex, const Kernel::V3D &newScaling) {
  m_componentInfo->scaleComponent(componentIndex, Kernel::toVector3d(newScaling));
}
 
void ComponentInfo::scaleComponent(const std::pair<size_t, size_t> &index, const Kernel::V3D &newScaling) {
  m_componentInfo->scaleComponent(index, Kernel::toVector3d(newScaling));
}
 
size_t ComponentInfo::parent(const size_t componentIndex) const { return m_componentInfo->parent(componentIndex); }
 
bool ComponentInfo::hasParent(const size_t componentIndex) const { return m_componentInfo->hasParent(componentIndex); }
 
bool ComponentInfo::hasDetectorInfo() const { return m_componentInfo->hasDetectorInfo(); }
 
Kernel::V3D ComponentInfo::sourcePosition() const { return Kernel::toV3D(m_componentInfo->sourcePosition()); }
 
Kernel::V3D ComponentInfo::samplePosition() const { return Kernel::toV3D(m_componentInfo->samplePosition()); }
 
bool ComponentInfo::hasSource() const { return m_componentInfo->hasSource(); }
 
/*
 * @brief Check the sources of two componentInfo objects coincide
 *
 * @details check both objects either lack or have a source. If the latter,
 * check their positions differ by less than 1 nm = 1e-9 m.
 *
 * @returns true if sources are equivalent
 */
bool ComponentInfo::hasEquivalentSource(const ComponentInfo &other) const {
  return m_componentInfo->hasEquivalentSource(*(other.m_componentInfo));
}
 
bool ComponentInfo::hasSample() const { return m_componentInfo->hasSample(); }
 
/*
 * @brief Check the samples of two componentInfo objects coincide
 *
 * @details check both objects either lack or have a sample. If the latter,
 * check their positions differ by less than 1 nm = 1e-9 m.
 *
 * @returns true if sources are equivalent
 */
bool ComponentInfo::hasEquivalentSample(const ComponentInfo &other) const {
  return m_componentInfo->hasEquivalentSample(*(other.m_componentInfo));
}
 
bool ComponentInfo::hasDetectors(const size_t componentIndex) const {
  if (isDetector(componentIndex))
    return false;
  const auto range = m_componentInfo->detectorRangeInSubtree(componentIndex);
  return range.begin() < range.end();
}
 
size_t ComponentInfo::source() const { return m_componentInfo->source(); }
 
size_t ComponentInfo::sample() const { return m_componentInfo->sample(); }
 
double ComponentInfo::l1() const { return m_componentInfo->l1(); }
 
size_t ComponentInfo::root() const { return m_componentInfo->root(); }
 
void ComponentInfo::setPosition(const size_t componentIndex, const Kernel::V3D &newPosition) {
  m_componentInfo->setPosition(componentIndex, Kernel::toVector3d(newPosition));
}
 
void ComponentInfo::setRotation(const size_t componentIndex, const Kernel::Quat &newRotation) {
  m_componentInfo->setRotation(componentIndex, Kernel::toQuaterniond(newRotation));
}
 
const IObject &ComponentInfo::shape(const size_t componentIndex) const { return *(*m_shapes)[componentIndex]; }
 
std::unordered_map<std::shared_ptr<const IObject>, std::vector<size_t>> ComponentInfo::shapeToComponentIndices() const {
  std::unordered_map<std::shared_ptr<const IObject>, std::vector<size_t>> result;
  const auto &shapes = *m_shapes;
  for (size_t i = 0; i < shapes.size(); ++i) {
    const auto &currentShape = shapes[i];
    if (currentShape != nullptr && currentShape->hasValidShape())
      result[currentShape].emplace_back(i);
  }
  return result;
}
 
Kernel::V3D ComponentInfo::scaleFactor(const size_t componentIndex) const {
  return Kernel::toV3D(m_componentInfo->scaleFactor(componentIndex));
}
 
const std::string &ComponentInfo::name(const size_t componentIndex) const {
  return m_componentInfo->name(componentIndex);
}
 
void ComponentInfo::setScaleFactor(const size_t componentIndex, const Kernel::V3D &scaleFactor) {
  m_componentInfo->setScaleFactor(componentIndex, Kernel::toVector3d(scaleFactor));
}
 
Kernel::V2D ComponentInfo::sideBySideViewPosition(const size_t componentIndex) const {
  return Kernel::toV2D(m_componentInfo->sideBySideViewPosition(componentIndex));
}
 
bool ComponentInfo::isGridDetector(size_t const componentIndex) const {
  return m_componentInfo->isGridDetector(componentIndex);
}
 
Beamline::PixelGridComponent ComponentInfo::pixelGridComponent(const size_t componentIndex) const {
  if (!isGridDetector(componentIndex)) {
    throw std::runtime_error("ComponentType is not Rectangular or Grid in ComponentInfo::pixelGridComponent.");
  }
  return m_componentInfo->pixelGridComponent(componentIndex);
}
 
size_t ComponentInfo::detectorIndexAtXYZ(const size_t componentIndex, const int x, const int y, const int z) const {
  return m_componentInfo->detectorIndexAtXYZ(componentIndex, x, y, z);
}
 
namespace {
std::tuple<int, int, int> xyzFillFirstZ(const Beamline::PixelGridComponent &grid, int col, int id) {
  if (grid.idFillOrder[1] == 'y') {
    int row = (id / grid.idStepByRow) % grid.nY;
    int layer = (id / grid.idStepByRow) / grid.nY;
    return {layer, row, col};
  }
  int row = (id / grid.idStepByRow) % grid.nX;
  int layer = (id / grid.idStepByRow) / grid.nX;
  return {row, layer, col};
}
 
std::tuple<int, int, int> xyzFillFirstY(const Beamline::PixelGridComponent &grid, int col, int id) {
  if (grid.idFillOrder[1] == 'z') {
    int row = (id / grid.idStepByRow) % grid.nZ;
    int layer = (id / grid.idStepByRow) / grid.nZ;
    return {layer, col, row};
  }
  int row = (id / grid.idStepByRow) % grid.nX;
  int layer = (id / grid.idStepByRow) / grid.nX;
  return {row, col, layer};
}
 
std::tuple<int, int, int> xyzFillFirstX(const Beamline::PixelGridComponent &grid, int col, int id) {
  if (grid.idFillOrder[1] == 'y') {
    int row = (id / grid.idStepByRow) % grid.nY;
    int layer = (id / grid.idStepByRow) / grid.nY;
    return {col, row, layer};
  }
  int row = (id / grid.idStepByRow) % grid.nZ;
  int layer = (id / grid.idStepByRow) / grid.nZ;
  return {col, layer, row};
}
} // namespace
 
std::tuple<int, int, int> ComponentInfo::xyzForDetectorID(const size_t componentIndex, const detid_t detectorID) const {
  const auto grid = pixelGridComponent(componentIndex);
 
  const int id = detectorID - grid.idStart;
  if (grid.idStepByRow == 0 || grid.idStep == 0)
    return {-1, -1, -1};
  const int col = (id % grid.idStepByRow) / grid.idStep;
 
  if (grid.idFillOrder[0] == 'z')
    return xyzFillFirstZ(grid, col, id);
  if (grid.idFillOrder[0] == 'y')
    return xyzFillFirstY(grid, col, id);
  return xyzFillFirstX(grid, col, id);
}
 
double ComponentInfo::solidAngle(const size_t componentIndex, const Geometry::SolidAngleParams &params) const {
  if (!hasValidShape(componentIndex))
    throw Kernel::Exception::NullPointerException("ComponentInfo::solidAngle", "shape");
  // This is the observer position in the shape's coordinate system.
  const Kernel::V3D relativeObserver = toShapeFrame(params.observer(), *m_componentInfo, componentIndex);
  const Kernel::V3D scaleFactorAtIndex = this->scaleFactor(componentIndex);
  const auto paramsWithRelativeObserver = params.copyWithNewObserver(relativeObserver);
  if ((scaleFactorAtIndex - Kernel::V3D(1.0, 1.0, 1.0)).norm() < 1e-12)
    return shape(componentIndex).solidAngle(paramsWithRelativeObserver);
  else {
    // This function will scale the object shape when calculating the solid
    // angle.
    return shape(componentIndex).solidAngle(paramsWithRelativeObserver, scaleFactorAtIndex);
  }
}
 
void ComponentInfo::growBoundingBoxAsRectuangularBank(size_t index, const Geometry::BoundingBox *reference,
                                                      Geometry::BoundingBox &mutableBB,
                                                      const bool excludeMonitors) const {
 
  auto panel = quadrilateralComponent(index);
  mutableBB.grow(componentBoundingBox(panel.bottomLeft, reference, excludeMonitors));
  mutableBB.grow(componentBoundingBox(panel.topRight, reference, excludeMonitors));
  mutableBB.grow(componentBoundingBox(panel.topLeft, reference, excludeMonitors));
  mutableBB.grow(componentBoundingBox(panel.bottomRight, reference, excludeMonitors));
}
 
void ComponentInfo::growBoundingBoxAsOutline(size_t index, const BoundingBox *reference, BoundingBox &mutableBB,
                                             const bool excludeMonitors) const {
  mutableBB.grow(componentBoundingBox(index, reference, excludeMonitors));
}
 
BoundingBox ComponentInfo::componentBoundingBox(const size_t index, const BoundingBox *reference,
                                                const bool excludeMonitors) const {
  // Check that we have a valid shape here
  if (componentType(index) == Beamline::ComponentType::Infinite) {
    return BoundingBox(); // Return null bounding box
  }
  if (excludeMonitors) {
    // skip monitors
    if (isDetector(index) && m_componentInfo->isMonitor(index)) {
      return BoundingBox();
    }
    // skip other components such as choppers, etc
    if (componentType(index) == Beamline::ComponentType::Generic) {
      return BoundingBox();
    }
  }
  if (!hasValidShape(index)) {
    return BoundingBox(this->position(index).X(), this->position(index).Y(), this->position(index).Z(),
                       this->position(index).X(), this->position(index).Y(), this->position(index).Z());
  } else {
    const auto &s = this->shape(index);
    BoundingBox absoluteBB = s.getBoundingBox();
 
    // modify in place for speed
    const Eigen::Vector3d scaleFactorAtIndex = m_componentInfo->scaleFactor(index);
    // Scale
    absoluteBB.xMin() *= scaleFactorAtIndex[0];
    absoluteBB.xMax() *= scaleFactorAtIndex[0];
    absoluteBB.yMin() *= scaleFactorAtIndex[1];
    absoluteBB.yMax() *= scaleFactorAtIndex[1];
    absoluteBB.zMin() *= scaleFactorAtIndex[2];
    absoluteBB.zMax() *= scaleFactorAtIndex[2];
    // Rotate
    (this->rotation(index))
        .rotateBB(absoluteBB.xMin(), absoluteBB.yMin(), absoluteBB.zMin(), absoluteBB.xMax(), absoluteBB.yMax(),
                  absoluteBB.zMax());
 
    // Shift
    const Eigen::Vector3d localPos = m_componentInfo->position(index);
    absoluteBB.xMin() += localPos[0];
    absoluteBB.xMax() += localPos[0];
    absoluteBB.yMin() += localPos[1];
    absoluteBB.yMax() += localPos[1];
    absoluteBB.zMin() += localPos[2];
    absoluteBB.zMax() += localPos[2];
 
    if (reference && !reference->isAxisAligned()) { // copy coordinate system
 
      std::vector<Kernel::V3D> coordSystem;
      coordSystem.assign(reference->getCoordSystem().begin(), reference->getCoordSystem().end());
 
      // realign to reference coordinate system
      absoluteBB.realign(&coordSystem);
    }
    return absoluteBB;
  }
}
 
BoundingBox ComponentInfo::boundingBox(const size_t componentIndex, const BoundingBox *reference,
                                       const bool excludeMonitors) const {
  if (isDetector(componentIndex) || componentType(componentIndex) == Beamline::ComponentType::Infinite) {
    return componentBoundingBox(componentIndex, reference, excludeMonitors);
  }
 
  BoundingBox absoluteBB;
  const auto compFlag = componentType(componentIndex);
 
  auto parentFlag = Beamline::ComponentType::Generic;
  if (size() > 1)
    parentFlag = componentType(parent(componentIndex));
 
  if (hasSource() && componentIndex == source()) {
    // Do nothing. Source is not considered part of the beamline for bounding
    // box calculations.
  } else if (compFlag == Beamline::ComponentType::Unstructured) {
    for (const auto &childIndex : this->children(componentIndex)) {
      absoluteBB.grow(boundingBox(childIndex, reference, excludeMonitors));
    }
  } else if (compFlag == Beamline::ComponentType::Grid) {
    for (const auto &childIndex : this->children(componentIndex)) {
      growBoundingBoxAsRectuangularBank(childIndex, reference, absoluteBB, excludeMonitors);
    }
  } else if (compFlag == Beamline::ComponentType::Rectangular || compFlag == Beamline::ComponentType::Structured ||
             parentFlag == Beamline::ComponentType::Grid) {
    growBoundingBoxAsRectuangularBank(componentIndex, reference, absoluteBB, excludeMonitors);
  } else if (compFlag == Beamline::ComponentType::OutlineComposite) {
    growBoundingBoxAsOutline(componentIndex, reference, absoluteBB, excludeMonitors);
  } else {
    // General case
    absoluteBB.grow(componentBoundingBox(componentIndex, reference, excludeMonitors));
  }
  return absoluteBB;
}
 
Beamline::ComponentType ComponentInfo::componentType(const size_t componentIndex) const {
  return m_componentInfo->componentType(componentIndex);
}
 
void ComponentInfo::setScanInterval(const std::pair<Types::Core::DateAndTime, Types::Core::DateAndTime> &interval) {
  m_componentInfo->setScanInterval({interval.first.totalNanoseconds(), interval.second.totalNanoseconds()});
}
 
size_t ComponentInfo::scanCount() const { return m_componentInfo->scanCount(); }
 
void ComponentInfo::merge(const ComponentInfo &other) { m_componentInfo->merge(*other.m_componentInfo); }
 
ComponentInfoIt ComponentInfo::begin() { return ComponentInfoIt(*this, 0, size()); }
 
ComponentInfoIt ComponentInfo::end() { return ComponentInfoIt(*this, size(), size()); }
 
const ComponentInfoConstIt ComponentInfo::cbegin() { return ComponentInfoConstIt(*this, 0, size()); }
 
const ComponentInfoConstIt ComponentInfo::cend() { return ComponentInfoConstIt(*this, size(), size()); }
 
size_t ComponentInfo::findBankParent(size_t index, const std::string &bankPart) const {
  constexpr size_t noBankParent{0}; // index 0 will always be a dectector and never a bank
  // if this component is a bank, return the parent
  if (name(index).starts_with(bankPart)) {
    return parent(index);
  }
  // check if the children components begin with bankPart
  auto indexChildren = children(index);
  if (indexChildren.empty()) {
    return noBankParent;
  }
  // if they do, we found the bank parent
  if (name(indexChildren[0]).starts_with(bankPart)) {
    return index;
  }
  // if not, check the grandchildren
  for (size_t const child : indexChildren) {
    size_t j = findBankParent(child, bankPart);
    if (j != noBankParent) {
      return j;
    }
  }
  return noBankParent;
}
 
std::string ComponentInfo::fullName(const size_t componentIndex) const {
  std::vector<size_t> ancestry{componentIndex};
  for (size_t index = componentIndex; hasParent(index);) {
    index = parent(index);
    ancestry.emplace_back(index);
  }
  std::string result;
  for (auto it = ancestry.crbegin(); it != ancestry.crend(); ++it) {
    if (it != ancestry.crbegin()) {
      result += "/";
    }
    result += name(*it);
  }
  return result;
}
 
size_t ComponentInfo::indexOfFullName(const std::string &fullName) const {
  if (fullName.empty() || size() == 0) {
    return invalidIndex;
  }
 
  size_t current = root();
  size_t segmentStart = 0;
  bool first = true;
  while (segmentStart <= fullName.size()) {
    const auto separator = fullName.find('/', segmentStart);
    const auto segment =
        fullName.substr(segmentStart, separator == std::string::npos ? std::string::npos : separator - segmentStart);
    if (first) {
      // The leading segment names the root itself, as fullName() writes it.
      if (name(current) != segment) {
        return invalidIndex;
      }
      first = false;
    } else {
      auto const &candidates = children(current);
      auto const found =
          std::find_if(candidates.cbegin(), candidates.cend(), [&](size_t child) { return name(child) == segment; });
      if (found == candidates.cend()) {
        return invalidIndex;
      }
      current = *found;
    }
    if (separator == std::string::npos) {
      break;
    }
    segmentStart = separator + 1;
  }
  return current;
}
 
template <class T>
std::vector<T> ComponentInfo::getParameter(size_t componentIndex, const std::string &name, bool recursive) const {
  std::vector<T> result;
  if (m_parameterInfo) {
    Parameter_sptr const param = recursive ? m_parameterInfo->getRecursive(*this, componentIndex, name)
                                           : m_parameterInfo->get(componentIndex, name);
    if (param) {
      result.emplace_back(param->value<T>());
    }
  }
  return result;
}
 
bool ComponentInfo::hasParameter(const size_t componentIndex, const std::string &name, bool recursive) const {
  bool result = false;
  if (m_parameterInfo) {
    // Recursively walk the ParameterInfo to search for name
    result = recursive ? static_cast<bool>(m_parameterInfo->getRecursive(*this, componentIndex, name))
                       : m_parameterInfo->contains(componentIndex, name);
  }
  return result;
}
 
std::set<std::string> ComponentInfo::getParameterNames(const size_t componentIndex, bool recursive) const {
  std::set<std::string> result;
  if (m_parameterInfo) {
    // Unlike the single-parameter lookups, this searches for all instances in component tree
    result = m_parameterInfo->names(componentIndex);
    if (recursive && hasParent(componentIndex)) {
      auto const parentNames = getParameterNames(parent(componentIndex), true);
      result.insert(parentNames.cbegin(), parentNames.cend());
    }
  }
  return result;
}
 
ParameterInfo &ComponentInfo::mutableParameterInfo() {
  if (!m_parameterInfo) {
    m_parameterInfo = std::make_shared<ParameterInfo>();
  }
  return *m_parameterInfo;
}
 
template <class T>
void ComponentInfo::addTypedParameter(const size_t componentIndex, const std::string &type, const std::string &name,
                                      const T &value, const std::string *const pDescription,
                                      const std::string &pVisible) {
  auto parameter = ParameterFactory::create(type, name, pVisible);
  auto typedParameter = std::dynamic_pointer_cast<ParameterType<T>>(parameter);
  if (!typedParameter) {
    throw std::invalid_argument("ComponentInfo: parameter type '" + type + "' does not match the value supplied for '" +
                                name + "'");
  }
  typedParameter->setValue(value);
  if (pDescription) {
    parameter->setDescription(*pDescription);
  }
  mutableParameterInfo().add(componentIndex, parameter);
}
 
void ComponentInfo::addParameter(const size_t componentIndex, const std::string &type, const std::string &name,
                                 const std::string &value, const std::string *const pDescription,
                                 const std::string &pVisible) {
  auto parameter = ParameterFactory::create(type, name, pVisible);
  // fromString rather than setValue: the value arrives already serialised, and the concrete
  // parameter type knows how to parse its own form.
  parameter->fromString(value);
  if (pDescription) {
    parameter->setDescription(*pDescription);
  }
  mutableParameterInfo().add(componentIndex, parameter);
}
 
void ComponentInfo::addDouble(const size_t componentIndex, const std::string &name, double value,
                              const std::string *const pDescription, const std::string &pVisible) {
  addTypedParameter(componentIndex, ParameterMap::pDouble(), name, value, pDescription, pVisible);
}
 
void ComponentInfo::addInt(const size_t componentIndex, const std::string &name, int value,
                           const std::string *const pDescription, const std::string &pVisible) {
  addTypedParameter(componentIndex, ParameterMap::pInt(), name, value, pDescription, pVisible);
}
 
void ComponentInfo::addBool(const size_t componentIndex, const std::string &name, bool value,
                            const std::string *const pDescription, const std::string &pVisible) {
  addTypedParameter(componentIndex, ParameterMap::pBool(), name, value, pDescription, pVisible);
}
 
void ComponentInfo::addString(const size_t componentIndex, const std::string &name, const std::string &value,
                              const std::string *const pDescription, const std::string &pVisible) {
  addTypedParameter(componentIndex, ParameterMap::pString(), name, value, pDescription, pVisible);
}
 
void ComponentInfo::addV3D(const size_t componentIndex, const std::string &name, const Kernel::V3D &value,
                           const std::string *const pDescription) {
  addTypedParameter(componentIndex, ParameterMap::pV3D(), name, value, pDescription, "true");
}
 
void ComponentInfo::addQuat(const size_t componentIndex, const std::string &name, const Kernel::Quat &value,
                            const std::string *const pDescription) {
  addTypedParameter(componentIndex, ParameterMap::pQuat(), name, value, pDescription, "true");
}
 
void ComponentInfo::addFittingParameter(const size_t componentIndex, const std::string &name,
                                        const std::string &fittingFunction, const std::string &value,
                                        const std::string *const pDescription, const std::string &pVisible) {
  auto parameter = ParameterFactory::create("fitting", name, pVisible);
  parameter->fromString(value);
  if (pDescription) {
    parameter->setDescription(*pDescription);
  }
  mutableParameterInfo().addFittingParameter(componentIndex, parameter, fittingFunction);
}
 
void ComponentInfo::clearParameter(const size_t componentIndex, const std::string &name) {
  if (m_parameterInfo) {
    m_parameterInfo->clearParametersByName(componentIndex, name);
  }
}
 
const ParameterInfo::ComponentParameters &ComponentInfo::parameters(const size_t componentIndex) const {
  static ParameterInfo::ComponentParameters const empty;
  return m_parameterInfo ? m_parameterInfo->parameters(componentIndex) : empty;
}
 
std::vector<double> ComponentInfo::getNumberParameter(const size_t componentIndex, const std::string &name,
                                                      bool recursive) const {
  return getParameter<double>(componentIndex, name, recursive);
}
 
std::vector<int> ComponentInfo::getIntParameter(const size_t componentIndex, const std::string &name,
                                                bool recursive) const {
  return getParameter<int>(componentIndex, name, recursive);
}
 
std::vector<bool> ComponentInfo::getBoolParameter(const size_t componentIndex, const std::string &name,
                                                  bool recursive) const {
  return getParameter<bool>(componentIndex, name, recursive);
}
 
std::vector<std::string> ComponentInfo::getStringParameter(const size_t componentIndex, const std::string &name,
                                                           bool recursive) const {
  return getParameter<std::string>(componentIndex, name, recursive);
}
 
double ComponentInfo::getFittingParameter(const size_t componentIndex, const std::string &name, double xvalue) const {
  if (!m_parameterInfo)
    throw std::runtime_error("Parameters are not available in component=" + this->name(componentIndex));
  Parameter_sptr parameter = m_parameterInfo->getRecursive(*this, componentIndex, name, "fitting");
  if (!parameter)
    throw std::runtime_error("Fitting parameter=" + name +
                             " could not be extracted from component=" + this->name(componentIndex));
  try {
    const auto &fitParam = parameter->value<FitParameter>();
    return fitParam.getValue(xvalue);
  } catch (...) {
    throw std::runtime_error("Unable to get lookup table for parameter=" + name +
                             " from component=" + this->name(componentIndex));
  }
}
 
size_t ComponentInfo::getMemorySize() const {
  const size_t n = size();
  // Beamline::ComponentInfo holds all the per-component arrays
  const size_t beamlineMem = m_componentInfo->getMemorySize();
  // m_componentIds: shared_ptr<const vector<IComponent*>> — count the heap-allocated vector object + its buffer
  const size_t componentIdsMem = sizeof(std::vector<Geometry::IComponent *>) + n * sizeof(Geometry::IComponent *);
  // m_compIDToIndex: shared_ptr<const unordered_map<IComponent const*, size_t>>
  // Count the heap-allocated map object + each node (key + value + ~2 pointers for bucket/chain overhead)
  const size_t compIDToIndexMem = sizeof(std::unordered_map<Geometry::IComponent const *, size_t>) +
                                  n * (sizeof(Geometry::IComponent const *) + sizeof(size_t) + 2 * sizeof(void *));
  // m_shapes: shared_ptr<vector<shared_ptr<const IObject>>>
  // IObject shapes are shared; count the vector object + buffer of shared_ptrs, not the shapes themselves
  const size_t shapesMem =
      m_shapes ? sizeof(*m_shapes) + m_shapes->capacity() * sizeof(std::shared_ptr<const Geometry::IObject>) : 0;
  return sizeof(*this) + beamlineMem + componentIdsMem + compIDToIndexMem + shapesMem;
}
 
} // namespace Mantid::Geometry