| Geant4 Cross Reference |
1 // -*- C++ -*- 1 // -*- C++ -*-
2 // CLASSDOC OFF 2 // CLASSDOC OFF
>> 3 // $Id:$
3 // ------------------------------------------- 4 // ---------------------------------------------------------------------------
4 // CLASSDOC ON 5 // CLASSDOC ON
5 // 6 //
6 // This file is a part of the CLHEP - a Class 7 // This file is a part of the CLHEP - a Class Library for High Energy Physics.
7 // 8 //
8 // This is the definition of the HepLorentzRot 9 // This is the definition of the HepLorentzRotation class for performing
9 // Lorentz transformations (rotations and boos 10 // Lorentz transformations (rotations and boosts) on objects of the
10 // HepLorentzVector class. 11 // HepLorentzVector class.
11 // 12 //
12 // HepLorentzRotation is a concrete implementa 13 // HepLorentzRotation is a concrete implementation of Hep4RotationInterface.
13 // 14 //
14 // .SS See Also 15 // .SS See Also
15 // RotationInterfaces.h 16 // RotationInterfaces.h
16 // ThreeVector.h, LorentzVector.h 17 // ThreeVector.h, LorentzVector.h
17 // Rotation.h, Boost.h 18 // Rotation.h, Boost.h
18 // 19 //
19 // .SS Author 20 // .SS Author
20 // Leif Lonnblad, Mark Fischler 21 // Leif Lonnblad, Mark Fischler
21 22
22 #ifndef HEP_LORENTZROTATION_H 23 #ifndef HEP_LORENTZROTATION_H
23 #define HEP_LORENTZROTATION_H 24 #define HEP_LORENTZROTATION_H
24 25
>> 26 #ifdef GNUPRAGMA
>> 27 #pragma interface
>> 28 #endif
>> 29
25 #include "CLHEP/Vector/RotationInterfaces.h" 30 #include "CLHEP/Vector/RotationInterfaces.h"
26 #include "CLHEP/Vector/Rotation.h" 31 #include "CLHEP/Vector/Rotation.h"
27 #include "CLHEP/Vector/Boost.h" 32 #include "CLHEP/Vector/Boost.h"
28 #include "CLHEP/Vector/LorentzVector.h" 33 #include "CLHEP/Vector/LorentzVector.h"
29 34
30 namespace CLHEP { 35 namespace CLHEP {
31 36
32 // Global methods 37 // Global methods
33 38
34 inline HepLorentzRotation inverseOf ( const He 39 inline HepLorentzRotation inverseOf ( const HepLorentzRotation & lt );
35 HepLorentzRotation operator * (const HepRotati 40 HepLorentzRotation operator * (const HepRotation & r,
36 const 41 const HepLorentzRotation & lt);
37 HepLorentzRotation operator * (const HepRotati 42 HepLorentzRotation operator * (const HepRotationX & r,
38 const 43 const HepLorentzRotation & lt);
39 HepLorentzRotation operator * (const HepRotati 44 HepLorentzRotation operator * (const HepRotationY & r,
40 const 45 const HepLorentzRotation & lt);
41 HepLorentzRotation operator * (const HepRotati 46 HepLorentzRotation operator * (const HepRotationZ & r,
42 const 47 const HepLorentzRotation & lt);
43 48
44 /** 49 /**
45 * @author 50 * @author
46 * @ingroup vector 51 * @ingroup vector
47 */ 52 */
48 class HepLorentzRotation { 53 class HepLorentzRotation {
49 54
50 public: 55 public:
51 // ---------- Identity HepLorentzRotation: 56 // ---------- Identity HepLorentzRotation:
52 57
53 DLL_API static const HepLorentzRotation IDEN 58 DLL_API static const HepLorentzRotation IDENTITY;
54 59
55 // ---------- Constructors and Assignment: 60 // ---------- Constructors and Assignment:
56 61
57 inline HepLorentzRotation(); 62 inline HepLorentzRotation();
58 // Default constructor. Gives a unit matrix. 63 // Default constructor. Gives a unit matrix.
59 64
60 inline HepLorentzRotation (const HepLorentz << 65 inline HepLorentzRotation (const HepLorentzRotation & r);
61 inline HepLorentzRotation (HepLorentzRotati << 66 // Copy constructor.
62 // Copy and move constructors. <<
63 67
64 inline HepLorentzRotation (const H 68 inline HepLorentzRotation (const HepRotation & r);
65 inline explicit HepLorentzRotation (const H 69 inline explicit HepLorentzRotation (const HepRotationX & r);
66 inline explicit HepLorentzRotation (const H 70 inline explicit HepLorentzRotation (const HepRotationY & r);
67 inline explicit HepLorentzRotation (const H 71 inline explicit HepLorentzRotation (const HepRotationZ & r);
68 inline HepLorentzRotation (const H 72 inline HepLorentzRotation (const HepBoost & b);
69 inline explicit HepLorentzRotation (const H 73 inline explicit HepLorentzRotation (const HepBoostX & b);
70 inline explicit HepLorentzRotation (const H 74 inline explicit HepLorentzRotation (const HepBoostY & b);
71 inline explicit HepLorentzRotation (const H 75 inline explicit HepLorentzRotation (const HepBoostZ & b);
72 // Constructors from special cases. 76 // Constructors from special cases.
73 77
74 inline HepLorentzRotation & operator = (HepL <<
75 inline HepLorentzRotation & operator = (cons 78 inline HepLorentzRotation & operator = (const HepLorentzRotation & m);
76 inline HepLorentzRotation & operator = (cons 79 inline HepLorentzRotation & operator = (const HepRotation & m);
77 inline HepLorentzRotation & operator = (cons 80 inline HepLorentzRotation & operator = (const HepBoost & m);
78 // Assignment. 81 // Assignment.
79 82
80 HepLorentzRotation & set (double bx, 83 HepLorentzRotation & set (double bx, double by, double bz);
81 inline HepLorentzRotation & set (const Hep3V 84 inline HepLorentzRotation & set (const Hep3Vector & p);
82 inline HepLorentzRotation & set (const HepRo 85 inline HepLorentzRotation & set (const HepRotation & r);
83 inline HepLorentzRotation & set (const HepRo 86 inline HepLorentzRotation & set (const HepRotationX & r);
84 inline HepLorentzRotation & set (const HepRo 87 inline HepLorentzRotation & set (const HepRotationY & r);
85 inline HepLorentzRotation & set (const HepRo 88 inline HepLorentzRotation & set (const HepRotationZ & r);
86 inline HepLorentzRotation & set (const HepBo 89 inline HepLorentzRotation & set (const HepBoost & boost);
87 inline HepLorentzRotation & set (const HepBo 90 inline HepLorentzRotation & set (const HepBoostX & boost);
88 inline HepLorentzRotation & set (const HepBo 91 inline HepLorentzRotation & set (const HepBoostY & boost);
89 inline HepLorentzRotation & set (const HepBo 92 inline HepLorentzRotation & set (const HepBoostZ & boost);
90 inline HepLorentzRotation (double bx, double 93 inline HepLorentzRotation (double bx, double by, double bz);
91 inline HepLorentzRotation (const Hep3Vector 94 inline HepLorentzRotation (const Hep3Vector & p);
92 // Other Constructors giving a Lorentz-boost 95 // Other Constructors giving a Lorentz-boost.
93 96
94 HepLorentzRotation & set( const HepBo 97 HepLorentzRotation & set( const HepBoost & B, const HepRotation & R );
95 inline HepLorentzRotation ( const HepBo 98 inline HepLorentzRotation ( const HepBoost & B, const HepRotation & R );
96 // supply B and R: T = B R: 99 // supply B and R: T = B R:
97 100
98 HepLorentzRotation & set( const HepRo 101 HepLorentzRotation & set( const HepRotation & R, const HepBoost & B );
99 inline HepLorentzRotation ( const HepRo 102 inline HepLorentzRotation ( const HepRotation & R, const HepBoost & B );
100 // supply R and B: T = R B: 103 // supply R and B: T = R B:
101 104
102 HepLorentzRotation ( const HepLorentzVector 105 HepLorentzRotation ( const HepLorentzVector & col1,
103 const HepLorentzVector & col2, 106 const HepLorentzVector & col2,
104 const HepLorentzVector & col3, 107 const HepLorentzVector & col3,
105 const HepLorentzVector & col4 ); 108 const HepLorentzVector & col4 );
106 // Construct from four *orthosymplectic* Lor 109 // Construct from four *orthosymplectic* LorentzVectors for the columns:
107 // NOTE: 110 // NOTE:
108 // This constructor, and the two 111 // This constructor, and the two set methods below,
109 // will check that the columns (o 112 // will check that the columns (or rows) form an orthosymplectic
110 // matrix, and will adjust values 113 // matrix, and will adjust values so that this relation is
111 // as exact as possible. 114 // as exact as possible.
112 // Orthosymplectic means the dot product US 115 // Orthosymplectic means the dot product USING THE METRIC
113 // of two different coumns will be 0, and o 116 // of two different coumns will be 0, and of a column with
114 // itself will be one. 117 // itself will be one.
115 118
116 HepLorentzRotation & set( const HepLorentzVe 119 HepLorentzRotation & set( const HepLorentzVector & col1,
117 const HepLorentzVe 120 const HepLorentzVector & col2,
118 const HepLorentzVe 121 const HepLorentzVector & col3,
119 const HepLorentzVe 122 const HepLorentzVector & col4 );
120 // supply four *orthosymplectic* HepLorent 123 // supply four *orthosymplectic* HepLorentzVectors for the columns
121 124
122 HepLorentzRotation & setRows( const HepLoren 125 HepLorentzRotation & setRows( const HepLorentzVector & row1,
123 const HepLoren 126 const HepLorentzVector & row2,
124 const HepLoren 127 const HepLorentzVector & row3,
125 const HepLoren 128 const HepLorentzVector & row4 );
126 // supply four *orthosymplectic* HepLorent 129 // supply four *orthosymplectic* HepLorentzVectors for the columns
127 130
128 inline HepLorentzRotation & set( const HepRe 131 inline HepLorentzRotation & set( const HepRep4x4 & rep );
129 inline HepLorentzRotation ( const HepRe 132 inline HepLorentzRotation ( const HepRep4x4 & rep );
130 // supply a HepRep4x4 structure (16 number 133 // supply a HepRep4x4 structure (16 numbers)
131 // WARNING: 134 // WARNING:
132 // This constructor and set metho 135 // This constructor and set method will assume the
133 // HepRep4x4 supplied is in fact 136 // HepRep4x4 supplied is in fact an orthosymplectic matrix.
134 // No checking or correction is d 137 // No checking or correction is done. If you are
135 // not certain the matrix is orth 138 // not certain the matrix is orthosymplectic, break it
136 // into four HepLorentzVector col 139 // into four HepLorentzVector columns and use the form
137 // HepLorentzRotation (col1, col2 140 // HepLorentzRotation (col1, col2, col3, col4)
138 141
139 // ---------- Accessors: 142 // ---------- Accessors:
140 143
141 inline double xx() const; 144 inline double xx() const;
142 inline double xy() const; 145 inline double xy() const;
143 inline double xz() const; 146 inline double xz() const;
144 inline double xt() const; 147 inline double xt() const;
145 inline double yx() const; 148 inline double yx() const;
146 inline double yy() const; 149 inline double yy() const;
147 inline double yz() const; 150 inline double yz() const;
148 inline double yt() const; 151 inline double yt() const;
149 inline double zx() const; 152 inline double zx() const;
150 inline double zy() const; 153 inline double zy() const;
151 inline double zz() const; 154 inline double zz() const;
152 inline double zt() const; 155 inline double zt() const;
153 inline double tx() const; 156 inline double tx() const;
154 inline double ty() const; 157 inline double ty() const;
155 inline double tz() const; 158 inline double tz() const;
156 inline double tt() const; 159 inline double tt() const;
157 // Elements of the matrix. 160 // Elements of the matrix.
158 161
159 inline HepLorentzVector col1() const; 162 inline HepLorentzVector col1() const;
160 inline HepLorentzVector col2() const; 163 inline HepLorentzVector col2() const;
161 inline HepLorentzVector col3() const; 164 inline HepLorentzVector col3() const;
162 inline HepLorentzVector col4() const; 165 inline HepLorentzVector col4() const;
163 // orthosymplectic column vectors 166 // orthosymplectic column vectors
164 167
165 inline HepLorentzVector row1() const; 168 inline HepLorentzVector row1() const;
166 inline HepLorentzVector row2() const; 169 inline HepLorentzVector row2() const;
167 inline HepLorentzVector row3() const; 170 inline HepLorentzVector row3() const;
168 inline HepLorentzVector row4() const; 171 inline HepLorentzVector row4() const;
169 // orthosymplectic row vectors 172 // orthosymplectic row vectors
170 173
171 inline HepRep4x4 rep4x4() const; 174 inline HepRep4x4 rep4x4() const;
172 // 4x4 representation: 175 // 4x4 representation:
173 176
174 // ------------ Subscripting: 177 // ------------ Subscripting:
175 178
176 class HepLorentzRotation_row { 179 class HepLorentzRotation_row {
177 public: 180 public:
178 inline HepLorentzRotation_row(const HepLor 181 inline HepLorentzRotation_row(const HepLorentzRotation &, int);
179 inline double operator [] (int) const; 182 inline double operator [] (int) const;
180 private: 183 private:
181 const HepLorentzRotation & rr; 184 const HepLorentzRotation & rr;
182 int ii; 185 int ii;
183 }; 186 };
184 // Helper class for implemention of C-style 187 // Helper class for implemention of C-style subscripting r[i][j]
185 188
186 inline const HepLorentzRotation_row operator 189 inline const HepLorentzRotation_row operator [] (int) const;
187 // Returns object of the helper class for C- 190 // Returns object of the helper class for C-style subscripting r[i][j]
188 191
189 double operator () (int, int) const; 192 double operator () (int, int) const;
190 // Fortran-style subscripting: returns (i,j) 193 // Fortran-style subscripting: returns (i,j) element of the matrix.
191 194
192 // ---------- Decomposition: 195 // ---------- Decomposition:
193 196
194 void decompose (Hep3Vector & boost, HepAxisA 197 void decompose (Hep3Vector & boost, HepAxisAngle & rotation) const;
195 void decompose (HepBoost & boost, HepRotat 198 void decompose (HepBoost & boost, HepRotation & rotation) const;
196 // Find B and R such that L = B*R 199 // Find B and R such that L = B*R
197 200
198 void decompose (HepAxisAngle & rotation, Hep 201 void decompose (HepAxisAngle & rotation, Hep3Vector & boost) const;
199 void decompose (HepRotation & rotation, Hep 202 void decompose (HepRotation & rotation, HepBoost & boost) const;
200 // Find R and B such that L = R*B 203 // Find R and B such that L = R*B
201 204
202 // ---------- Comparisons: 205 // ---------- Comparisons:
203 206
204 int compare( const HepLorentzRotation & m ) 207 int compare( const HepLorentzRotation & m ) const;
205 // Dictionary-order comparison, in order tt, 208 // Dictionary-order comparison, in order tt,tz,...zt,zz,zy,zx,yt,yz,...,xx
206 // Used in operator<, >, <=, >= 209 // Used in operator<, >, <=, >=
207 210
208 inline bool operator == (const HepLorentzRot 211 inline bool operator == (const HepLorentzRotation &) const;
209 inline bool operator != (const HepLorentzRot 212 inline bool operator != (const HepLorentzRotation &) const;
210 inline bool operator <= (const HepLorentzRot 213 inline bool operator <= (const HepLorentzRotation &) const;
211 inline bool operator >= (const HepLorentzRot 214 inline bool operator >= (const HepLorentzRotation &) const;
212 inline bool operator < (const HepLorentzRot 215 inline bool operator < (const HepLorentzRotation &) const;
213 inline bool operator > (const HepLorentzRot 216 inline bool operator > (const HepLorentzRotation &) const;
214 217
215 inline bool isIdentity() const; 218 inline bool isIdentity() const;
216 // Returns true if the Identity matrix. 219 // Returns true if the Identity matrix.
217 220
218 double distance2( const HepBoost & b ) cons 221 double distance2( const HepBoost & b ) const;
219 double distance2( const HepRotation & r ) c 222 double distance2( const HepRotation & r ) const;
220 double distance2( const HepLorentzRotation & 223 double distance2( const HepLorentzRotation & lt ) const;
221 // Decomposes L = B*R, returns the sum of di 224 // Decomposes L = B*R, returns the sum of distance2 for B and R.
222 225
223 double howNear( const HepBoost & b ) const 226 double howNear( const HepBoost & b ) const;
224 double howNear( const HepRotation & r) con 227 double howNear( const HepRotation & r) const;
225 double howNear( const HepLorentzRotation & 228 double howNear( const HepLorentzRotation & lt ) const;
226 229
227 bool isNear(const HepBoost & b, 230 bool isNear(const HepBoost & b,
228 double epsilon=Hep4RotationInterf 231 double epsilon=Hep4RotationInterface::tolerance) const;
229 bool isNear(const HepRotation & r, 232 bool isNear(const HepRotation & r,
230 double epsilon=Hep4RotationInterf 233 double epsilon=Hep4RotationInterface::tolerance) const;
231 bool isNear(const HepLorentzRotation & lt, 234 bool isNear(const HepLorentzRotation & lt,
232 double epsilon=Hep4RotationInterf 235 double epsilon=Hep4RotationInterface::tolerance) const;
233 236
234 // ---------- Properties: 237 // ---------- Properties:
235 238
236 double norm2() const; 239 double norm2() const;
237 // distance2 (IDENTITY), which involves deco 240 // distance2 (IDENTITY), which involves decomposing into B and R and summing
238 // norm2 for the individual B and R parts. 241 // norm2 for the individual B and R parts.
239 242
240 void rectify(); 243 void rectify();
241 // non-const but logically moot correction f 244 // non-const but logically moot correction for accumulated roundoff errors
242 // rectify averages the matrix with th 245 // rectify averages the matrix with the orthotranspose of its actual
243 // inverse (absent accumulated roundof 246 // inverse (absent accumulated roundoff errors, the orthotranspose IS
244 // the inverse)); this removes to firs 247 // the inverse)); this removes to first order those errors.
245 // Then it formally decomposes that, e 248 // Then it formally decomposes that, extracts axis and delta for its
246 // Rotation part, forms a LorentzRotation fr 249 // Rotation part, forms a LorentzRotation from a true HepRotation
247 // with those values of axis and delta, time 250 // with those values of axis and delta, times the true Boost
248 // with that boost vector. 251 // with that boost vector.
249 252
250 // ---------- Application: 253 // ---------- Application:
251 254
252 inline HepLorentzVector vectorMultiplication 255 inline HepLorentzVector vectorMultiplication(const HepLorentzVector&) const;
253 inline HepLorentzVector operator()( const He 256 inline HepLorentzVector operator()( const HepLorentzVector & w ) const;
254 inline HepLorentzVector operator* ( const He 257 inline HepLorentzVector operator* ( const HepLorentzVector & p ) const;
255 // Multiplication with a Lorentz Vector. 258 // Multiplication with a Lorentz Vector.
256 259
257 // ---------- Operations in the group of 4-R 260 // ---------- Operations in the group of 4-Rotations
258 261
259 HepLorentzRotation matrixMultiplication(cons 262 HepLorentzRotation matrixMultiplication(const HepRep4x4 & m) const;
260 263
261 inline HepLorentzRotation operator * (const 264 inline HepLorentzRotation operator * (const HepBoost & b) const;
262 inline HepLorentzRotation operator * (const 265 inline HepLorentzRotation operator * (const HepRotation & r) const;
263 inline HepLorentzRotation operator * (const 266 inline HepLorentzRotation operator * (const HepLorentzRotation & lt) const;
264 // Product of two Lorentz Rotations (this) * 267 // Product of two Lorentz Rotations (this) * lt - matrix multiplication
265 268
266 inline HepLorentzRotation & operator *= (co 269 inline HepLorentzRotation & operator *= (const HepBoost & b);
267 inline HepLorentzRotation & operator *= (co 270 inline HepLorentzRotation & operator *= (const HepRotation & r);
268 inline HepLorentzRotation & operator *= (co 271 inline HepLorentzRotation & operator *= (const HepLorentzRotation & lt);
269 inline HepLorentzRotation & transform (co 272 inline HepLorentzRotation & transform (const HepBoost & b);
270 inline HepLorentzRotation & transform (co 273 inline HepLorentzRotation & transform (const HepRotation & r);
271 inline HepLorentzRotation & transform (co 274 inline HepLorentzRotation & transform (const HepLorentzRotation & lt);
272 // Matrix multiplication. 275 // Matrix multiplication.
273 // Note a *= b; <=> a = a * b; while a.trans 276 // Note a *= b; <=> a = a * b; while a.transform(b); <=> a = b * a;
274 277
275 // Here there is an opportunity for speedup 278 // Here there is an opportunity for speedup by providing specialized forms
276 // of lt * r and lt * b where r is a Rotatio 279 // of lt * r and lt * b where r is a RotationX Y or Z or b is a BoostX Y or Z
277 // These are, in fact, provided below for th 280 // These are, in fact, provided below for the transform() methods.
278 281
279 HepLorentzRotation & rotateX(double delta); 282 HepLorentzRotation & rotateX(double delta);
280 // Rotation around the x-axis; equivalent to 283 // Rotation around the x-axis; equivalent to LT = RotationX(delta) * LT
281 284
282 HepLorentzRotation & rotateY(double delta); 285 HepLorentzRotation & rotateY(double delta);
283 // Rotation around the y-axis; equivalent to 286 // Rotation around the y-axis; equivalent to LT = RotationY(delta) * LT
284 287
285 HepLorentzRotation & rotateZ(double delta); 288 HepLorentzRotation & rotateZ(double delta);
286 // Rotation around the z-axis; equivalent to 289 // Rotation around the z-axis; equivalent to LT = RotationZ(delta) * LT
287 290
288 inline HepLorentzRotation & rotate(double de 291 inline HepLorentzRotation & rotate(double delta, const Hep3Vector& axis);
289 inline HepLorentzRotation & rotate(double de 292 inline HepLorentzRotation & rotate(double delta, const Hep3Vector *axis);
290 // Rotation around specified vector - LT = R 293 // Rotation around specified vector - LT = Rotation(delta,axis)*LT
291 294
292 HepLorentzRotation & boostX(double beta); 295 HepLorentzRotation & boostX(double beta);
293 // Pure boost along the x-axis; equivalent t 296 // Pure boost along the x-axis; equivalent to LT = BoostX(beta) * LT
294 297
295 HepLorentzRotation & boostY(double beta); 298 HepLorentzRotation & boostY(double beta);
296 // Pure boost along the y-axis; equivalent t 299 // Pure boost along the y-axis; equivalent to LT = BoostX(beta) * LT
297 300
298 HepLorentzRotation & boostZ(double beta); 301 HepLorentzRotation & boostZ(double beta);
299 // Pure boost along the z-axis; equivalent t 302 // Pure boost along the z-axis; equivalent to LT = BoostX(beta) * LT
300 303
301 inline HepLorentzRotation & boost(double, do 304 inline HepLorentzRotation & boost(double, double, double);
302 inline HepLorentzRotation & boost(const Hep3 305 inline HepLorentzRotation & boost(const Hep3Vector &);
303 // Lorenz boost. 306 // Lorenz boost.
304 307
305 inline HepLorentzRotation inverse() const; 308 inline HepLorentzRotation inverse() const;
306 // Return the inverse. 309 // Return the inverse.
307 310
308 inline HepLorentzRotation & invert(); 311 inline HepLorentzRotation & invert();
309 // Inverts the LorentzRotation matrix. 312 // Inverts the LorentzRotation matrix.
310 313
311 // ---------- I/O: 314 // ---------- I/O:
312 315
313 std::ostream & print( std::ostream & os ) co 316 std::ostream & print( std::ostream & os ) const;
314 // Aligned six-digit-accurate output of the 317 // Aligned six-digit-accurate output of the transformation matrix.
315 318
316 // ---------- Tolerance 319 // ---------- Tolerance
317 320
318 static inline double getTolerance(); 321 static inline double getTolerance();
319 static inline double setTolerance(double tol 322 static inline double setTolerance(double tol);
320 323
321 friend HepLorentzRotation inverseOf ( const 324 friend HepLorentzRotation inverseOf ( const HepLorentzRotation & lt );
322 325
323 protected: 326 protected:
324 327
325 inline HepLorentzRotation 328 inline HepLorentzRotation
326 (double mxx, double mxy, double mxz, do 329 (double mxx, double mxy, double mxz, double mxt,
327 double myx, double myy, double myz, double m 330 double myx, double myy, double myz, double myt,
328 double mzx, double mzy, double mzz, double m 331 double mzx, double mzy, double mzz, double mzt,
329 double mtx, double mty, double mtz, double m 332 double mtx, double mty, double mtz, double mtt);
330 // Protected constructor. 333 // Protected constructor.
331 // DOES NOT CHECK FOR VALIDITY AS A LORENTZ 334 // DOES NOT CHECK FOR VALIDITY AS A LORENTZ TRANSFORMATION.
332 335
333 inline void setBoost(double, double, double) 336 inline void setBoost(double, double, double);
334 // Set elements according to a boost vector. 337 // Set elements according to a boost vector.
335 338
336 double mxx, mxy, mxz, mxt, 339 double mxx, mxy, mxz, mxt,
337 myx, myy, myz, myt, 340 myx, myy, myz, myt,
338 mzx, mzy, mzz, mzt, 341 mzx, mzy, mzz, mzt,
339 mtx, mty, mtz, mtt; 342 mtx, mty, mtz, mtt;
340 // The matrix elements. 343 // The matrix elements.
341 344
342 }; // HepLorentzRotation 345 }; // HepLorentzRotation
343 346
344 inline std::ostream & operator<< 347 inline std::ostream & operator<<
345 ( std::ostream & os, const HepLorentzRota 348 ( std::ostream & os, const HepLorentzRotation& lt )
346 {return lt.print(os);} 349 {return lt.print(os);}
347 350
348 inline bool operator==(const HepRotation &r, c 351 inline bool operator==(const HepRotation &r, const HepLorentzRotation & lt)
349 { return lt==HepLorentzRotation(r); } << 352 { return lt==r; }
350 inline bool operator!=(const HepRotation &r, c 353 inline bool operator!=(const HepRotation &r, const HepLorentzRotation & lt)
351 { return lt!=HepLorentzRotation(r); } << 354 { return lt!=r; }
352 inline bool operator<=(const HepRotation &r, c 355 inline bool operator<=(const HepRotation &r, const HepLorentzRotation & lt)
353 { return lt<=r; } 356 { return lt<=r; }
354 inline bool operator>=(const HepRotation &r, c 357 inline bool operator>=(const HepRotation &r, const HepLorentzRotation & lt)
355 { return lt>=r; } 358 { return lt>=r; }
356 inline bool operator<(const HepRotation &r, co 359 inline bool operator<(const HepRotation &r, const HepLorentzRotation & lt)
357 { return lt<r; } 360 { return lt<r; }
358 inline bool operator>(const HepRotation &r, co 361 inline bool operator>(const HepRotation &r, const HepLorentzRotation & lt)
359 { return lt>r; } 362 { return lt>r; }
360 363
361 inline bool operator==(const HepBoost &b, cons 364 inline bool operator==(const HepBoost &b, const HepLorentzRotation & lt)
362 { return lt==HepLorentzRotation(b); } << 365 { return lt==b; }
363 inline bool operator!=(const HepBoost &b, cons 366 inline bool operator!=(const HepBoost &b, const HepLorentzRotation & lt)
364 { return lt!=HepLorentzRotation(b); } << 367 { return lt!=b; }
365 inline bool operator<=(const HepBoost &b, cons 368 inline bool operator<=(const HepBoost &b, const HepLorentzRotation & lt)
366 { return lt<=b; } 369 { return lt<=b; }
367 inline bool operator>=(const HepBoost &b, cons 370 inline bool operator>=(const HepBoost &b, const HepLorentzRotation & lt)
368 { return lt>=b; } 371 { return lt>=b; }
369 inline bool operator<(const HepBoost &b, const 372 inline bool operator<(const HepBoost &b, const HepLorentzRotation & lt)
370 { return lt<b; } 373 { return lt<b; }
371 inline bool operator>(const HepBoost &b, const 374 inline bool operator>(const HepBoost &b, const HepLorentzRotation & lt)
372 { return lt>b; } 375 { return lt>b; }
373 376
374 } // namespace CLHEP 377 } // namespace CLHEP
375 378
376 #include "CLHEP/Vector/LorentzRotation.icc" 379 #include "CLHEP/Vector/LorentzRotation.icc"
377 380
378 #endif /* HEP_LORENTZROTATION_H */ 381 #endif /* HEP_LORENTZROTATION_H */
379 382
380 383