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
|
// 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`.
/// \brief Declaration of the unplaced Orb shape
/// \file volumes/UnplacedOrb.h
/// \author Raman Sehgal
#ifndef VECGEOM_VOLUMES_UNPLACEDORB_H_
#define VECGEOM_VOLUMES_UNPLACEDORB_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/OrbStruct.h" // the pure Orb struct
#include "VecGeom/volumes/kernel/OrbImplementation.h"
#include "VecGeom/volumes/UnplacedVolumeImplHelper.h"
#ifdef VECGEOM_ROOT
class TGeoShape;
#endif
#ifdef VECGEOM_GEANT4
class G4VSolid;
#endif
namespace vecgeom {
VECGEOM_DEVICE_FORWARD_DECLARE(class UnplacedOrb;);
VECGEOM_DEVICE_DECLARE_CONV(class, UnplacedOrb);
inline namespace VECGEOM_IMPL_NAMESPACE {
class UnplacedOrb : public SIMDUnplacedVolumeImplHelper<OrbImplementation>, public AlignedBase {
private:
OrbStruct<Precision> fOrb; ///< Structure holding the data for Orb
Precision fCubicVolume, fSurfaceArea; ///< Variable to store the cached value of Volume and SurfaceArea
Precision fEpsilon, fRTolerance; ///< Radial Tolerance
public:
using Kernel = OrbImplementation;
/// Default constructor for the unplaced orb.
VECCORE_ATT_HOST_DEVICE
UnplacedOrb();
/// Constructor for the unplaced Orb.
/** The constructor takes 1 parameter: radius of Orb
@param r Radius of Orb.
*/
VECCORE_ATT_HOST_DEVICE
UnplacedOrb(const Precision r);
/// Setter for Radial tolerance
VECCORE_ATT_HOST_DEVICE
void SetRadialTolerance();
/// Getter for Radial tolerance
VECCORE_ATT_HOST_DEVICE
Precision GetRadialTolerance() const { return fRTolerance; }
/// Getter for the structure storing Orb data.
VECCORE_ATT_HOST_DEVICE
OrbStruct<Precision> const &GetStruct() const { return fOrb; }
/// Getter for Radius
VECCORE_ATT_HOST_DEVICE
VECGEOM_FORCE_INLINE
Precision GetRadius() const { return fOrb.fR; }
/// Setter for Radius
VECCORE_ATT_HOST_DEVICE
void SetRadius(Precision r);
VECCORE_ATT_HOST_DEVICE
void Extent(Vector3D<Precision> &aMin, Vector3D<Precision> &aMax) const override;
Precision Capacity() const override { return fCubicVolume; }
Precision SurfaceArea() const override { return fSurfaceArea; }
virtual Vector3D<Precision> SamplePointOnSurface() const override;
VECCORE_ATT_HOST_DEVICE
virtual bool Normal(Vector3D<Precision> const &p, Vector3D<Precision> &normal) const override
{
bool valid;
normal = OrbImplementation::NormalKernel(fOrb, p, valid);
return valid;
}
/// Get the solid type as string.
/** @return Name of the solid type.*/
std::string GetEntityType() const;
/// Get list of Orb parameters as an array.
/** @param[in] aNumber Not used.
@param[out] aArray User array to be filled (rMin, stIn, rMax, stOut, dz)
*/
VECCORE_ATT_HOST_DEVICE
void GetParametersList(int aNumber, Precision *aArray) const;
VECCORE_ATT_HOST_DEVICE
UnplacedOrb *Clone() 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::UnplacedOrb>::SizeOf(); }
virtual DevicePtr<cuda::VUnplacedVolume> CopyToGpu() const override;
virtual DevicePtr<cuda::VUnplacedVolume> CopyToGpu(DevicePtr<cuda::VUnplacedVolume> const gpu_ptr) const override;
#endif
#ifndef VECCORE_CUDA
/// this is the function called from the VolumeFactory
/// this may be specific to the shape
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
/// Comparison specific conversion functions
#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 // VECCORE_CUDA
};
} // namespace VECGEOM_IMPL_NAMESPACE
} // namespace vecgeom
#endif
|
