CLHEP VERSION Reference Documentation
CLHEP Home Page
CLHEP Documentation
CLHEP Bug Reports
Main Page
Namespaces
Classes
Files
File List
File Members
Geometry
CLHEP
Vector
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
73
namespace
CLHEP {
74
75
struct
HepRep3x3;
76
struct
HepRep4x4;
77
struct
HepRep4x4Symmetric;
78
79
class
HepRotation;
80
class
HepRotationX;
81
class
HepRotationY;
82
class
HepRotationZ;
83
class
HepLorentzRotation;
84
class
HepBoost;
85
class
HepBoostX;
86
class
HepBoostY;
87
class
HepBoostZ;
88
89
90
//-******************************
91
//
92
// Hep4RotationInterface
93
//
94
//-******************************
95
100
class
Hep4RotationInterface
{
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
116
public
:
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
199
protected
:
200
201
~Hep4RotationInterface
() {}
// protect destructor to forbid instatiation
202
203
};
// Hep4RotationInterface
204
205
206
207
//-******************************
208
//
209
// Hep3RotationInterface
210
//
211
//-******************************
212
217
class
Hep3RotationInterface
:
public
Hep4RotationInterface
{
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
227
public
:
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
280
HepRotation
operator *
(
const
Hep3RotationInterface
& r )
const
;
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
298
private
:
299
300
~
Hep3RotationInterface
() {}
// private destructor to forbid instatiation
301
302
};
// Hep3RotationInterface
303
304
305
//-***************************
306
// 3x3 and 4x4 representations
307
//-***************************
308
309
struct
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_
,
328
yx_
,
yy_
,
yz_
,
329
zx_
,
zy_
,
zz_
;
330
331
inline
void
getArray
(
double
* array )
const
;
332
// fill array with the NINE doubles xx, xy, xz ... zz
333
334
};
// HepRep3x3
335
336
struct
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_
,
357
yx_
,
yy_
,
yz_
,
yt_
,
358
zx_
,
zy_
,
zz_
,
zt_
,
359
tx_
,
ty_
,
tz_
,
tt_
;
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
370
struct
HepRep4x4Symmetric
{
371
372
// ----- Constructors:
373
374
inline
HepRep4x4Symmetric
();
375
376
inline
HepRep4x4Symmetric
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_
,
390
yy_
,
yz_
,
yt_
,
391
zz_
,
zt_
,
392
tt_
;
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
405
using namespace
CLHEP;
406
#endif
407
408
#endif // ROTATION_INTERFACES_H
Generated on Sun Jun 17 2012 08:08:27 for CLHEP by
1.8.1.1