CLHEP VERSION Reference Documentation
   
CLHEP Home Page     CLHEP Documentation     CLHEP Bug Reports

Geometry/CLHEP/Vector/RotationInterfaces.h
Go to the documentation of this file.
1// -*- C++ -*-
2// CLASSDOC OFF
3// ---------------------------------------------------------------------------
4// CLASSDOC ON
5
6#ifndef HEP_ROTATION_INTERFACES_H
7#define HEP_ROTATION_INTERFACES_H
8
9// This file is a part of the CLHEP - a Class Library for High Energy Physics.
10//
11// This contains the definition of two abstract interface classes:
12// Hep4RotationInterface
13// Hep3RotationInterface.
14// However, these are mostly for defining methods which should be present in
15// any 4- or 3-rotation class, however specialized. The actual classes do
16// not inherit from these. The virtual function overhead turns out
17// to be too steep for that to be practical.
18//
19// It may be desirable in the future to turn these classes into constraints
20// in the Stroustrup sense, so as to enforce this interface, still without
21// inheritance. However, they do contain an important static:
22// static double tolerance to set criteria for relative nearness.
23//
24// This file also defines structs
25// HepRep3x3;
26// HepRep4x4;
27// HepRep4x4Symmetric;
28// which are used by various Rotation classes.
29//
30// Hep4RotationInterface
31// contains all the methods to get attributes of either a
32// HepLorentzRotation or a HepRotation -- any information
33// that pertains to a LorentzRotation can also be defined
34// for a HepRotation.(For example, the 4x4 representation
35// would just have 0's in the space-time entries and 1 in
36// the time-time entry.)
37//
38// Hep3RotationInterface
39// inherits from Hep4RotationInterface, and adds methods
40// which are well-defined only in the case of a Rotation.
41// For example, a 3x3 representation is an attribute only
42// if the generic LorentzRotation involves no boost.
43//
44// In terms of classes in the ZOOM PhysicsVectors package,
45// Hep4RotationInterface <--> LorentzTransformationInterface
46// Hep3RotationInterface <--> RotationInterface
47//
48// Hep4RotationInterface defines the required methods for:
49// HepLorentzRotation
50// HepBoost
51// HepBoostX
52// HepBoostY
53// HepBoostZ
54//
55// Hep3RotationInterface defines the required methods for:
56// HepRotation
57// HepRotationX
58// HepRotationY
59// HepRotationZ
60//
61// .SS See Also
62// Rotation.h, LorentzRotation.h
63//
64// .SS Author
65// Mark Fischler
66//
67
68#include "CLHEP/Vector/defs.h"
69#include "CLHEP/Vector/ThreeVector.h"
70#include "CLHEP/Vector/LorentzVector.h"
71#include "CLHEP/Vector/AxisAngle.h"
72
73namespace CLHEP {
74
75struct HepRep3x3;
76struct HepRep4x4;
77struct HepRep4x4Symmetric;
78
79class HepRotation;
80class HepRotationX;
81class HepRotationY;
82class HepRotationZ;
83class HepLorentzRotation;
84class HepBoost;
85class HepBoostX;
86class HepBoostY;
87class HepBoostZ;
88
89
90//-******************************
91//
92// Hep4RotationInterface
93//
94//-******************************
95
101
102 // All attributes of shared by HepLorentzRotation, HepBoost,
103 // HepBoostX, HepBoostY, HepBoostZ. HepRotation, HepRotationX,
104 // HepRotationY, HepRotationZ also share this attribute interface.
105
106 friend class HepRotation;
107 friend class HepRotationX;
108 friend class HepRotationY;
109 friend class HepRotationZ;
110 friend class HepLorentzRotation;
111 friend class HepBoost;
112 friend class HepBoostX;
113 friend class HepBoostY;
114 friend class HepBoostZ;
115
116public:
117
118 static double tolerance; // to determine relative nearness
119
120 // ---------- Accessors:
121
122#ifdef ONLY_IN_CONCRETE_CLASSES
123 // orthosymplectic 4-vectors:
124 HepLorentzVector col1() const;
125 HepLorentzVector col2() const;
126 HepLorentzVector col3() const;
127 HepLorentzVector col4() const;
128 HepLorentzVector row1() const;
129 HepLorentzVector row2() const;
130 HepLorentzVector row3() const;
131 HepLorentzVector row4() const;
132
133 // individual elements:
134 double xx() const ;
135 double xy() const ;
136 double xz() const ;
137 double xt() const ;
138 double yx() const ;
139 double yy() const ;
140 double yz() const ;
141 double yt() const ;
142 double zx() const ;
143 double zy() const ;
144 double zz() const ;
145 double zt() const ;
146 double tx() const ;
147 double ty() const ;
148 double tz() const ;
149 double tt() const ;
150
151 // 4x4 representation:
152//HepRep4x4 rep4x4() const; JMM Declared here but not defined anywhere!
153
154 // ---------- Operations:
155 // comparisons:
156
157 inline int compare( const Hep4RotationInterface & lt ) const;
158 // Dictionary-order comparisons, utilizing the decompose(b,r) method
159
160 // decomposition:
161
162 void decompose (HepAxisAngle & rotation, Hep3Vector & boost)const;
163 // Decompose as T= R * B, where R is pure rotation, B is pure boost.
164
165 void decompose (Hep3Vector & boost, HepAxisAngle & rotation)const;
166 // Decompose as T= B * R, where R is pure rotation, B is pure boost.
167
168 bool operator == (const Hep4RotationInterface & r) const;
169 bool operator != (const Hep4RotationInterface & r) const;
170
171 // relative comparison:
172
173 double norm2() const ;
174 double distance2( const Hep4RotationInterface & lt ) const ;
175 double howNear( const Hep4RotationInterface & lt ) const ;
176 bool isNear (const Hep4RotationInterface & lt,
177 double epsilon=tolerance) const ;
178
179 void rectify() ;
180 // non-const but logically const correction for accumulated roundoff errors
181
182 // ---------- Apply LorentzTransformations:
183
184 HepLorentzVector operator* ( const HepLorentzVector & w ) const ;
185 HepLorentzVector operator()( const HepLorentzVector & w ) const ;
186 // Apply to a 4-vector
187
188 // ---------- I/O:
189
190 std::ostream & print( std::ostream & os ) const;
191
192#endif /* ONLY_IN_CONCRETE_CLASSES */
193
194 static double getTolerance();
195 static double setTolerance( double tol );
196
197 enum { ToleranceTicks = 100 };
198
199protected:
200
201 ~Hep4RotationInterface() {} // protect destructor to forbid instatiation
202
203}; // Hep4RotationInterface
204
205
206
207//-******************************
208//
209// Hep3RotationInterface
210//
211//-******************************
212
218
219 // All attributes of HepRotation, HepRotationX, HepRotationY, HepRotationZ
220 // beyond those available by virtue of being a Hep3RotationInterface.
221
222 friend class HepRotation;
223 friend class HepRotationX;
224 friend class HepRotationY;
225 friend class HepRotationZ;
226
227public:
228
229#ifdef ONLY_IN_CONCRETE_CLASSES
230
231 // Euler angles:
232 double getPhi () const ;
233 double getTheta() const ;
234 double getPsi () const ;
235 double phi () const ;
236 double theta() const ;
237 double psi () const ;
238 HepEulerAngles eulerAngles() const ;
239
240 // axis & angle of rotation:
241 double getDelta() const ;
242 Hep3Vector getAxis () const ;
243 double delta() const ;
244 Hep3Vector axis () const ;
245 HepAxisAngle axisAngle() const ;
246
247 // orthogonal unit-length vectors:
248 Hep3Vector rowX() const;
249 Hep3Vector rowY() const;
250 Hep3Vector rowZ() const;
251
252 Hep3Vector colX() const;
253 Hep3Vector colY() const;
254 Hep3Vector colZ() const;
255
256//HepRep3x3 rep3x3() const; JMM Declared here but not defined anywhere!
257 // 3x3 representation
258
259 // orthosymplectic 4-vectors treating this as a 4-rotation:
260 HepLorentzVector col1() const;
261 HepLorentzVector col2() const;
262 HepLorentzVector col3() const;
263 HepLorentzVector col4() const;
264 HepLorentzVector row1() const;
265 HepLorentzVector row2() const;
266 HepLorentzVector row3() const;
267 HepLorentzVector row4() const;
268
269 // individual elements treating this as a 4-rotation:
270 double xt() const;
271 double yt() const;
272 double zt() const;
273 double tx() const;
274 double ty() const;
275 double tz() const;
276 double tt() const;
277
278 // ---------- Operations in the Rotation group
279
281
282 // ---------- Application
283
284 HepLorentzVector operator* ( const HepLorentzVector & w ) const ;
285 HepLorentzVector operator()( const HepLorentzVector & w ) const ;
286 // apply to HepLorentzVector
287
288 Hep3Vector operator* ( const Hep3Vector & v ) const ;
289 Hep3Vector operator()( const Hep3Vector & v ) const ;
290 // apply to Hep3Vector
291
292 // ---------- I/O and a helper method
293
294 std::ostream & print( std::ostream & os ) const;
295
296#endif /* ONLY_IN_CONCRETE_CLASSES */
297
298private:
299
300 ~Hep3RotationInterface() {} // private destructor to forbid instatiation
301
302}; // Hep3RotationInterface
303
304
305//-***************************
306// 3x3 and 4x4 representations
307//-***************************
308
309struct HepRep3x3 {
310
311 // ----- Constructors:
312
313 inline HepRep3x3();
314
315 inline HepRep3x3( double xx, double xy, double xz
316 , double yx, double yy, double yz
317 , double zx, double zy, double zz
318 );
319
320 inline HepRep3x3( const double * array );
321 // construct from an array of doubles, holding the rotation matrix
322 // in ROW order (xx, xy, ...)
323
324 inline void setToIdentity();
325
326 // ----- The data members are public:
327 double xx_, xy_, xz_,
330
331 inline void getArray ( double * array ) const;
332 // fill array with the NINE doubles xx, xy, xz ... zz
333
334}; // HepRep3x3
335
336struct HepRep4x4 {
337
338 // ----- Constructors:
339 inline HepRep4x4();
340
341 inline HepRep4x4( double xx, double xy, double xz, double xt
342 , double yx, double yy, double yz, double yt
343 , double zx, double zy, double zz, double zt
344 , double tx, double ty, double tz, double tt
345 );
346
347 inline HepRep4x4( const HepRep4x4Symmetric & rep );
348
349 inline HepRep4x4( const double * array );
350 // construct from an array of doubles, holding the transformation matrix
351 // in ROW order xx, xy, ...
352
353 inline void setToIdentity();
354
355 // ----- The data members are public:
356 double xx_, xy_, xz_, xt_,
360
361 inline void getArray ( double * array ) const;
362 // fill array with the SIXTEEN doubles xx, xy, xz ... tz, tt
363
364 inline bool operator==(HepRep4x4 const & r) const;
365 inline bool operator!=(HepRep4x4 const & r) const;
366
367
368}; // HepRep4x4
369
371
372 // ----- Constructors:
373
375
377 ( double xx, double xy, double xz, double xt
378 , double yy, double yz, double yt
379 , double zz, double zt
380 , double tt );
381
382 inline HepRep4x4Symmetric( const double * array );
383 // construct from an array of doubles, holding the transformation matrix
384 // elements in this order: xx, xy, xz, xt, yy, yz, yt, zz, zt, tt
385
386 inline void setToIdentity();
387
388 // ----- The data members are public:
389 double xx_, xy_, xz_, xt_,
393
394 inline void getArray ( double * array ) const;
395 // fill array with the TEN doubles xx, xy, xz, xt, yy, yz, yt, zz, zt, tt
396
397};
398
399} // namespace CLHEP
400
401#include "CLHEP/Vector/RotationInterfaces.icc"
402
403#ifdef ENABLE_BACKWARDS_COMPATIBILITY
404// backwards compatibility will be enabled ONLY in CLHEP 1.9
405using namespace CLHEP;
406#endif
407
408#endif // ROTATION_INTERFACES_H
static double setTolerance(double tol)
HepLorentzRotation operator*(const HepRotation &r, const HepLorentzRotation &lt)
bool operator!=(const HepRotation &r, const HepLorentzRotation &lt)
bool operator==(const HepRotation &r, const HepLorentzRotation &lt)
HepRep3x3(const double *array)
HepRep3x3(double xx, double xy, double xz, double yx, double yy, double yz, double zx, double zy, double zz)
void getArray(double *array) const
void getArray(double *array) const
HepRep4x4Symmetric(const double *array)
HepRep4x4Symmetric(double xx, double xy, double xz, double xt, double yy, double yz, double yt, double zz, double zt, double tt)
HepRep4x4(const double *array)
HepRep4x4(const HepRep4x4Symmetric &rep)
bool operator!=(HepRep4x4 const &r) const
HepRep4x4(double xx, double xy, double xz, double xt, double yx, double yy, double yz, double yt, double zx, double zy, double zz, double zt, double tx, double ty, double tz, double tt)
bool operator==(HepRep4x4 const &r) const
void getArray(double *array) const