CSGObject.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
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidGeometry/DllConfig.h"
#include "MantidGeometry/Objects/BoundingBox.h"
#include "MantidGeometry/Objects/IObject.h"
#include "MantidGeometry/Objects/Track.h"
#include "MantidGeometry/Rendering/ShapeInfo.h"
 
#include <boost/optional.hpp>
#include <map>
#include <memory>
 
namespace Mantid {
//----------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------
namespace Kernel {
class PseudoRandomNumberGenerator;
class Material;
class V3D;
} // namespace Kernel
 
namespace Geometry {
class CompGrp;
class GeometryHandler;
class Rule;
class Surface;
class Track;
class vtkGeometryCacheReader;
class vtkGeometryCacheWriter;
 
class MANTID_GEOMETRY_DLL CSGObject final : public IObject {
public:
  CSGObject();
  CSGObject(std::string shapeXML);
  CSGObject(const CSGObject &);
  CSGObject &operator=(const CSGObject &);
  ~CSGObject() override;
  IObject *clone() const override { return new CSGObject(*this); }
 
  IObject *cloneWithMaterial(const Kernel::Material &material) const override {
    auto obj = new CSGObject(*this);
    obj->setMaterial(material);
    return obj;
  }
 
  bool isFiniteGeometry() const override { return m_isFiniteGeometry; }
  void setFiniteGeometryFlag(bool isFinite) override { m_isFiniteGeometry = isFinite; }
 
  const Rule *topRule() const { return m_topRule.get(); }
  void setID(const std::string &id) override { m_id = id; }
  const std::string &id() const override { return m_id; }
 
  void setName(const int objNum) { m_objNum = objNum; } 
  int getName() const override { return m_objNum; }     
 
  void setMaterial(const Kernel::Material &material) override;
  const Kernel::Material &material() const override;
 
  bool hasValidShape() const override;
  int setObject(const int objName, const std::string &lineStr);
  int procString(const std::string &lineStr);
  int complementaryObject(const int cellNum,
                          std::string &lineStr); 
  int hasComplement() const;
 
  int populate(const std::map<int, std::shared_ptr<Surface>> &);
  int createSurfaceList(const int outFlag = 0); 
  int addSurfString(const std::string &);       
  int removeSurface(const int surfNum);
  int substituteSurf(const int surfNum, const int newSurfNum, const std::shared_ptr<Surface> &surfPtr);
  void makeComplement();
  void convertComplement(const std::map<int, CSGObject> &);
 
  virtual void print() const;
  void printTree() const;
 
  bool isValid(const Kernel::V3D &) const override; 
  bool isValid(const std::map<int, int> &) const;   
  bool isOnSide(const Kernel::V3D &) const override;
  Mantid::Geometry::TrackDirection calcValidType(const Kernel::V3D &Pt, const Kernel::V3D &uVec) const;
  Mantid::Geometry::TrackDirection calcValidTypeBy3Points(const Kernel::V3D &prePt, const Kernel::V3D &curPt,
                                                          const Kernel::V3D &nxtPt) const;
 
  std::vector<int> getSurfaceIndex() const;
  const std::vector<const Surface *> &getSurfacePtr() const { return m_surList; }
  std::vector<const Surface *> &getSurfacePtr() { return m_surList; }
 
  std::string cellCompStr() const;
  std::string cellStr(const std::map<int, CSGObject> &) const;
 
  std::string str() const;
  void write(std::ostream &) const; 
 
  // INTERSECTION
  int interceptSurface(Geometry::Track &track) const override;
  double distance(const Track &track) const override;
 
  // Solid angle - uses triangleSolidAngle unless many (>30000) triangles
  double solidAngle(const Kernel::V3D &observer) const override;
  // Solid angle with a scaling of the object
  double solidAngle(const Kernel::V3D &observer, const Kernel::V3D &scaleFactor) const override;
  // solid angle via triangulation
  double triangulatedSolidAngle(const Kernel::V3D &observer) const;
  // Solid angle via triangulation with scaling factor for object size
  double triangulatedSolidAngle(const Kernel::V3D &observer, const Kernel::V3D &scaleFactor) const;
  // solid angle via ray tracing
  double rayTraceSolidAngle(const Kernel::V3D &observer) const;
 
  double volume() const override;
 
  void getBoundingBox(double &xmax, double &ymax, double &zmax, double &xmin, double &ymin,
                      double &zmin) const override;
 
  const BoundingBox &getBoundingBox() const override;
  void defineBoundingBox(const double &xMax, const double &yMax, const double &zMax, const double &xMin,
                         const double &yMin, const double &zMin);
  void setNullBoundingBox();
  // find internal point to object
  int getPointInObject(Kernel::V3D &point) const override;
 
  boost::optional<Kernel::V3D> generatePointInObject(Kernel::PseudoRandomNumberGenerator &rng,
                                                     const size_t) const override;
  boost::optional<Kernel::V3D> generatePointInObject(Kernel::PseudoRandomNumberGenerator &rng,
                                                     const BoundingBox &activeRegion, const size_t) const override;
 
  // Rendering member functions
  void draw() const override;
  // Initialize Drawing
  void initDraw() const override;
  // Get Geometry Handler
  std::shared_ptr<GeometryHandler> getGeometryHandler() const override;
  void setGeometryHandler(const std::shared_ptr<GeometryHandler> &h);
 
  void setVtkGeometryCacheWriter(std::shared_ptr<vtkGeometryCacheWriter>);
  void setVtkGeometryCacheReader(std::shared_ptr<vtkGeometryCacheReader>);
  detail::ShapeInfo::GeometryShape shape() const override;
  const detail::ShapeInfo &shapeInfo() const override;
  void GetObjectGeom(detail::ShapeInfo::GeometryShape &type, std::vector<Kernel::V3D> &vectors, double &innerRadius,
                     double &radius, double &height) const override;
  std::string getShapeXML() const;
 
private:
  int procPair(std::string &lineStr, std::map<int, std::unique_ptr<Rule>> &ruleMap, int &compUnit) const;
  std::unique_ptr<CompGrp> procComp(std::unique_ptr<Rule>) const;
  int checkSurfaceValid(const Kernel::V3D &, const Kernel::V3D &) const;
 
  void calcBoundingBoxByRule();
 
  void calcBoundingBoxByVertices();
 
  void calcBoundingBoxByGeometry();
 
  int searchForObject(Kernel::V3D &) const;
 
  double monteCarloVolume() const;
  double singleShotMonteCarloVolume(const int shotSize, const size_t seed) const;
  std::unique_ptr<Rule> m_topRule;
  BoundingBox m_boundingBox;
  // -- DEPRECATED --
  mutable double AABBxMax,  
      AABByMax,             
      AABBzMax,             
      AABBxMin,             
      AABByMin,             
      AABBzMin;             
  mutable bool boolBounded; 
 
  int m_objNum;
  std::shared_ptr<GeometryHandler> m_handler;
  friend class GeometryHandler;
  friend class GeometryRenderer;
  bool bGeometryCaching;
  std::shared_ptr<vtkGeometryCacheReader> vtkCacheReader;
  std::shared_ptr<vtkGeometryCacheWriter> vtkCacheWriter;
  void updateGeometryHandler();
  size_t numberOfTriangles() const;
  size_t numberOfVertices() const;
  const std::vector<uint32_t> &getTriangleFaces() const;
  const std::vector<double> &getTriangleVertices() const;
  std::string m_shapeXML;
  std::string m_id;
  mutable std::unique_ptr<Kernel::Material> m_material;
  bool m_isFiniteGeometry = true;
 
protected:
  std::vector<const Surface *> m_surList; 
};
 
} // NAMESPACE Geometry
} // NAMESPACE Mantid