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