DetectorGroup.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2008 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/IDetector.h"
#include "MantidGeometry/Instrument/Component.h"
#include "MantidGeometry/Instrument/ObjComponent.h"
#include <map>
#include <vector>
 
namespace Mantid {
namespace Geometry {
class MANTID_GEOMETRY_DLL DetectorGroup : public virtual IDetector {
public:
  DetectorGroup();
  DetectorGroup(const std::vector<IDetector_const_sptr> &dets);
 
  void addDetector(const IDetector_const_sptr &det);
 
  // IDetector methods
  IDetector *cloneParameterized(const ParameterMap *) const override { return nullptr; }
  detid_t getID() const override;
  std::size_t nDets() const override;
  Kernel::V3D getPos() const override;
  double getDistance(const IComponent &comp) const override;
  double getTwoTheta(const Kernel::V3D &observer, const Kernel::V3D &axis) const override;
  double getSignedTwoTheta(const Kernel::V3D &observer, const Kernel::V3D &axis,
                           const Kernel::V3D &instrumentUp) const override;
  double getPhi() const override;
  double getPhiOffset(const double &offset) const override;
  double solidAngle(const Kernel::V3D &observer) const override;
  bool isParametrized() const override;
  bool isValid(const Kernel::V3D &point) const override;
  bool isOnSide(const Kernel::V3D &point) const override;
  int getPointInObject(Kernel::V3D &point) const override;
  void getBoundingBox(BoundingBox &boundingBox) const override;
 
  std::vector<detid_t> getDetectorIDs() const;
  std::vector<IDetector_const_sptr> getDetectors() const;
 
  // 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;
  // Hack used untill Geomertry can not exprot different types parematers
  // properly
  std::string getParameterType(const std::string &name, bool recursive = true) const override;
  std::vector<double> getNumberParameter(const std::string &pname, bool recursive = true) const override;
  std::vector<Kernel::V3D> getPositionParameter(const std::string &pname, bool recursive = true) const override;
  std::vector<Kernel::Quat> getRotationParameter(const std::string &pname, bool recursive = true) const override;
 
  std::vector<std::string> getStringParameter(const std::string &pname, bool recursive = true) const override;
 
  std::vector<int> getIntParameter(const std::string &pname, bool recursive = true) const override;
 
  std::vector<bool> getBoolParameter(const std::string &pname, bool recursive = true) const override;
 
  std::string getParameterAsString(const std::string &pname, bool recursive = true) const override;
 
  bool getParameterVisible(const std::string &pname, bool recursive = true) const override;
 
  det_topology getTopology(Kernel::V3D &center) const override;
 
  std::string getNameSeparator() const { return ";"; }
  IComponent const *getBaseComponent() const override { return const_cast<const DetectorGroup *>(this); }
 
  const ParameterMap &parameterMap() const override;
  size_t index() const override;
  virtual size_t registerContents(class ComponentVisitor &visitor) const override;
 
protected:
  int m_id;
  // May want to change this to a hash_map in due course
  using DetCollection = std::map<int, IDetector_const_sptr>;
  DetCollection m_detectors;
  mutable det_topology group_topology;
  mutable Kernel::V3D groupCentre;
 
  // functions inherited from IComponent
  Component *clone() const override { return nullptr; }
  ComponentID getComponentID() const override { return nullptr; }
  std::shared_ptr<const IComponent> getParent() const override { return std::shared_ptr<const IComponent>(); }
  const IComponent *getBareParent() const override { return nullptr; }
  std::vector<std::shared_ptr<const IComponent>> getAncestors() const override {
    return std::vector<std::shared_ptr<const IComponent>>();
  }
  std::string getName() const override;
  std::string getFullName() const override;
  void setParent(IComponent *) override {}
  void setName(const std::string &) override {}
 
  void setPos(double, double, double) override {}
  void setPos(const Kernel::V3D &) override {}
  void setRot(const Kernel::Quat &) override {}
  void copyRot(const IComponent &) {}
  int interceptSurface(Track &) const override { return -10; }
  void translate(const Kernel::V3D &) override {}
  void translate(double, double, double) override {}
  void rotate(const Kernel::Quat &) override {}
  void rotate(double, const Kernel::V3D &) override {}
  Kernel::V3D getRelativePos() const override {
    throw std::runtime_error("Cannot call getRelativePos on a DetectorGroup");
  }
  Kernel::Quat getRelativeRot() const override {
    throw std::runtime_error("Cannot call getRelativeRot on a DetectorGroup");
  }
  Kernel::Quat getRotation() const override { return Kernel::Quat(); }
  void printSelf(std::ostream &) const override {}
 
  // functions inherited from IObjComponent
 
  void getBoundingBox(double &, double &, double &, double &, double &, double &) const {}
 
  void draw() const override {}
  void drawObject() const override {}
  void initDraw() const override {}
 
  const std::shared_ptr<const IObject> shape() const override { return std::shared_ptr<const IObject>(); }
  const Kernel::Material material() const override;
 
private:
  DetectorGroup(const DetectorGroup &);
  DetectorGroup &operator=(const DetectorGroup &);
 
  void calculateGroupTopology() const;
};
 
using DetectorGroup_sptr = std::shared_ptr<DetectorGroup>;
using DetectorGroup_const_sptr = std::shared_ptr<const DetectorGroup>;
 
} // namespace Geometry
} // namespace Mantid