bug fixed while filling the object AliPMDcluster
[u/mrichter/AliRoot.git] / RALICE / AliBoost.cxx
CommitLineData
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
65ClassImp(AliBoost) // Class implementation to enable ROOT I/O
66
c72198f1 67AliBoost::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///////////////////////////////////////////////////////////////////////////
79AliBoost::~AliBoost()
80{
959fbac5 81// Default destructor.
d88f97cc 82}
83///////////////////////////////////////////////////////////////////////////
c72198f1 84AliBoost::AliBoost(AliBoost& b) : TObject(b)
85{
86// Copy constructor
87 fBeta=b.fBeta;
88 fGamma=b.fGamma;
89 fDgamma=b.fDgamma;
90 fDresult=b.fDresult;
91}
92///////////////////////////////////////////////////////////////////////////
93void 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///////////////////////////////////////////////////////////////////////////
116void 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///////////////////////////////////////////////////////////////////////////
144Ali3Vector AliBoost::GetBetaVector()
145{
959fbac5 146// Provide the beta 3-vector.
d88f97cc 147 return fBeta;
148}
149///////////////////////////////////////////////////////////////////////////
150Double_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///////////////////////////////////////////////////////////////////////////
159Double_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///////////////////////////////////////////////////////////////////////////
959fbac5 167Double_t AliBoost::GetResultError()
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 174void 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///////////////////////////////////////////////////////////////////////////
185Ali4Vector 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///////////////////////////////////////////////////////////////////////////
246Ali4Vector 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///////////////////////////////////////////////////////////////////////////