Introduction of the Copyright and cvs Log
[u/mrichter/AliRoot.git] / RALICE / Ali3Vector.cxx
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
16 /*
17 $Log$
18 */
19
20 #include "Ali3Vector.h"
21  
22 ClassImp(Ali3Vector) // Class implementation to enable ROOT I/O
23  
24 Ali3Vector::Ali3Vector()
25 {
26 // Creation of an Ali3Vector object and initialisation of parameters
27  fV=0;
28  fTheta=0;
29  fPhi=0;
30 }
31 ///////////////////////////////////////////////////////////////////////////
32 Ali3Vector::~Ali3Vector()
33 {
34 // Destructor to delete dynamically allocated memory
35 }
36 ///////////////////////////////////////////////////////////////////////////
37 void Ali3Vector::SetVector(Double_t* v,TString f)
38 {
39 // Store vector according to reference frame f
40  Double_t pi=acos(-1.);
41  Int_t frame=0;
42  if (f == "car") frame=1;
43  if (f == "sph") frame=2;
44  if (f == "cyl") frame=3;
45
46  Double_t x,y,z,rho,phi;
47
48  switch (frame)
49  {
50   case 1: // Cartesian coordinates
51    x=v[0];
52    y=v[1];
53    z=v[2];
54    fV=sqrt(x*x+y*y+z*z);
55    fTheta=0;
56    if (fV && fabs(z/fV)<=1.)
57    {
58     fTheta=acos(z/fV);
59    }
60    else
61    {
62     if (z<0.) fTheta=pi;
63    }
64    if (fTheta<0.) fTheta+=2.*pi;
65    fPhi=0;
66    if (x || y) fPhi=atan2(y,x);
67    if (fPhi<0.) fPhi+=2.*pi;
68    break;
69
70   case 2: // Spherical coordinates
71    fV=v[0];
72    fTheta=v[1];
73    fPhi=v[2];
74    break;
75
76   case 3: // Cylindrical coordinates
77    rho=v[0];
78    phi=v[1];
79    z=v[2];
80    fV=sqrt(rho*rho+z*z);
81    fPhi=phi;
82    if (fPhi<0.) fPhi+=2.*pi;
83    fTheta=0;
84    if (fV && fabs(z/fV)<=1.)
85    {
86     fTheta=acos(z/fV);
87    }
88    else
89    {
90     if (z<0.) fTheta=pi;
91    }
92    if (fTheta<0.) fTheta+=2.*pi;
93    break;
94
95   default: // Unsupported reference frame
96    cout << "*Ali3Vector::SetVector* Unsupported frame : " << f << endl
97         << " Possible frames are 'car', 'sph' and 'cyl'." << endl; 
98    fV=0;
99    fTheta=0;
100    fPhi=0;
101    break;
102  }
103 }
104 ///////////////////////////////////////////////////////////////////////////
105 void Ali3Vector::GetVector(Double_t* v,TString f)
106 {
107 // Provide vector according to reference frame f
108  Int_t frame=0;
109  if (f == "car") frame=1;
110  if (f == "sph") frame=2;
111  if (f == "cyl") frame=3;
112
113  switch (frame)
114  {
115   case 1: // Cartesian coordinates
116    v[0]=fV*sin(fTheta)*cos(fPhi);
117    v[1]=fV*sin(fTheta)*sin(fPhi);
118    v[2]=fV*cos(fTheta);
119    break;
120
121   case 2: // Spherical coordinates
122    v[0]=fV;
123    v[1]=fTheta;
124    v[2]=fPhi;
125    break;
126
127   case 3: // Cylindrical coordinates
128    v[0]=fV*sin(fTheta);
129    v[1]=fPhi;
130    v[2]=fV*cos(fTheta);
131    break;
132
133   default: // Unsupported reference frame
134    cout << "*Ali3Vector::GetVector* Unsupported frame : " << f << endl
135         << " Possible frames are 'car', 'sph' and 'cyl'." << endl; 
136    for (Int_t i=0; i<3; i++)
137    {
138     v[i]=0;
139    }
140    break;
141  }
142 }
143 ///////////////////////////////////////////////////////////////////////////
144 void Ali3Vector::SetVector(Float_t* v,TString f)
145 {
146 // Store vector according to reference frame f
147  Double_t vec[3];
148  for (Int_t i=0; i<3; i++)
149  {
150   vec[i]=v[i];
151  }
152  SetVector(vec,f);
153 }
154 ///////////////////////////////////////////////////////////////////////////
155 void Ali3Vector::GetVector(Float_t* v,TString f)
156 {
157 // Provide vector according to reference frame f
158  Double_t vec[3];
159  GetVector(vec,f);
160  for (Int_t i=0; i<3; i++)
161  {
162   v[i]=vec[i];
163  }
164 }
165 ///////////////////////////////////////////////////////////////////////////
166 void Ali3Vector::Info(TString f)
167 {
168 // Print vector components according to reference frame f
169  if (f=="car" || f=="sph" || f=="cyl")
170  {
171   Double_t vec[3];
172   GetVector(vec,f);
173   cout << " Vector in " << f << " coordinates : "
174        << vec[0] << " " << vec[1] << " " << vec[2] << endl; 
175  }
176  else
177  {
178   cout << " *Ali3Vector::Info* Unsupported frame : " << f << endl
179        << "  Possible frames are 'car', 'sph' and 'cyl'." << endl; 
180  }
181 }
182 ///////////////////////////////////////////////////////////////////////////
183 Double_t Ali3Vector::GetNorm()
184 {
185  return fV;
186 }
187 ///////////////////////////////////////////////////////////////////////////
188 Double_t Ali3Vector::Dot(Ali3Vector& q)
189 {
190 // Provide the dot product of the current vector with vector q
191  Double_t a[3],b[3];
192  Double_t dotpro=0;
193
194  GetVector(a,"car");
195  q.GetVector(b,"car");
196  for (Int_t i=0; i<3; i++)
197  {
198   dotpro+=a[i]*b[i];
199  }
200  
201  return dotpro;
202 }
203 ///////////////////////////////////////////////////////////////////////////
204 Ali3Vector Ali3Vector::Cross(Ali3Vector& q)
205 {
206 // Provide the cross product of the current vector with vector q
207  Double_t a[3],b[3],c[3];
208
209  GetVector(a,"car");
210  q.GetVector(b,"car");
211
212  c[0]=a[1]*b[2]-a[2]*b[1];
213  c[1]=a[2]*b[0]-a[0]*b[2];
214  c[2]=a[0]*b[1]-a[1]*b[0];
215
216  Ali3Vector v;
217  v.SetVector(c,"car");
218   
219  return v;
220 }
221 ///////////////////////////////////////////////////////////////////////////
222 Ali3Vector Ali3Vector::operator+(Ali3Vector& q)
223 {
224 // Add vector q to the current vector
225  Double_t a[3],b[3];
226
227  GetVector(a,"car");
228  q.GetVector(b,"car");
229
230  for (Int_t i=0; i<3; i++)
231  {
232   a[i]+=b[i];
233  }
234
235  Ali3Vector v;
236  v.SetVector(a,"car");
237   
238  return v;
239 }
240 ///////////////////////////////////////////////////////////////////////////
241 Ali3Vector Ali3Vector::operator-(Ali3Vector& q)
242 {
243 // Subtract vector q from the current vector
244  Double_t a[3],b[3];
245
246  GetVector(a,"car");
247  q.GetVector(b,"car");
248
249  for (Int_t i=0; i<3; i++)
250  {
251   a[i]-=b[i];
252  }
253
254  Ali3Vector v;
255  v.SetVector(a,"car");
256   
257  return v;
258 }
259 ///////////////////////////////////////////////////////////////////////////
260 Ali3Vector Ali3Vector::operator*(Double_t s)
261 {
262 // Multiply the current vector with a scalar s
263  Double_t a[3];
264
265  GetVector(a,"car");
266
267  for (Int_t i=0; i<3; i++)
268  {
269   a[i]*=s;
270  }
271
272  Ali3Vector v;
273  v.SetVector(a,"car");
274   
275  return v;
276 }
277 ///////////////////////////////////////////////////////////////////////////
278 Ali3Vector Ali3Vector::operator/(Double_t s)
279 {
280 // Divide the current vector by a scalar s
281
282  if (fabs(s)<1.e-20) // Protect against division by 0
283  {
284   cout << " *Ali3Vector::/* Division by 0 detected. No action taken." << endl;
285   return *this;
286  }
287  else
288  {
289   Double_t a[3];
290
291   GetVector(a,"car");
292
293   for (Int_t i=0; i<3; i++)
294   {
295    a[i]/=s;
296   }
297
298   Ali3Vector v;
299   v.SetVector(a,"car");
300   
301   return v;
302  }
303 }
304 ///////////////////////////////////////////////////////////////////////////
305 Ali3Vector& Ali3Vector::operator+=(Ali3Vector& q)
306 {
307 // Add vector q to the current vector
308  Double_t a[3],b[3];
309
310  GetVector(a,"car");
311  q.GetVector(b,"car");
312
313  for (Int_t i=0; i<3; i++)
314  {
315   a[i]+=b[i];
316  }
317
318  SetVector(a,"car");
319   
320  return *this;
321 }
322 ///////////////////////////////////////////////////////////////////////////
323 Ali3Vector& Ali3Vector::operator-=(Ali3Vector& q)
324 {
325 // Subtract vector q from the current vector
326  Double_t a[3],b[3];
327
328  GetVector(a,"car");
329  q.GetVector(b,"car");
330
331  for (Int_t i=0; i<3; i++)
332  {
333   a[i]-=b[i];
334  }
335
336  SetVector(a,"car");
337   
338  return *this;
339 }
340 ///////////////////////////////////////////////////////////////////////////
341 Ali3Vector& Ali3Vector::operator*=(Double_t s)
342 {
343 // Multiply the current vector with a scalar s
344  Double_t a[3];
345
346  GetVector(a,"car");
347
348  for (Int_t i=0; i<3; i++)
349  {
350   a[i]*=s;
351  }
352
353  SetVector(a,"car");
354   
355  return *this;
356 }
357 ///////////////////////////////////////////////////////////////////////////
358 Ali3Vector& Ali3Vector::operator/=(Double_t s)
359 {
360 // Divide the current vector by a scalar s
361
362  if (fabs(s)<1.e-20) // Protect against division by 0
363  {
364   cout << " *Ali3Vector::/=* Division by 0 detected. No action taken." << endl;
365   return *this;
366  }
367  else
368  {
369   Double_t a[3];
370
371   GetVector(a,"car");
372
373   for (Int_t i=0; i<3; i++)
374   {
375    a[i]/=s;
376   }
377
378   SetVector(a,"car");
379   
380   return *this;
381  }
382 }
383 ///////////////////////////////////////////////////////////////////////////