| Geant4 Cross Reference |
1 // -*- C++ -*- 1
2 // -------------------------------------------
3 //
4 // This file is a part of the CLHEP - a Class
5 //
6 // History:
7 // 09.09.96 E.Chernyaev - initial version
8 // 12.06.01 E.Chernyaev - CLHEP-1.7: introduct
9 // the functionality fr
10 // 01.04.03 E.Chernyaev - CLHEP-1.9: template
11 //
12
13 #ifndef HEP_VECTOR3D_H
14 #define HEP_VECTOR3D_H
15
16 #include <iosfwd>
17 #include "CLHEP/Vector/ThreeVector.h"
18 #include "CLHEP/Geometry/BasicVector3D.h"
19
20 namespace HepGeom {
21
22 class Transform3D;
23
24 /**
25 * Geometrical 3D Vector.
26 * This is just a declaration of the class n
27 * specializations Vector3D<float> and Vecto
28 *
29 * @ingroup geometry
30 * @author Evgeni Chernyaev <Evgueni.Tcherni
31 */
32 template<class T>
33 class Vector3D : public BasicVector3D<T> {};
34
35 /**
36 * Geometrical 3D Vector with components of
37 *
38 * @author Evgeni Chernyaev <Evgueni.Tcherni
39 * @ingroup geometry
40 */
41 template<>
42 class Vector3D<float> : public BasicVector3D
43 public:
44 /**
45 * Default constructor. */
46 Vector3D() = default;
47
48 /**
49 * Constructor from three numbers. */
50 Vector3D(float x1, float y1, float z1) : B
51
52 /**
53 * Constructor from array of floats. */
54 explicit Vector3D(const float * a)
55 : BasicVector3D<float>(a[0],a[1],a[2]) {
56
57 /**
58 * Copy constructor. */
59 Vector3D(const Vector3D<float> &) = defaul
60
61 /**
62 * Move constructor. */
63 Vector3D(Vector3D<float> &&) = default;
64
65 /**
66 * Constructor from BasicVector3D<float>.
67 Vector3D(const BasicVector3D<float> & v) :
68
69 /**
70 * Destructor. */
71 ~Vector3D() = default;
72
73 /**
74 * Assignment. */
75 Vector3D<float> & operator=(const Vector3D
76
77 /**
78 * Assignment from BasicVector3D<float>. *
79 Vector3D<float> & operator=(const BasicVec
80 this->BasicVector3D<float>::operator=(v)
81 return *this;
82 }
83
84 /**
85 * Move assignment. */
86 Vector3D<float> & operator=(Vector3D<float
87
88 /**
89 * Transformation by Transform3D. */
90 Vector3D<float> & transform(const Transfor
91 };
92
93 /**
94 * Transformation of Vector<float> by Transf
95 * @relates Vector3D
96 */
97 Vector3D<float>
98 operator*(const Transform3D & m, const Vecto
99
100 /**
101 * Geometrical 3D Vector with components of
102 *
103 * @author Evgeni Chernyaev <Evgueni.Tcherni
104 * @ingroup geometry
105 */
106 template<>
107 class Vector3D<double> : public BasicVector3
108 public:
109 /**
110 * Default constructor. */
111 Vector3D() = default;
112
113 /**
114 * Constructor from three numbers. */
115 Vector3D(double x1, double y1, double z1)
116
117 /**
118 * Constructor from array of floats. */
119 explicit Vector3D(const float * a)
120 : BasicVector3D<double>(a[0],a[1],a[2])
121
122 /**
123 * Constructor from array of doubles. */
124 explicit Vector3D(const double * a)
125 : BasicVector3D<double>(a[0],a[1],a[2])
126
127 /**
128 * Copy constructor. */
129 Vector3D(const Vector3D<double> &) = defau
130
131 /**
132 * Move constructor. */
133 Vector3D(Vector3D<double> &&) = default;
134
135 /**
136 * Constructor from BasicVector3D<float>.
137 Vector3D(const BasicVector3D<float> & v) :
138
139 /**
140 * Constructor from BasicVector3D<double>.
141 Vector3D(const BasicVector3D<double> & v)
142
143 /**
144 * Destructor. */
145 ~Vector3D() = default;
146
147 /**
148 * Constructor from CLHEP::Hep3Vector.
149 * This constructor is needed only for bac
150 * in principle should be absent.
151 */
152 Vector3D(const CLHEP::Hep3Vector & v)
153 : BasicVector3D<double>(v.x(),v.y(),v.z(
154
155 /**
156 * Conversion (cast) to CLHEP::Hep3Vector.
157 * This operator is needed only for backwa
158 * in principle should not exit.
159 */
160 operator CLHEP::Hep3Vector () const { retu
161
162 /**
163 * Assignment. */
164 Vector3D<double> & operator=(const Vector3
165
166 /**
167 * Assignment from BasicVector3D<float>. *
168 Vector3D<double> & operator=(const BasicVe
169 this->BasicVector3D<double>::operator=(v
170 return *this;
171 }
172
173 /**
174 * Assignment from BasicVector3D<double>.
175 Vector3D<double> & operator=(const BasicVe
176 this->BasicVector3D<double>::operator=(v
177 return *this;
178 }
179
180 /**
181 * Move assignment. */
182 Vector3D<double> & operator=(Vector3D<doub
183
184 /**
185 * Transformation by Transform3D. */
186 Vector3D<double> & transform(const Transfo
187 };
188
189 /**
190 * Transformation of Vector<double> by Trans
191 * @relates Vector3D
192 */
193 Vector3D<double>
194 operator*(const Transform3D & m, const Vecto
195
196 } /* namespace HepGeom */
197
198 #endif /* HEP_VECTOR3D_H */
199