Component.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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 "MantidGeometry/DllConfig.h"
#include "MantidGeometry/Instrument/ParameterMap.h"
#include "MantidKernel/Quat.h"
#include "MantidKernel/V2D.h"
#include "MantidKernel/V3D.h"
 
#include <string>
#include <typeinfo>
#include <vector>
 
namespace Poco {
namespace XML {
class Attributes;
class XMLWriter;
} // namespace XML
} // namespace Poco
 
namespace Mantid {
namespace Geometry {
 
//----------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------
template <typename T> class ComponentPool;
 
class MANTID_GEOMETRY_DLL Component : public virtual IComponent {
public:
  virtual std::string typeName() const { return "Component"; }
 
  Component(const IComponent *base, const ParameterMap *map);
 
  Component();
  explicit Component(std::string name, IComponent *parent = nullptr);
  //(optional)
  Component(std::string name, const Kernel::V3D &position, IComponent *parent = nullptr);
  // component
  Component(std::string name, const Kernel::V3D &position, const Kernel::Quat &rotation, IComponent *parent = nullptr);
 
  IComponent *clone() const override;
 
  ComponentID getComponentID() const override;
  // or pointer to itself if not. Currently is the same as getComponentID bar
  // const cast;
  IComponent const *getBaseComponent() const override;
 
  void setParent(IComponent *) override;
 
  std::shared_ptr<const IComponent> getParent() const override;
  std::vector<std::shared_ptr<const IComponent>> getAncestors() const override;
 
  bool isParentNamed(const std::string &expectedName, int maxDepth = -1) const;
 
  void setName(const std::string &) override;
 
  std::string getName() const override;
 
  std::string getFullName() const override;
 
  // otherwise absolute
  void setPos(double, double, double) override;
  void setPos(const Kernel::V3D &) override;
 
  void setSideBySideViewPos(const Kernel::V2D &) override;
 
  // otherwise absolute
  void setRot(const Kernel::Quat &) override;
 
  // present.
  void translate(const Kernel::V3D &) override;
 
  // present.
  void translate(double, double, double) override;
 
  void rotate(const Kernel::Quat &) override;
 
  void rotate(double, const Kernel::V3D &) override;
 
  Kernel::V3D getRelativePos() const override;
 
  // parent chain
  Kernel::V3D getPos() const override;
 
  std::optional<Kernel::V2D> getSideBySideViewPos() const override;
 
  Kernel::Quat getRelativeRot() const override;
 
  Kernel::Quat getRotation() const override;
 
  double getDistance(const IComponent &) const override;
 
  void getBoundingBox(BoundingBox &boundingBox) const override;
 
  // 06/05/2010 MG: Templated virtual functions cannot be defined so we have to
  // resort to
  // one for each type, luckily there won't be too many
  std::set<std::string> getParameterNames(bool recursive = true) const override;
  std::map<std::string, ComponentID> getParameterNamesByComponent() const override;
  bool hasParameter(const std::string &name, bool recursive = true) const override;
 
  std::vector<double> getNumberParameter(const std::string &pname, bool recursive = true) const override {
    return getParameter<double>(pname, recursive);
  }
 
  std::vector<int> getIntParameter(const std::string &pname, bool recursive = true) const override {
    return getParameter<int>(pname, recursive);
  }
 
  std::string getParameterType(const std::string &pname, bool recursive = true) const override {
    Parameter_sptr param;
    if (recursive) {
      param = m_map->getRecursive(this, pname);
    } else {
      param = m_map->get(this, pname);
    }
    if (param)
      return std::string(param->type());
    else
      return std::string("");
  }
  std::string getDescription() const;
 
  std::string getParamDescription(const std::string &pname, bool recursive = true) const;
 
  std::string getParamShortDescription(const std::string &pname, bool recursive = true) const;
  std::string getShortDescription() const;
  void setDescription(const std::string &descr);
  std::vector<bool> getBoolParameter(const std::string &pname, bool recursive = true) const override {
    return getParameter<bool>(pname, recursive);
  }
 
  std::vector<Kernel::V3D> getPositionParameter(const std::string &pname, bool recursive = true) const override {
    return getParameter<Kernel::V3D>(pname, recursive);
  }
 
  std::vector<Kernel::Quat> getRotationParameter(const std::string &pname, bool recursive = true) const override {
    return getParameter<Kernel::Quat>(pname, recursive);
  }
 
  std::vector<std::string> getStringParameter(const std::string &pname, bool recursive = true) const override {
    return getParameter<std::string>(pname, recursive);
  }
 
  std::string getParameterAsString(const std::string &pname, bool recursive = true) const override {
    std::string retVal;
    if (m_map) {
      retVal = m_map->getString(this, pname, recursive);
    }
    return retVal;
  }
 
  bool getParameterVisible(const std::string &p_name, bool recursive) const override {
    if (m_map) {
      Parameter_sptr param;
      if (recursive) {
        param = m_map->getRecursive(this, p_name);
      } else {
        param = m_map->get(this, p_name);
      }
      if (param != Parameter_sptr()) {
        return param->visible();
      } else {
        return false;
      }
    } else {
      // Not parametrized = not visible by default
      return false;
    }
  }
 
  double getFittingParameter(const std::string &pname, double xvalue) const;
 
  void printSelf(std::ostream &) const override;
 
  const IComponent *base() const { return m_base; }
 
  Kernel::V3D getScaleFactor() const override;
 
  const IComponent *getBareParent() const override { return m_parent; }
 
  virtual void readXMLAttributes(const Poco::XML::Attributes &attr);
  virtual void writeXML(Poco::XML::XMLWriter &writer) const;
  virtual void appendXML(std::ostream &xmlStream) const;
 
  bool isParametrized() const override;
 
  virtual size_t registerContents(class ComponentVisitor &componentVisitor) const override;
  bool hasComponentInfo() const;
  size_t index() const;
 
protected:
  const IComponent *m_parent;
  const Component *m_base;
  const ParameterMap *m_map;
 
  std::string m_name;
  Kernel::V3D m_pos;
  Kernel::Quat m_rot;
  std::optional<Kernel::V2D> m_sidebysideviewpos;
 
  template <class TYPE> std::vector<TYPE> getParameter(const std::string &p_name, bool recursive) const {
    if (m_map) {
      Parameter_sptr param;
      if (recursive) {
        param = m_map->getRecursive(this, p_name);
      } else {
        param = m_map->get(this, p_name);
      }
      if (param != Parameter_sptr()) {
        return std::vector<TYPE>(1, param->value<TYPE>());
      } else {
        return std::vector<TYPE>(0);
      }
    } else {
      // Not parametrized = return empty vector
      return std::vector<TYPE>(0);
    }
  }
 
protected:
  // This method is only required for efficient caching of parameterized
  // components and
  // should not form part of the interface. It is an implementation detail.
  template <typename T> friend class ComponentPool;
  void swap(const Component *base, const ParameterMap *pmap);
};
 
} // namespace Geometry
} // namespace Mantid