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/ComponentType.h"
#include "MantidGeometry/Instrument/SolidAngleParams.h"
#include "MantidGeometry/Objects/CSGObject.h"
#include "MantidGeometry/Objects/IObject.h"
#include "MantidKernel/Quat.h"
#include "MantidKernel/V3D.h"
#include "MantidPythonInterface/core/Converters/WrapWithNDArray.h"
#include "MantidPythonInterface/core/Policies/VectorToNumpy.h"
#include "MantidPythonInterface/geometry/ComponentInfoPythonIterator.h"
 
#include <boost/python/class.hpp>
#include <boost/python/copy_const_reference.hpp>
#include <boost/python/dict.hpp>
#include <boost/python/enum.hpp>
#include <boost/python/reference_existing_object.hpp>
#include <boost/python/return_value_policy.hpp>
 
using Mantid::Beamline::ComponentType;
using Mantid::Geometry::ComponentInfo;
using Mantid::Geometry::SolidAngleParams;
using Mantid::Kernel::Quat;
using Mantid::Kernel::V3D;
using Mantid::PythonInterface::ComponentInfoPythonIterator;
using namespace Mantid::PythonInterface::Converters;
using namespace Mantid::PythonInterface::Policies;
using namespace boost::python;
 
namespace {
ComponentInfoPythonIterator make_pyiterator(ComponentInfo &componentInfo) {
  return ComponentInfoPythonIterator(componentInfo);
}
 
// Accept a bare observer position so this reads as a drop-in for the legacy
// IDetector::solidAngle(observer), constructing SolidAngleParams internally.
double solidAngle(const ComponentInfo &self, const size_t index, const V3D &observer) {
  return self.solidAngle(index, SolidAngleParams(observer));
}
 
dict shapeToComponentIndices(const ComponentInfo &componentInfo) {
  dict result;
  const auto shapeMap = componentInfo.shapeToComponentIndices();
  for (const auto &shape : shapeMap) {
    const auto csgObject = std::dynamic_pointer_cast<const Mantid::Geometry::CSGObject>(shape.first);
    if (csgObject != nullptr) {
      result[csgObject->getShapeXML()] = shape.second;
    }
  }
  return result;
}
 
} // namespace
 
// Function pointers to help resolve ambiguity
Mantid::Kernel::V3D (ComponentInfo::*position)(const size_t) const = &ComponentInfo::position;
 
Mantid::Kernel::Quat (ComponentInfo::*rotation)(const size_t) const = &ComponentInfo::rotation;
 
void (ComponentInfo::*setPosition)(const size_t, const Mantid::Kernel::V3D &) = &ComponentInfo::setPosition;
 
void (ComponentInfo::*setRotation)(const size_t, const Mantid::Kernel::Quat &) = &ComponentInfo::setRotation;
 
// Export ComponentInfo
void export_ComponentInfo() {
  enum_<ComponentType>("ComponentType")
      .value("Generic", ComponentType::Generic)
      .value("Infinite", ComponentType::Infinite)
      .value("Grid", ComponentType::Grid)
      .value("Rectangular", ComponentType::Rectangular)
      .value("Structured", ComponentType::Structured)
      .value("Unstructured", ComponentType::Unstructured)
      .value("Detector", ComponentType::Detector)
      .value("OutlineComposite", ComponentType::OutlineComposite);
 
  class_<ComponentInfo, boost::noncopyable>("ComponentInfo", no_init)
 
      .def("__iter__", make_pyiterator)
 
      .def("__len__", &ComponentInfo::size, arg("self"), "Returns the number of components.")
 
      .def("size", &ComponentInfo::size, arg("self"), "Returns the number of components.")
 
      .def("isDetector", &ComponentInfo::isDetector, (arg("self"), arg("index")),
           "Checks if the component is a detector.")
 
      .def("detectorsInSubtree", &ComponentInfo::detectorsInSubtree, return_value_policy<VectorToNumpy>(),
           (arg("self"), arg("index")),
           "Returns a list of detectors in the subtree for the component "
           "identified by 'index'.")
 
      .def("componentsInSubtree", &ComponentInfo::componentsInSubtree, return_value_policy<VectorToNumpy>(),
           (arg("self"), arg("index")),
           "Returns a list of components in the subtree for the component "
           "identified by 'index'.")
 
      .def("position", position, (arg("self"), arg("index")),
           "Returns the absolute position of the component identified by "
           "'index'.")
 
      .def("rotation", rotation, (arg("self"), arg("index")),
           "Returns the absolute rotation of the component identified by "
           "'index'.")
 
      .def("relativePosition", &ComponentInfo::relativePosition, (arg("self"), arg("index")),
           "Returns the absolute relative position of the component identified "
           "by 'index'.")
 
      .def("relativeRotation", &ComponentInfo::relativeRotation, (arg("self"), arg("index")),
           "Returns the absolute relative rotation of the component identified "
           "by 'index'.")
 
      .def("setPosition", setPosition, (arg("self"), arg("index"), arg("newPosition")),
           "Set the absolute position of the component identified by 'index'.")
 
      .def("setRotation", setRotation, (arg("self"), arg("index"), arg("newRotation")),
           "Set the absolute rotation of the component identified by 'index'.")
 
      .def("hasSource", &ComponentInfo::hasSource, arg("self"), "Returns True if a source is present.")
 
      .def("hasEquivalentSource", &ComponentInfo::hasEquivalentSource, arg("self"), arg("other"),
           "Returns True is both beamlines either lack a Source or "
           "have a Source at the same position.")
 
      .def("hasSample", &ComponentInfo::hasSample, arg("self"), "Returns True if a sample is present.")
 
      .def("hasEquivalentSample", &ComponentInfo::hasEquivalentSample, arg("self"), arg("other"),
           "Returns True is both beamlines either lack a Sample or "
           "have a Sample at the same position.")
 
      .def("source", &ComponentInfo::source, arg("self"), "Returns the source component index.")
 
      .def("sample", &ComponentInfo::sample, arg("self"), "Returns the sample component index.")
 
      .def("sourcePosition", &ComponentInfo::sourcePosition, arg("self"), "Returns the source position.")
 
      .def("samplePosition", &ComponentInfo::samplePosition, arg("self"), "Returns the sample position.")
 
      .def("hasParent", &ComponentInfo::hasParent, (arg("self"), arg("index")),
           "Returns True only if the component identified by 'index' has a "
           "parent component.")
 
      .def("parent", &ComponentInfo::parent, (arg("self"), arg("index")),
           "Returns the parent component of the component identified by "
           "'index'.")
 
      .def("children", &ComponentInfo::children, (arg("self"), arg("index")),
           return_value_policy<VectorRefToNumpy<WrapReadOnly>>(),
           "Returns a list of child components for the component identified by "
           "'index'.")
 
      .def("name", &ComponentInfo::name, (arg("self"), arg("index")), return_value_policy<copy_const_reference>(),
           "Returns the name of the component identified by 'index'.")
 
      .def("l1", &ComponentInfo::l1, arg("self"), "Returns the l1 value.")
 
      .def("scaleFactor", &ComponentInfo::scaleFactor, (arg("self"), arg("index")),
           "Returns the scale factor for the component identified by 'index'.")
 
      .def("setScaleFactor", &ComponentInfo::setScaleFactor, (arg("self"), arg("index"), arg("scaleFactor")),
           "Set the scale factor of the component identifed by 'index'.")
 
      .def("hasValidShape", &ComponentInfo::hasValidShape, (arg("self"), arg("index")),
           "Returns True if the component identified by 'index' has a valid "
           "shape.")
 
      .def("shape", &ComponentInfo::shape, (arg("self"), arg("index")),
           return_value_policy<reference_existing_object>(),
           "Returns the shape of the component identified by 'index'.")
 
      .def("solidAngle", &solidAngle, (arg("self"), arg("index"), arg("observer")),
           "Returns the solid angle of the component identified by 'index' as "
           "seen from the observer position.")
 
      .def("componentType", &ComponentInfo::componentType, (arg("self"), arg("index")),
           "Returns the ComponentType of the component identified by 'index'.")
 
      .def("indexOfAny", &ComponentInfo::indexOfAny, (arg("self"), arg("name")),
           "Returns the index of any component matching name. Raises "
           "ValueError if name not found")
 
      .def("uniqueName", &ComponentInfo::uniqueName, (arg("self"), arg("name")),
           "Returns True if the name is a unique single occurance. Zero occurances yields False.")
 
      .def("root", &ComponentInfo::root, arg("self"), "Returns the index of the root component")
      .def("getMemorySize", &ComponentInfo::getMemorySize, arg("self"),
           "Return the memory footprint of the component info in bytes.")
      .def("shapeToComponentIndices", &shapeToComponentIndices, arg("self"),
           "Returns a mapping of shapes to the indices of components with that shape.");
}