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