Container.h 4.92 KB
Newer Older
Martyn Gigg's avatar
Martyn Gigg committed
1
2
#ifndef MANTID_GEOMETRY_CONTAINER_H_
#define MANTID_GEOMETRY_CONTAINER_H_
3
4

#include "MantidGeometry/DllConfig.h"
5
6
7
#include "MantidGeometry/Objects/IObject.h"
#include "MantidKernel/Material.h"
#include "MantidKernel/V3D.h"
8
#include <unordered_map>
9
10
11
12
13

namespace Mantid {
namespace Geometry {

/**
Martyn Gigg's avatar
Martyn Gigg committed
14
  Models a Container is used to hold a sample in the beam. It gets most
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
  of its functionality from Geometry::Object but can also hold a
  definition of what the sample geometry itself would be. If the sample shape
  definition is set then we term this a constriained sample geometry.

  Copyright &copy; 2016 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
  National Laboratory & European Spallation Source

  This file is part of Mantid.

  Mantid is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 3 of the License, or
  (at your option) any later version.

  Mantid is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.

  File change history is stored at: <https://github.com/mantidproject/mantid>
  Code Documentation is available at: <http://doxygen.mantidproject.org>
*/
40
class MANTID_GEOMETRY_DLL Container final : public IObject {
41
public:
42
43
  typedef std::unordered_map<std::string, double> ShapeArgs;

44
45
  Container();
  Container(IObject_sptr shape);
46
  Container(const Container &container);
Martyn Gigg's avatar
Martyn Gigg committed
47
  Container(std::string xml);
48
49

  bool hasSampleShape() const;
50
  IObject_sptr createSampleShape(const ShapeArgs &args) const;
51

52
  void setSampleShape(const std::string &sampleShapeXML);
53

54
55
56
57
58
59
60
61
62
63
64
  bool isValid(const Kernel::V3D &p) const override {
    return m_shape->isValid(p);
  }
  bool isOnSide(const Kernel::V3D &p) const override {
    return m_shape->isOnSide(p);
  }
  int calcValidType(const Kernel::V3D &Pt,
                    const Kernel::V3D &uVec) const override {
    return m_shape->calcValidType(Pt, uVec);
  }
  bool hasValidShape() const override { return m_shape->hasValidShape(); }
65

66
67
68
69
70
71
72
73
74
75
  IObject *clone() const override { return new Container(*this); }

  int getName() const override { return m_shape->getName(); }

  int interceptSurface(Geometry::Track &t) const override {
    return m_shape->interceptSurface(t);
  }
  double solidAngle(const Kernel::V3D &observer) const override {
    return m_shape->solidAngle(observer);
  }
76
  double solidAngle(const Kernel::V3D &observer,
77
78
79
80
81
82
83
                    const Kernel::V3D &scaleFactor) const override {
    return m_shape->solidAngle(observer, scaleFactor);
  }
  double volume() const override { return m_shape->volume(); }
  const BoundingBox &getBoundingBox() const override {
    return m_shape->getBoundingBox();
  }
84
85
86
87
  void getBoundingBox(double &xmax, double &ymax, double &zmax, double &xmin,
                      double &ymin, double &zmin) const override {
    m_shape->getBoundingBox(xmax, ymax, zmax, xmin, ymin, zmin);
  }
88
89
90
91

  int getPointInObject(Kernel::V3D &point) const override {
    return m_shape->getPointInObject(point);
  }
92
  Kernel::V3D generatePointInObject(Kernel::PseudoRandomNumberGenerator &rng,
93
94
95
                                    const size_t i) const override {
    return m_shape->generatePointInObject(rng, i);
  }
96
  Kernel::V3D generatePointInObject(Kernel::PseudoRandomNumberGenerator &rng,
97
98
99
100
                                    const BoundingBox &activeRegion,
                                    const size_t i) const override {
    return m_shape->generatePointInObject(rng, activeRegion, i);
  }
101
102

  void GetObjectGeom(int &type, std::vector<Kernel::V3D> &vectors,
103
104
105
                     double &myradius, double &myheight) const override {
    m_shape->GetObjectGeom(type, vectors, myradius, myheight);
  }
106
  boost::shared_ptr<GeometryHandler> getGeometryHandler() const override {
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
    return m_shape->getGeometryHandler();
  }

  std::string getShapeXML() const override { return m_shape->getShapeXML(); }

  void draw() const override { m_shape->draw(); }
  void initDraw() const override { m_shape->initDraw(); }

  void setMaterial(const Kernel::Material &material) override {
    m_shape->setMaterial(material);
  }
  const Kernel::Material material() const override {
    return m_shape->material();
  }
  void setID(const std::string &id) override { m_shape->setID(id); }
  const std::string &id() const override { return m_shape->id(); }
123

124
private:
125
  IObject_sptr m_shape;
126
  std::string m_sampleShapeXML;
127
128
};

129
/// Typdef for a shared pointer
Martyn Gigg's avatar
Martyn Gigg committed
130
typedef boost::shared_ptr<Container> Container_sptr;
131
/// Typdef for a shared pointer to a const object
Martyn Gigg's avatar
Martyn Gigg committed
132
typedef boost::shared_ptr<const Container> Container_const_sptr;
133

134
135
136
} // namespace Geometry
} // namespace Mantid

Martyn Gigg's avatar
Martyn Gigg committed
137
#endif /* MANTID_GEOMETRY_CONTAINER_H_ */