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