ComponentInfo.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2017 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 +
#pragma once
 
#include "MantidBeamline/ComponentType.h"
#include "MantidBeamline/PixelGridComponent.h"
#include "MantidGeometry/DllConfig.h"
#include "MantidGeometry/IDTypes.h"
#include "MantidGeometry/Instrument/ComponentInfoIterator.h"
#include "MantidGeometry/Instrument/ParameterInfo.h"
#include "MantidGeometry/Instrument/SolidAngleParams.h"
#include "MantidGeometry/Objects/BoundingBox.h"
#include "MantidTypes/Core/DateAndTime.h"
#include <limits>
#include <memory>
#include <set>
#include <tuple>
#include <unordered_map>
#include <vector>
 
namespace Mantid {
 
namespace Kernel {
class Quat;
class V2D;
class V3D;
} // namespace Kernel
 
namespace Geometry {
class IComponent;
class IObject;
} // namespace Geometry
 
namespace Beamline {
class ComponentInfo;
}
 
namespace Geometry {
class Instrument;
 
class MANTID_GEOMETRY_DLL ComponentInfo {
public:
  static constexpr size_t invalidIndex = std::numeric_limits<size_t>::max();
 
private:
  std::unique_ptr<Beamline::ComponentInfo> m_componentInfo;
  std::shared_ptr<const std::vector<Geometry::IComponent *>> m_componentIds;
  std::shared_ptr<const std::unordered_map<Geometry::IComponent const *, size_t>> m_compIDToIndex;
 
  std::shared_ptr<std::vector<std::shared_ptr<const Geometry::IObject>>> m_shapes;
 
  std::shared_ptr<ParameterInfo> m_parameterInfo;
 
  template <class T> std::vector<T> getParameter(size_t componentIndex, const std::string &name, bool recursive) const;
 
  template <class T>
  void 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);
 
  ParameterInfo &mutableParameterInfo();
 
  BoundingBox componentBoundingBox(const size_t index, const BoundingBox *reference,
                                   const bool excludeMonitors = false) const;
 
  ComponentInfo(const ComponentInfo &other);
  void growBoundingBoxAsRectuangularBank(size_t index, const Geometry::BoundingBox *reference,
                                         Geometry::BoundingBox &mutableBB, const bool excludeMonitors = false) const;
  void growBoundingBoxAsOutline(size_t index, const Geometry::BoundingBox *reference, Geometry::BoundingBox &mutableBB,
                                const bool excludeMonitors = false) const;
 
public:
  struct QuadrilateralComponent {
    size_t topLeft;
    size_t bottomLeft;
    size_t bottomRight;
    size_t topRight;
    size_t nX;
    size_t nY;
  };
 
  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 = nullptr);
  ~ComponentInfo();
  ComponentInfo &operator=(const ComponentInfo &) = delete;
  std::unique_ptr<ComponentInfo> cloneWithoutDetectorInfo() const;
  std::vector<size_t> detectorsInSubtree(size_t componentIndex) const;
  std::vector<size_t> componentsInSubtree(size_t componentIndex) const;
  const std::vector<size_t> &children(size_t componentIndex) const;
  size_t size() const;
  size_t getMemorySize() const;
  QuadrilateralComponent quadrilateralComponent(const size_t componentIndex) const;
  size_t indexOf(Geometry::IComponent const *id) const;
  size_t indexOfOrInvalid(Geometry::IComponent const *id) const;
  size_t indexOfAny(const std::string &name) const;
  bool uniqueName(const std::string &name) const;
  bool isDetector(const size_t componentIndex) const;
  Kernel::V3D position(const size_t componentIndex) const;
  Kernel::V3D position(const std::pair<size_t, size_t> &index) const;
  Kernel::Quat rotation(const size_t componentIndex) const;
  Kernel::Quat rotation(const std::pair<size_t, size_t> &index) const;
  Kernel::V3D relativePosition(const size_t componentIndex) const;
  Kernel::Quat relativeRotation(const size_t componentIndex) const;
  void setPosition(size_t componentIndex, const Kernel::V3D &newPosition);
  void setRotation(size_t componentIndex, const Kernel::Quat &newRotation);
  void setPosition(const std::pair<size_t, size_t> &index, const Kernel::V3D &newPosition);
  void setRotation(const std::pair<size_t, size_t> &index, const Kernel::Quat &newRotation);
  void scaleComponent(const size_t componentIndex, const Kernel::V3D &newScaling);
  void scaleComponent(const std::pair<size_t, size_t> &index, const Kernel::V3D &newScaling);
  size_t parent(const size_t componentIndex) const;
  bool hasParent(const size_t componentIndex) const;
  bool hasDetectorInfo() const;
  Kernel::V3D sourcePosition() const;
  Kernel::V3D samplePosition() const;
  bool hasSource() const;
  bool hasEquivalentSource(const ComponentInfo &other) const;
  bool hasSample() const;
  bool hasEquivalentSample(const ComponentInfo &other) const;
  bool hasDetectors(const size_t componentIndex) const;
  size_t source() const;
  size_t sample() const;
  double l1() const;
  Kernel::V3D scaleFactor(const size_t componentIndex) const;
  const std::string &name(const size_t componentIndex) const;
  void setScaleFactor(const size_t componentIndex, const Kernel::V3D &scaleFactor);
  Kernel::V2D sideBySideViewPosition(const size_t componentIndex) const;
  Beamline::PixelGridComponent pixelGridComponent(const size_t componentIndex) const;
  size_t detectorIndexAtXYZ(const size_t componentIndex, const int x, const int y, const int z) const;
  std::tuple<int, int, int> xyzForDetectorID(const size_t componentIndex, const detid_t detectorID) const;
  bool isGridDetector(size_t const componentIndex) const;
  size_t root() const;
 
  const IComponent *componentID(const size_t componentIndex) const { return (*m_componentIds)[componentIndex]; }
  bool hasValidShape(const size_t componentIndex) const;
 
  const Geometry::IObject &shape(const size_t componentIndex) const;
  std::unordered_map<std::shared_ptr<const Geometry::IObject>, std::vector<size_t>> shapeToComponentIndices() const;
 
  double solidAngle(const size_t componentIndex, const Geometry::SolidAngleParams &params) const;
  BoundingBox boundingBox(const size_t componentIndex, const BoundingBox *reference = nullptr,
                          const bool excludeMonitors = false) const;
  Beamline::ComponentType componentType(const size_t componentIndex) const;
  void setScanInterval(const std::pair<Types::Core::DateAndTime, Types::Core::DateAndTime> &interval);
  size_t scanCount() const;
  void merge(const ComponentInfo &other);
 
  ComponentInfoIterator<ComponentInfo> begin();
  ComponentInfoIterator<ComponentInfo> end();
  const ComponentInfoIterator<const ComponentInfo> cbegin();
  const ComponentInfoIterator<const ComponentInfo> cend();
 
  size_t findBankParent(size_t index, const std::string &bankPart) const;
 
  std::string fullName(const size_t componentIndex) const;
 
  size_t indexOfFullName(const std::string &fullName) const;
 
  bool hasParameter(const size_t componentIndex, const std::string &name, bool recursive = true) const;
  std::set<std::string> getParameterNames(const size_t componentIndex, bool recursive = true) const;
  const ParameterInfo::ComponentParameters &parameters(const size_t componentIndex) const;
  std::vector<double> getNumberParameter(const size_t componentIndex, const std::string &name,
                                         bool recursive = true) const;
  std::vector<int> getIntParameter(const size_t componentIndex, const std::string &name, bool recursive = true) const;
  std::vector<bool> getBoolParameter(const size_t componentIndex, const std::string &name, bool recursive = true) const;
  std::vector<std::string> getStringParameter(const size_t componentIndex, const std::string &name,
                                              bool recursive = true) const;
  double getFittingParameter(const size_t componentIndex, const std::string &name, double xvalue) const;
 
  void addParameter(const size_t componentIndex, const std::string &type, const std::string &name,
                    const std::string &value, const std::string *const pDescription = nullptr,
                    const std::string &pVisible = "true");
  void addDouble(const size_t componentIndex, const std::string &name, double value,
                 const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void addInt(const size_t componentIndex, const std::string &name, int value,
              const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void addBool(const size_t componentIndex, const std::string &name, bool value,
               const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void addString(const size_t componentIndex, const std::string &name, const std::string &value,
                 const std::string *const pDescription = nullptr, const std::string &pVisible = "true");
  void addV3D(const size_t componentIndex, const std::string &name, const Kernel::V3D &value,
              const std::string *const pDescription = nullptr);
  void addQuat(const size_t componentIndex, const std::string &name, const Kernel::Quat &value,
               const std::string *const pDescription = nullptr);
  void addFittingParameter(const size_t componentIndex, const std::string &name, const std::string &fittingFunction,
                           const std::string &value, const std::string *const pDescription = nullptr,
                           const std::string &pVisible = "true");
  void clearParameter(const size_t componentIndex, const std::string &name);
 
  const std::shared_ptr<ParameterInfo> &sharedParameterInfo() const { return m_parameterInfo; }
 
  friend class Instrument;
};
 
using ComponentInfoIt = ComponentInfoIterator<ComponentInfo>;
using ComponentInfoConstIt = ComponentInfoIterator<const ComponentInfo>;
 
} // namespace Geometry
} // namespace Mantid