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