-
Notifications
You must be signed in to change notification settings - Fork 1.3k
/
TLorentzRotation.cxx
241 lines (206 loc) · 7.05 KB
/
TLorentzRotation.cxx
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
// @(#)root/physics:$Id$
// Author: Peter Malzacher 19/06/99
/** \class TLorentzRotation
\legacy{TLorentzRotation, Consider using instead ROOT::Math::LorentzRotation.}
\ingroup Physics
The TLorentzRotation class describes Lorentz transformations including
Lorentz boosts and rotations (see TRotation)
~~~
| xx xy xz xt |
| |
| yx yy yz yt |
lambda = | |
| zx zy zz zt |
| |
| tx ty tz tt |
~~~
### Declaration
By default it is initialized to the identity matrix, but it may also be
initialized by an other TLorentzRotation,
by a pure TRotation or by a boost:
TLorentzRotation l; // l is
initialized as identity
TLorentzRotation m(l); // m = l
TRotation r;
TLorentzRotation lr(r);
TLorentzRotation lb1(bx,by,bz);
TVector3 b;
TLorentzRotation lb2(b);
The Matrix for a Lorentz boosts is:
~~~
| 1+gamma'*bx*bx gamma'*bx*by gamma'*bx*bz gamma*bx |
| gamma'*by*bx 1+gamma'*by*by gamma'*by*bz gamma*by |
| gamma'*bz*bx gamma'*bz*by 1+gamma'*bz*bz gamma*bz |
| gamma*bx gamma*by gamma*bz gamma |
~~~
with the boost vector b=(bx,by,bz) and gamma=1/Sqrt(1-beta*beta)
and gamma'=(gamma-1)/beta*beta.
### Access to the matrix components/Comparisons
Access to the matrix components is possible through the member functions
XX(), XY() .. TT(),
through the operator (int,int):
~~~
Double_t xx;
TLorentzRotation l;
xx = l.XX(); // gets the xx component
xx = l(0,0); // gets the xx component
if (l==m) {...} // test for equality
if (l !=m) {...} // test for inequality
if (l.IsIdentity()) {...} // test for identity
~~~
### Transformations of a LorentzRotation
#### Compound transformations
There are four possibilities to find the product of two TLorentzRotation
transformations:
~~~
TLorentzRotation a,b,c;
c = b*a;// product
c = a.MatrixMultiplication(b); // a is unchanged
a *= b;// Attention: a=a*b
c = a.Transform(b)// a=b*a then c=a
~~~
#### Lorentz boosts
~~~
Double_t bx, by, bz;
TVector3 v(bx,by,bz);
TLorentzRotation l;
l.Boost(v);
l.Boost(bx,by,bz);
~~~
#### Rotations
~~~
TVector3 axis;
l.RotateX(TMath::Pi()); // rotation around x-axis
l.Rotate(.5,axis);// rotation around specified vector
~~~
#### Inverse transformation
The matrix for the inverse transformation of a TLorentzRotation is as follows:
~~~
| xx yx zx -tx |
| |
| xy yy zy -ty |
| |
| xz yz zz -tz |
| |
|-xt -yt -zt tt |
~~~
To return the inverse transformation keeping the current unchanged
use the member function Inverse().
Invert() inverts the current TLorentzRotation:
~~~
l1 = l2.Inverse(); // l1 is inverse of l2, l2 unchanged
l1 = l2.Invert(); // invert l2, then l1=l2
~~~
### Transformation of a TLorentzVector
To apply TLorentzRotation to TLorentzVector you can use
either the VectorMultiplication() member function or the *
operator. You can also use the Transform() function and the *=
operator of the TLorentzVector class.:
~~~
TLorentzVector v;
...
v=l.VectorMultiplication(v);
v = l * v;
v.Transform(l);
v *= l; // Attention v = l*v
~~~
*/
#include "TLorentzRotation.h"
ClassImp(TLorentzRotation);
TLorentzRotation::TLorentzRotation()
: fxx(1.0), fxy(0.0), fxz(0.0), fxt(0.0),
fyx(0.0), fyy(1.0), fyz(0.0), fyt(0.0),
fzx(0.0), fzy(0.0), fzz(1.0), fzt(0.0),
ftx(0.0), fty(0.0), ftz(0.0), ftt(1.0) {}
TLorentzRotation::TLorentzRotation(const TRotation & r)
: fxx(r.XX()), fxy(r.XY()), fxz(r.XZ()), fxt(0.0),
fyx(r.YX()), fyy(r.YY()), fyz(r.YZ()), fyt(0.0),
fzx(r.ZX()), fzy(r.ZY()), fzz(r.ZZ()), fzt(0.0),
ftx(0.0), fty(0.0), ftz(0.0), ftt(1.0) {}
TLorentzRotation::TLorentzRotation(const TLorentzRotation & r) : TObject(r),
fxx(r.fxx), fxy(r.fxy), fxz(r.fxz), fxt(r.fxt),
fyx(r.fyx), fyy(r.fyy), fyz(r.fyz), fyt(r.fyt),
fzx(r.fzx), fzy(r.fzy), fzz(r.fzz), fzt(r.fzt),
ftx(r.ftx), fty(r.fty), ftz(r.ftz), ftt(r.ftt) {}
TLorentzRotation::TLorentzRotation(
Double_t rxx, Double_t rxy, Double_t rxz, Double_t rxt,
Double_t ryx, Double_t ryy, Double_t ryz, Double_t ryt,
Double_t rzx, Double_t rzy, Double_t rzz, Double_t rzt,
Double_t rtx, Double_t rty, Double_t rtz, Double_t rtt)
: fxx(rxx), fxy(rxy), fxz(rxz), fxt(rxt),
fyx(ryx), fyy(ryy), fyz(ryz), fyt(ryt),
fzx(rzx), fzy(rzy), fzz(rzz), fzt(rzt),
ftx(rtx), fty(rty), ftz(rtz), ftt(rtt) {}
TLorentzRotation::TLorentzRotation(Double_t bx,
Double_t by,
Double_t bz)
{
//constructor
SetBoost(bx, by, bz);
}
TLorentzRotation::TLorentzRotation(const TVector3 & p) {
//copy constructor
SetBoost(p.X(), p.Y(), p.Z());
}
Double_t TLorentzRotation::operator () (int i, int j) const {
//dereferencing operator
if (i == 0) {
if (j == 0) { return fxx; }
if (j == 1) { return fxy; }
if (j == 2) { return fxz; }
if (j == 3) { return fxt; }
} else if (i == 1) {
if (j == 0) { return fyx; }
if (j == 1) { return fyy; }
if (j == 2) { return fyz; }
if (j == 3) { return fyt; }
} else if (i == 2) {
if (j == 0) { return fzx; }
if (j == 1) { return fzy; }
if (j == 2) { return fzz; }
if (j == 3) { return fzt; }
} else if (i == 3) {
if (j == 0) { return ftx; }
if (j == 1) { return fty; }
if (j == 2) { return ftz; }
if (j == 3) { return ftt; }
}
Warning("operator()(i,j)","subscripting: bad indices(%d,%d)",i,j);
return 0.0;
}
void TLorentzRotation::SetBoost(Double_t bx, Double_t by, Double_t bz) {
//boost this Lorentz vector
Double_t bp2 = bx*bx + by*by + bz*bz;
Double_t gamma = 1.0 / TMath::Sqrt(1.0 - bp2);
Double_t bgamma = gamma * gamma / (1.0 + gamma);
fxx = 1.0 + bgamma * bx * bx;
fyy = 1.0 + bgamma * by * by;
fzz = 1.0 + bgamma * bz * bz;
fxy = fyx = bgamma * bx * by;
fxz = fzx = bgamma * bx * bz;
fyz = fzy = bgamma * by * bz;
fxt = ftx = gamma * bx;
fyt = fty = gamma * by;
fzt = ftz = gamma * bz;
ftt = gamma;
}
TLorentzRotation TLorentzRotation::MatrixMultiplication(const TLorentzRotation & b) const {
//multiply this vector by a matrix
return TLorentzRotation(
fxx*b.fxx + fxy*b.fyx + fxz*b.fzx + fxt*b.ftx,
fxx*b.fxy + fxy*b.fyy + fxz*b.fzy + fxt*b.fty,
fxx*b.fxz + fxy*b.fyz + fxz*b.fzz + fxt*b.ftz,
fxx*b.fxt + fxy*b.fyt + fxz*b.fzt + fxt*b.ftt,
fyx*b.fxx + fyy*b.fyx + fyz*b.fzx + fyt*b.ftx,
fyx*b.fxy + fyy*b.fyy + fyz*b.fzy + fyt*b.fty,
fyx*b.fxz + fyy*b.fyz + fyz*b.fzz + fyt*b.ftz,
fyx*b.fxt + fyy*b.fyt + fyz*b.fzt + fyt*b.ftt,
fzx*b.fxx + fzy*b.fyx + fzz*b.fzx + fzt*b.ftx,
fzx*b.fxy + fzy*b.fyy + fzz*b.fzy + fzt*b.fty,
fzx*b.fxz + fzy*b.fyz + fzz*b.fzz + fzt*b.ftz,
fzx*b.fxt + fzy*b.fyt + fzz*b.fzt + fzt*b.ftt,
ftx*b.fxx + fty*b.fyx + ftz*b.fzx + ftt*b.ftx,
ftx*b.fxy + fty*b.fyy + ftz*b.fzy + ftt*b.fty,
ftx*b.fxz + fty*b.fyz + ftz*b.fzz + ftt*b.ftz,
ftx*b.fxt + fty*b.fyt + ftz*b.fzt + ftt*b.ftt);
}