]>
Commit | Line | Data |
---|---|---|
4c039060 | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
f531a546 | 16 | // $Id$ |
4c039060 | 17 | |
959fbac5 | 18 | /////////////////////////////////////////////////////////////////////////// |
19 | // Class AliBoost | |
20 | // Perform various Lorentz transformations. | |
21 | // | |
22 | // Example : | |
23 | // ========= | |
24 | // | |
25 | // Float_t a[3]={0.1,0.2,0.3}; | |
26 | // Float_t ea[3]={0.01,0.02,0.03}; | |
27 | // Ali3Vector beta; | |
28 | // beta.SetVector(a,"car"); | |
29 | // beta.SetErrors(ea,"car"); | |
30 | // | |
31 | // AliBoost b1; | |
32 | // b1.SetBeta(beta); | |
84bb7c66 | 33 | // b1.Data(); |
959fbac5 | 34 | // |
35 | // Float_t b[4]={14,1,2,3}; | |
36 | // Float_t eb[4]={1.4,0.1,0.2,0.3}; | |
37 | // Ali4Vector p; | |
38 | // p.SetVector(b,"car"); | |
39 | // p.SetErrors(eb,"car"); | |
40 | // Ali4Vector pprim=b1.Boost(p); | |
84bb7c66 | 41 | // p.Data(); |
42 | // pprim.Data(); | |
959fbac5 | 43 | // |
44 | // p=b1.Inverse(pprim); | |
84bb7c66 | 45 | // pprim.Data(); |
46 | // p.Data(); | |
959fbac5 | 47 | // |
48 | // Float_t c[4]={5,0,0,4}; | |
49 | // Float_t ec[4]={0.5,0,0,0.4}; | |
50 | // Ali4Vector q; | |
51 | // q.SetVector(c,"car"); | |
52 | // q.SetErrors(ec,"car"); | |
53 | // | |
54 | // AliBoost b2; | |
55 | // b2.Set4Momentum(q); | |
84bb7c66 | 56 | // b2.Data("sph"); |
959fbac5 | 57 | // |
58 | //--- Author: Nick van Eijndhoven 14-may-1996 UU-SAP Utrecht | |
f531a546 | 59 | //- Modified: NvE $Date$ UU-SAP Utrecht |
959fbac5 | 60 | /////////////////////////////////////////////////////////////////////////// |
61 | ||
d88f97cc | 62 | #include "AliBoost.h" |
c72198f1 | 63 | #include "Riostream.h" |
d88f97cc | 64 | |
65 | ClassImp(AliBoost) // Class implementation to enable ROOT I/O | |
66 | ||
c72198f1 | 67 | AliBoost::AliBoost() : TObject() |
d88f97cc | 68 | { |
959fbac5 | 69 | // Creation of a Lorentz boost object and initialisation of parameters. |
70 | // Beta is set to (0,0,0) and consequently Gamma=1. | |
71 | // All errors are initialised to 0. | |
d88f97cc | 72 | Double_t a[3]={0,0,0}; |
73 | fBeta.SetVector(a,"sph"); | |
959fbac5 | 74 | fGamma=1; |
75 | fDgamma=0; | |
76 | fDresult=0; | |
d88f97cc | 77 | } |
78 | /////////////////////////////////////////////////////////////////////////// | |
79 | AliBoost::~AliBoost() | |
80 | { | |
959fbac5 | 81 | // Default destructor. |
d88f97cc | 82 | } |
83 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 84 | AliBoost::AliBoost(const AliBoost& b) : TObject(b) |
c72198f1 | 85 | { |
86 | // Copy constructor | |
87 | fBeta=b.fBeta; | |
88 | fGamma=b.fGamma; | |
89 | fDgamma=b.fDgamma; | |
90 | fDresult=b.fDresult; | |
91 | } | |
92 | /////////////////////////////////////////////////////////////////////////// | |
93 | void AliBoost::SetBeta(Ali3Vector& b) | |
d88f97cc | 94 | { |
959fbac5 | 95 | // Setting of boost parameters on basis of beta 3-vector. |
96 | // The errors on the beta 3-vector are taken from the input 3-vector. | |
97 | // The gamma value and its error are calculated accordingly. | |
d88f97cc | 98 | fBeta=b; |
959fbac5 | 99 | Double_t beta2=fBeta.Dot(fBeta); |
100 | Double_t dbeta2=fBeta.GetResultError(); | |
d88f97cc | 101 | |
959fbac5 | 102 | if (beta2 > 1.) |
d88f97cc | 103 | { |
104 | cout << " *AliBoost::SetBeta* beta > 1." << endl; | |
105 | } | |
d88f97cc | 106 | fGamma=0; |
959fbac5 | 107 | fDgamma=0; |
108 | Double_t temp=1.-beta2; | |
109 | if (temp > 0.) | |
d88f97cc | 110 | { |
959fbac5 | 111 | fGamma=sqrt(1./temp); |
112 | fDgamma=fabs(dbeta2/(2.*pow(temp,1.5))); | |
d88f97cc | 113 | } |
114 | } | |
115 | /////////////////////////////////////////////////////////////////////////// | |
116 | void AliBoost::Set4Momentum(Ali4Vector& p) | |
117 | { | |
959fbac5 | 118 | // Setting of boost parameters on basis of momentum 4-vector data. |
119 | // The errors of the input 4-vector are used to calculate the | |
120 | // errors on the beta 3-vector and the gamma factor. | |
d88f97cc | 121 | Double_t E=p.GetScalar(); |
959fbac5 | 122 | Double_t dE=p.GetResultError(); |
d88f97cc | 123 | if (E <= 0.) |
124 | { | |
125 | cout << " *AliBoost::Set4Momentum* Unphysical situation." << endl; | |
84bb7c66 | 126 | p.Data(); |
d88f97cc | 127 | } |
128 | else | |
129 | { | |
130 | Ali3Vector b=p.Get3Vector(); | |
959fbac5 | 131 | Double_t vb[3],eb[3]; |
132 | b.GetVector(vb,"car"); | |
133 | b.GetErrors(eb,"car"); | |
d88f97cc | 134 | b=b/E; |
959fbac5 | 135 | for (Int_t i=0; i<3; i++) |
136 | { | |
137 | eb[i]=sqrt(pow(eb[i]/E,2)+pow(vb[i]*dE/(E*E),2)); | |
138 | } | |
139 | b.SetErrors(eb,"car"); | |
d88f97cc | 140 | SetBeta(b); |
141 | } | |
142 | } | |
143 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 144 | Ali3Vector AliBoost::GetBetaVector() const |
d88f97cc | 145 | { |
959fbac5 | 146 | // Provide the beta 3-vector. |
d88f97cc | 147 | return fBeta; |
148 | } | |
149 | /////////////////////////////////////////////////////////////////////////// | |
150 | Double_t AliBoost::GetBeta() | |
151 | { | |
959fbac5 | 152 | // Provide the norm of the beta 3-vector. |
153 | // The error on the value can be obtained via GetResultError(). | |
154 | Double_t norm=fBeta.GetNorm(); | |
155 | fDresult=fBeta.GetResultError(); | |
156 | return norm; | |
d88f97cc | 157 | } |
158 | /////////////////////////////////////////////////////////////////////////// | |
159 | Double_t AliBoost::GetGamma() | |
160 | { | |
959fbac5 | 161 | // Provide the gamma factor. |
162 | // The error on the value can be obtained via GetResultError(). | |
163 | fDresult=fDgamma; | |
d88f97cc | 164 | return fGamma; |
165 | } | |
166 | /////////////////////////////////////////////////////////////////////////// | |
261c0caf | 167 | Double_t AliBoost::GetResultError() const |
959fbac5 | 168 | { |
169 | // Provide the error on the result of an operation yielding a scalar. | |
170 | // E.g. GetBeta() or GetGamma() | |
171 | return fDresult; | |
172 | } | |
173 | /////////////////////////////////////////////////////////////////////////// | |
84bb7c66 | 174 | void AliBoost::Data(TString f) |
d88f97cc | 175 | { |
959fbac5 | 176 | // Printing of the boost parameter info in coordinate frame f. |
177 | Double_t beta=fBeta.GetNorm(); | |
178 | Double_t dbeta=fBeta.GetResultError(); | |
84bb7c66 | 179 | cout << " *AliBoost::Data* beta : " << beta << " error : " << dbeta |
959fbac5 | 180 | << " gamma : " << fGamma << " error : " << fDgamma << endl; |
181 | cout << " Beta"; | |
84bb7c66 | 182 | fBeta.Data(f); |
d88f97cc | 183 | } |
184 | /////////////////////////////////////////////////////////////////////////// | |
185 | Ali4Vector AliBoost::Boost(Ali4Vector& v) | |
186 | { | |
959fbac5 | 187 | // Perform the Lorentz boost on the 4-vector v. |
188 | // Error propagation is performed automatically. | |
189 | // Note : As an approximation Beta and p.Dot(Beta) are considered as | |
190 | // independent quantities. | |
191 | ||
192 | Double_t beta=fBeta.GetNorm(); | |
193 | Double_t dbeta=fBeta.GetResultError(); | |
194 | ||
195 | Double_t beta2=pow(beta,2); | |
196 | ||
197 | if (beta > 1.e-10) | |
d88f97cc | 198 | { |
199 | Double_t E=v.GetScalar(); | |
959fbac5 | 200 | Double_t dE=v.GetResultError(); |
201 | ||
d88f97cc | 202 | Ali3Vector p=v.Get3Vector(); |
959fbac5 | 203 | |
d88f97cc | 204 | Double_t pdotbeta=p.Dot(fBeta); |
959fbac5 | 205 | Double_t dpdotbeta=p.GetResultError(); |
206 | ||
207 | // Determine the new vector components | |
208 | Double_t Eprim=fGamma*(E-pdotbeta); | |
209 | ||
210 | Double_t z=((fGamma-1.)*pdotbeta/beta2)-fGamma*E; | |
211 | Ali3Vector add=fBeta*z; | |
212 | ||
213 | // Determine errors on the new vector components | |
214 | Double_t dEprim=sqrt(pow((E-pdotbeta)*fDgamma,2)+pow(fGamma*dE,2) | |
215 | +pow(fGamma*dpdotbeta,2)); | |
216 | Double_t dz=sqrt( pow(((fGamma-1.)/beta2)*dpdotbeta,2) + pow(fGamma*dE,2) | |
217 | +pow(( | |
218 | ((2./beta)-(4.*pow(beta,3)-6.*pow(beta,5))/(2.*pow((pow(beta,4)-pow(beta,6)),1.5)))*pdotbeta | |
219 | +beta*E/pow(fGamma,3))*dbeta,2) ); | |
d88f97cc | 220 | |
959fbac5 | 221 | Double_t vb[3],eb[3]; |
222 | fBeta.GetVector(vb,"car"); | |
223 | fBeta.GetErrors(eb,"car"); | |
224 | for (Int_t i=0; i<3; i++) | |
225 | { | |
226 | eb[i]=sqrt(pow(z*eb[i],2)+pow(vb[i]*dz,2)); | |
227 | } | |
228 | add.SetErrors(eb,"car"); | |
d88f97cc | 229 | |
959fbac5 | 230 | // Calculate the new 3-vector |
231 | Ali3Vector pprim=p+add; | |
d88f97cc | 232 | |
959fbac5 | 233 | // Set the components and errors of the new 4-vector |
d88f97cc | 234 | Ali4Vector w; |
235 | w.SetVector(Eprim,pprim); | |
959fbac5 | 236 | w.SetScalarError(dEprim); |
d88f97cc | 237 | |
238 | return w; | |
239 | } | |
240 | else | |
241 | { | |
242 | return v; | |
243 | } | |
244 | } | |
245 | /////////////////////////////////////////////////////////////////////////// | |
246 | Ali4Vector AliBoost::Inverse(Ali4Vector& vprim) | |
247 | { | |
959fbac5 | 248 | // Perform the inverse Lorentz boost on the 4-vector vprim. |
249 | // Error propagation is performed automatically. | |
250 | // Note : As an approximation Beta and pprim.Dot(Beta) are considered as | |
251 | // independent quantities. | |
252 | ||
253 | Double_t beta=fBeta.GetNorm(); | |
254 | Double_t dbeta=fBeta.GetResultError(); | |
255 | ||
256 | Double_t beta2=pow(beta,2); | |
257 | ||
258 | if (beta > 1.e-10) | |
d88f97cc | 259 | { |
260 | Double_t Eprim=vprim.GetScalar(); | |
959fbac5 | 261 | Double_t dEprim=vprim.GetResultError(); |
262 | ||
d88f97cc | 263 | Ali3Vector pprim=vprim.Get3Vector(); |
959fbac5 | 264 | |
d88f97cc | 265 | Double_t pprimdotbeta=pprim.Dot(fBeta); |
959fbac5 | 266 | Double_t dpprimdotbeta=pprim.GetResultError(); |
267 | ||
268 | // Determine the new vector components | |
269 | Double_t E=fGamma*(Eprim+pprimdotbeta); | |
270 | ||
271 | Double_t z=((fGamma-1.)*pprimdotbeta/beta2)+fGamma*Eprim; | |
272 | Ali3Vector add=fBeta*z; | |
273 | ||
274 | // Determine errors on the prime-vector components | |
275 | Double_t dE=sqrt(pow((Eprim+pprimdotbeta)*fDgamma,2)+pow(fGamma*dEprim,2) | |
276 | +pow(fGamma*dpprimdotbeta,2)); | |
277 | Double_t dz=sqrt( pow(((fGamma-1.)/beta2)*dpprimdotbeta,2) + pow(fGamma*dEprim,2) | |
278 | +pow(( | |
279 | ((2./beta)-(4.*pow(beta,3)-6.*pow(beta,5))/(2.*pow((pow(beta,4)-pow(beta,6)),1.5)))*pprimdotbeta | |
280 | -beta*Eprim/pow(fGamma,3))*dbeta,2) ); | |
d88f97cc | 281 | |
959fbac5 | 282 | Double_t vb[3],eb[3]; |
283 | fBeta.GetVector(vb,"car"); | |
284 | fBeta.GetErrors(eb,"car"); | |
285 | for (Int_t i=0; i<3; i++) | |
286 | { | |
287 | eb[i]=sqrt(pow(z*eb[i],2)+pow(vb[i]*dz,2)); | |
288 | } | |
289 | add.SetErrors(eb,"car"); | |
d88f97cc | 290 | |
959fbac5 | 291 | // Calculate the new 3-vector |
292 | Ali3Vector p=pprim+add; | |
d88f97cc | 293 | |
959fbac5 | 294 | // Set the components and errors of the new 4-vector |
d88f97cc | 295 | Ali4Vector w; |
296 | w.SetVector(E,p); | |
959fbac5 | 297 | w.SetScalarError(dE); |
d88f97cc | 298 | |
299 | return w; | |
300 | } | |
301 | else | |
302 | { | |
303 | return vprim; | |
304 | } | |
305 | } | |
306 | /////////////////////////////////////////////////////////////////////////// |