1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
/// @file UnplacedExtruded.h
/// @author Mihaela Gheata (mihaela.gheata@cern.ch)
#ifndef VECGEOM_VOLUMES_UNPLACEDEXTRUDED_H_
#define VECGEOM_VOLUMES_UNPLACEDEXTRUDED_H_
#include "VecGeom/base/Cuda.h"
#include "VecGeom/base/Global.h"
#include "VecGeom/base/AlignedBase.h"
#include "VecGeom/volumes/UnplacedVolume.h"
#include "ExtrudedStruct.h"
#include "VecGeom/volumes/kernel/ExtrudedImplementation.h"
#include "VecGeom/volumes/UnplacedVolumeImplHelper.h"
namespace vecgeom {
VECGEOM_DEVICE_FORWARD_DECLARE(class UnplacedExtruded;);
VECGEOM_DEVICE_DECLARE_CONV(class, UnplacedExtruded);
inline namespace VECGEOM_IMPL_NAMESPACE {
class UnplacedExtruded : public LoopUnplacedVolumeImplHelper<ExtrudedImplementation>, public AlignedBase {
// template <typename U>
// using vector_t = vecgeom::Vector<U>;
template <typename U>
using vector_t = std::vector<U>;
private:
ExtrudedStruct fXtru; ///< Structure storing the data for the tessellated solid
public:
/** @brief Dummy constructor */
VECCORE_ATT_HOST_DEVICE
UnplacedExtruded() : fXtru()
{
ComputeBBox();
}
/** @brief Constructor providing polygone vertices and sections */
VECCORE_ATT_HOST_DEVICE
UnplacedExtruded(int nvertices, XtruVertex2 const *vertices, int nsections, XtruSection const *sections)
: fXtru(nvertices, vertices, nsections, sections)
{
fGlobalConvexity = (nsections == 2) && fXtru.IsConvexPolygon();
ComputeBBox();
}
VECCORE_ATT_HOST_DEVICE
UnplacedExtruded(int nvertices, const Precision *x, const Precision *y, Precision zmin, Precision zmax)
: fXtru(nvertices, x, y, zmin, zmax)
{
fGlobalConvexity = fXtru.IsConvexPolygon();
ComputeBBox();
}
VECCORE_ATT_HOST_DEVICE
ExtrudedStruct const &GetStruct() const { return fXtru; }
/** @brief Initialize */
VECCORE_ATT_HOST_DEVICE
void Initialize(int nvertices, XtruVertex2 const *vertices, int nsections, XtruSection const *sections)
{
fXtru.Initialize(nvertices, vertices, nsections, sections);
fGlobalConvexity = (nsections == 2) && fXtru.IsConvexPolygon();
}
/** @brief GetThe number of sections */
VECCORE_ATT_HOST_DEVICE
VECGEOM_FORCE_INLINE
size_t GetNSections() const { return fXtru.GetNSections(); }
/** @brief Get section i */
VECCORE_ATT_HOST_DEVICE
VECGEOM_FORCE_INLINE
XtruSection GetSection(int i) const { return fXtru.GetSection(i); }
/** @brief Get the number of vertices */
VECCORE_ATT_HOST_DEVICE
VECGEOM_FORCE_INLINE
size_t GetNVertices() const { return fXtru.GetNVertices(); }
/** @brief Get the polygone vertex i */
VECCORE_ATT_HOST_DEVICE
VECGEOM_FORCE_INLINE
void GetVertex(int i, Precision &x, Precision &y) const { fXtru.GetVertex(i, x, y); }
VECCORE_ATT_HOST_DEVICE
void Extent(Vector3D<Precision> &aMin, Vector3D<Precision> &aMax) const override;
// Computes capacity of the shape in [length^3]
VECCORE_ATT_HOST_DEVICE
Precision Capacity() const override;
// VECCORE_ATT_HOST_DEVICE
Precision SurfaceArea() const override;
VECCORE_ATT_HOST_DEVICE
int ChooseSurface() const;
Vector3D<Precision> SamplePointOnSurface() const override;
VECCORE_ATT_HOST_DEVICE
bool Normal(Vector3D<Precision> const &point, Vector3D<Precision> &normal) const override;
VECCORE_ATT_HOST_DEVICE
virtual void Print() const final;
virtual void Print(std::ostream &os) const final;
virtual int memory_size() const final { return sizeof(*this); }
std::string GetEntityType() const { return "Extruded"; }
#ifndef VECCORE_CUDA
virtual SolidMesh *CreateMesh3D(Transformation3D const &trans, size_t nSegments) const override;
#endif
template <TranslationCode transCodeT, RotationCode rotCodeT>
VECCORE_ATT_DEVICE
static VPlacedVolume *Create(LogicalVolume const *const logical_volume, Transformation3D const *const transformation,
#ifdef VECCORE_CUDA
const int id,
#endif
VPlacedVolume *const placement = NULL);
#ifdef VECGEOM_CUDA_INTERFACE
#ifdef HYBRID_NAVIGATOR_PORTED_TO_CUDA
virtual size_t DeviceSizeOf() const override { return DevicePtr<cuda::UnplacedExtruded>::SizeOf(); }
#else
virtual size_t DeviceSizeOf() const override { return 0; }
#endif
virtual DevicePtr<cuda::VUnplacedVolume> CopyToGpu() const override;
virtual DevicePtr<cuda::VUnplacedVolume> CopyToGpu(DevicePtr<cuda::VUnplacedVolume> const gpu_ptr) const override;
#endif
std::ostream &StreamInfo(std::ostream &os) const;
#ifndef VECCORE_CUDA
#ifdef VECGEOM_ROOT
TGeoShape const *ConvertToRoot(char const *label) const;
#endif
#ifdef VECGEOM_GEANT4
G4VSolid const *ConvertToGeant4(char const *label) const;
#endif
#endif
private:
VECCORE_ATT_DEVICE
virtual VPlacedVolume *SpecializedVolume(LogicalVolume const *const volume,
Transformation3D const *const transformation,
const TranslationCode trans_code, const RotationCode rot_code,
#ifdef VECCORE_CUDA
const int id,
#endif
VPlacedVolume *const placement = NULL) const override; // final;
};
template <>
struct Maker<UnplacedExtruded> {
template <typename... ArgTypes>
static UnplacedExtruded *MakeInstance(const size_t nvertices, XtruVertex2 const *vertices, const int nsections,
XtruSection const *sections);
};
using GenericUnplacedExtruded = UnplacedExtruded;
} // namespace VECGEOM_IMPL_NAMESPACE
} // namespace vecgeom
#endif // VECGEOM_VOLUMES_UNPLACEDEXTRUDED_H_
|
