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
|
// This file is part of VecGeom and is distributed under the
// conditions in the file LICENSE.txt in the top directory.
// For the full list of authors see CONTRIBUTORS.txt and `git log`.
/// Declaration of the unplaced tetrahedron shape
/// @file volumes/UnplaceTet.h
/// @author Raman Sehgal, Evgueni Tcherniaev
#ifndef VECGEOM_VOLUMES_UNPLACEDTET_H_
#define VECGEOM_VOLUMES_UNPLACEDTET_H_
#include "VecGeom/base/Cuda.h"
#include "VecGeom/base/Global.h"
#include "VecGeom/base/AlignedBase.h"
#include "VecGeom/base/Vector3D.h"
#include "VecGeom/volumes/UnplacedVolume.h"
#include "VecGeom/volumes/TetStruct.h" // the pure Tet struct
#include "VecGeom/volumes/kernel/TetImplementation.h"
#include "VecGeom/volumes/UnplacedVolumeImplHelper.h"
namespace vecgeom {
VECGEOM_DEVICE_FORWARD_DECLARE(class UnplacedTet;);
VECGEOM_DEVICE_DECLARE_CONV(class, UnplacedTet);
inline namespace VECGEOM_IMPL_NAMESPACE {
/// Class for tetrahedron shape primitive
///
/// Tetrahedron, also known as a triangular pyramid, is a polyhedron composed
/// by four triangular faces. It is completely defined by its four vertices.
class UnplacedTet : public SIMDUnplacedVolumeImplHelper<TetImplementation>, public AlignedBase {
private:
TetStruct<Precision> fTet; ///< The structure with the tetrahedron data members
public:
/// Default constructor
VECCORE_ATT_HOST_DEVICE
UnplacedTet();
/// Constructor from four points
/// @param [in] p0 Point given as 3D vector
/// @param [in] p1 Point given as 3D vector
/// @param [in] p2 Point given as 3D vector
/// @param [in] p3 Point given as 3D vector
VECCORE_ATT_HOST_DEVICE
UnplacedTet(const Vector3D<Precision> &p0, const Vector3D<Precision> &p1, const Vector3D<Precision> &p2,
const Vector3D<Precision> &p3);
/// Constructor from four points
/// @param [in] p0 Point given as array
/// @param [in] p1 Point given as array
/// @param [in] p2 Point given as array
/// @param [in] p3 Point given as array
VECCORE_ATT_HOST_DEVICE
UnplacedTet(const Precision p0[], const Precision p1[], const Precision p2[], const Precision p3[])
: fTet(p0, p1, p2, p3)
{
fGlobalConvexity = true;
}
/// Getter for the structure storing the tetrahedron data
VECCORE_ATT_HOST_DEVICE
TetStruct<Precision> const &GetStruct() const { return fTet; }
/// Getter for the tetrahedron vertices
/// @param [out] p0 Point given as 3D vector
/// @param [out] p1 Point given as 3D vector
/// @param [out] p2 Point given as 3D vector
/// @param [out] p3 Point given as 3D vector
VECCORE_ATT_HOST_DEVICE
VECGEOM_FORCE_INLINE
void GetVertices(Vector3D<Precision> &p0, Vector3D<Precision> &p1, Vector3D<Precision> &p2,
Vector3D<Precision> &p3) const
{
p0 = fTet.fVertex[0];
p1 = fTet.fVertex[1];
p2 = fTet.fVertex[2];
p3 = fTet.fVertex[3];
}
VECCORE_ATT_HOST_DEVICE
void Extent(Vector3D<Precision> &, Vector3D<Precision> &) const override;
Precision Capacity() const override { return fTet.fCubicVolume; }
Precision SurfaceArea() const override { return fTet.fSurfaceArea; }
Vector3D<Precision> SamplePointOnSurface() const override;
VECCORE_ATT_HOST_DEVICE
virtual bool Normal(Vector3D<Precision> const &p, Vector3D<Precision> &normal) const override
{
bool valid;
normal = TetImplementation::NormalKernel(fTet, p, valid);
return valid;
}
/// Get the solid type as string
/// @return Name of the solid type
std::string GetEntityType() const;
VECCORE_ATT_HOST_DEVICE
void GetParametersList(int aNumber, Precision *aArray) const;
std::ostream &StreamInfo(std::ostream &os) const;
public:
virtual int MemorySize() const final { return sizeof(*this); }
VECCORE_ATT_HOST_DEVICE
virtual void Print() const override;
virtual void Print(std::ostream &os) const override;
#ifndef VECCORE_CUDA
virtual SolidMesh *CreateMesh3D(Transformation3D const &trans, size_t nSegments) const override;
#endif
#ifdef VECGEOM_CUDA_INTERFACE
virtual size_t DeviceSizeOf() const override { return DevicePtr<cuda::UnplacedTet>::SizeOf(); }
virtual DevicePtr<cuda::VUnplacedVolume> CopyToGpu() const override;
virtual DevicePtr<cuda::VUnplacedVolume> CopyToGpu(DevicePtr<cuda::VUnplacedVolume> const gpu_ptr) const override;
#endif
/// Templated factory for creating a placed volume
#ifndef VECCORE_CUDA
template <TranslationCode trans_code, RotationCode rot_code>
static VPlacedVolume *Create(LogicalVolume const *const logical_volume, Transformation3D const *const transformation,
VPlacedVolume *const placement = NULL);
VPlacedVolume *SpecializedVolume(LogicalVolume const *const volume, Transformation3D const *const transformation,
const TranslationCode trans_code, const RotationCode rot_code,
VPlacedVolume *const placement) const override;
#else
template <TranslationCode trans_code, RotationCode rot_code>
VECCORE_ATT_DEVICE
static VPlacedVolume *Create(LogicalVolume const *const logical_volume, Transformation3D const *const transformation,
const int id, const int copy_no, const int child_id,
VPlacedVolume *const placement = NULL);
VECCORE_ATT_DEVICE VPlacedVolume *SpecializedVolume(LogicalVolume const *const volume,
Transformation3D const *const transformation,
const TranslationCode trans_code, const RotationCode rot_code,
const int id, const int copy_no, const int child_id,
VPlacedVolume *const placement) const override;
#endif
};
} // namespace VECGEOM_IMPL_NAMESPACE
} // namespace vecgeom
#endif
|
