08-mar-2003 NvE Compiler option /GR introduced for MSVC++ in mklibs.bat to explicitly...
[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 // $Id$
17
18 ///////////////////////////////////////////////////////////////////////////
19 // Class Ali3Vector
20 // Handling of 3-vectors in various reference frames.
21 //
22 // This class is meant to serve as a base class for ALICE objects
23 // that have 3-dimensional vector characteristics.
24 // Error propagation is performed automatically. 
25 //
26 // Note :
27 // ------
28 // Vectors (v), Errors (e) and reference frames (f) are specified via
29 // SetVector(Float_t* v,TString f)
30 // SetErrors(Float_t* e,TString f)
31 // under the following conventions :
32 //
33 // f="car" ==> v in Cartesian coordinates   (x,y,z)
34 // f="sph" ==> v in Spherical coordinates   (r,theta,phi)
35 // f="cyl" ==> v in Cylindrical coordinates (rho,phi,z)
36 //
37 // All angles are in radians.
38 //
39 // Example :
40 // ---------
41 //
42 // Ali3Vector a;
43 // Float_t v[3]={-1,25,7};
44 // Float_t e[3]={0.03,0.5,0.21};
45 // a.SetVector(v,"car");
46 // a.SetErrors(e,"car");
47 // a.Data();
48 //
49 // Float_t vec[3];
50 // Float_t err[3];
51 // a.GetVector(vec,"sph");
52 // a.GetErrors(vec,"sph");
53 //
54 // Ali3Vector b;
55 // Float_t v2[3]={6,-18,33};
56 // Float_t e2[3]={0.19,0.45,0.93};
57 // b.SetVector(v2,"car");
58 // b.SetErrors(e2,"car");
59 //
60 // Float_t dotpro=a.Dot(b);
61 // Float_t doterror=a.GetResultError();
62 //
63 // Ali3Vector c=a.Cross(b);
64 // c.Data("sph");
65 // c.GetVector(vec,"cyl");
66 // c.GetErrors(err,"cyl");
67 //
68 // Float_t norm=c.GetNorm();
69 // Float_t normerror=c.GetResultError();
70 //
71 // c=a+b;
72 // c=a-b;
73 // c=a*5;
74 //
75 //--- Author: Nick van Eijndhoven 30-mar-1999 UU-SAP Utrecht
76 //- Modified: NvE $Date$ UU-SAP Utrecht
77 ///////////////////////////////////////////////////////////////////////////
78
79 #include "Ali3Vector.h"
80 #include "Riostream.h"
81  
82 ClassImp(Ali3Vector) // Class implementation to enable ROOT I/O
83  
84 Ali3Vector::Ali3Vector()
85 {
86 // Creation of an Ali3Vector object and initialisation of parameters
87 // All attributes initialised to 0
88  SetZero();
89 }
90 ///////////////////////////////////////////////////////////////////////////
91 Ali3Vector::~Ali3Vector()
92 {
93 // Destructor to delete dynamically allocated memory
94 }
95 ///////////////////////////////////////////////////////////////////////////
96 Ali3Vector::Ali3Vector(const Ali3Vector& v)
97 {
98 // Copy constructor
99  fV=v.fV;
100  fTheta=v.fTheta;
101  fPhi=v.fPhi;
102  fDx=v.fDx;
103  fDy=v.fDy;
104  fDz=v.fDz;
105  fDresult=v.fDresult;
106 }
107 ///////////////////////////////////////////////////////////////////////////
108 void Ali3Vector::SetZero()
109 {
110 // (Re)set all attributes to zero.
111  fV=0;
112  fTheta=0;
113  fPhi=0;
114  fDx=0;
115  fDy=0;
116  fDz=0;
117  fDresult=0;
118 }
119 ///////////////////////////////////////////////////////////////////////////
120 void Ali3Vector::SetVector(Double_t* v,TString f)
121 {
122 // Store vector according to reference frame f
123 // All errors will be reset to 0
124  fDx=0;
125  fDy=0;
126  fDz=0;
127  fDresult=0;
128
129  Double_t pi=acos(-1.);
130
131  Int_t frame=0;
132  if (f == "car") frame=1;
133  if (f == "sph") frame=2;
134  if (f == "cyl") frame=3;
135
136  Double_t x,y,z,rho,phi;
137
138  switch (frame)
139  {
140   case 1: // Cartesian coordinates
141    x=v[0];
142    y=v[1];
143    z=v[2];
144    fV=sqrt(x*x+y*y+z*z);
145    fTheta=0;
146    if (fV && fabs(z/fV)<=1.)
147    {
148     fTheta=acos(z/fV);
149    }
150    else
151    {
152     if (z<0.) fTheta=pi;
153    }
154    if (fTheta<0.) fTheta+=2.*pi;
155    fPhi=0;
156    if (x || y) fPhi=atan2(y,x);
157    if (fPhi<0.) fPhi+=2.*pi;
158    break;
159
160   case 2: // Spherical coordinates
161    fV=v[0];
162    fTheta=v[1];
163    fPhi=v[2];
164    break;
165
166   case 3: // Cylindrical coordinates
167    rho=v[0];
168    phi=v[1];
169    z=v[2];
170    fV=sqrt(rho*rho+z*z);
171    fPhi=phi;
172    if (fPhi<0.) fPhi+=2.*pi;
173    fTheta=0;
174    if (fV && fabs(z/fV)<=1.)
175    {
176     fTheta=acos(z/fV);
177    }
178    else
179    {
180     if (z<0.) fTheta=pi;
181    }
182    if (fTheta<0.) fTheta+=2.*pi;
183    break;
184
185   default: // Unsupported reference frame
186    cout << "*Ali3Vector::SetVector* Unsupported frame : " << f.Data() << endl
187         << " Possible frames are 'car', 'sph' and 'cyl'." << endl; 
188    fV=0;
189    fTheta=0;
190    fPhi=0;
191    break;
192  }
193 }
194 ///////////////////////////////////////////////////////////////////////////
195 void Ali3Vector::GetVector(Double_t* v,TString f)
196 {
197 // Provide vector according to reference frame f
198  Int_t frame=0;
199  if (f == "car") frame=1;
200  if (f == "sph") frame=2;
201  if (f == "cyl") frame=3;
202
203  switch (frame)
204  {
205   case 1: // Cartesian coordinates
206    v[0]=fV*sin(fTheta)*cos(fPhi);
207    v[1]=fV*sin(fTheta)*sin(fPhi);
208    v[2]=fV*cos(fTheta);
209    break;
210
211   case 2: // Spherical coordinates
212    v[0]=fV;
213    v[1]=fTheta;
214    v[2]=fPhi;
215    break;
216
217   case 3: // Cylindrical coordinates
218    v[0]=fV*sin(fTheta);
219    v[1]=fPhi;
220    v[2]=fV*cos(fTheta);
221    break;
222
223   default: // Unsupported reference frame
224    cout << "*Ali3Vector::GetVector* Unsupported frame : " << f.Data() << endl
225         << " Possible frames are 'car', 'sph' and 'cyl'." << endl; 
226    for (Int_t i=0; i<3; i++)
227    {
228     v[i]=0;
229    }
230    break;
231  }
232 }
233 ///////////////////////////////////////////////////////////////////////////
234 void Ali3Vector::SetVector(Float_t* v,TString f)
235 {
236 // Store vector according to reference frame f
237 // All errors will be reset to 0
238  Double_t vec[3];
239  for (Int_t i=0; i<3; i++)
240  {
241   vec[i]=v[i];
242  }
243  SetVector(vec,f);
244 }
245 ///////////////////////////////////////////////////////////////////////////
246 void Ali3Vector::GetVector(Float_t* v,TString f)
247 {
248 // Provide vector according to reference frame f
249  Double_t vec[3];
250  GetVector(vec,f);
251  for (Int_t i=0; i<3; i++)
252  {
253   v[i]=vec[i];
254  }
255 }
256 ///////////////////////////////////////////////////////////////////////////
257 void Ali3Vector::SetErrors(Double_t* e,TString f)
258 {
259 // Store errors according to reference frame f
260 // The error on scalar results is reset to 0
261  fDresult=0;
262
263  Int_t frame=0;
264  if (f == "car") frame=1;
265  if (f == "sph") frame=2;
266  if (f == "cyl") frame=3;
267
268  Double_t dx2,dy2,dz2,rho;
269
270  switch (frame)
271  {
272   case 1: // Cartesian coordinates
273    fDx=fabs(e[0]);
274    fDy=fabs(e[1]);
275    fDz=fabs(e[2]);
276    break;
277
278   case 2: // Spherical coordinates
279    dx2=pow((cos(fPhi)*sin(fTheta)*e[0]),2)+pow((fV*cos(fTheta)*cos(fPhi)*e[1]),2)
280        +pow((fV*sin(fTheta)*sin(fPhi)*e[2]),2);
281    dy2=pow((sin(fPhi)*sin(fTheta)*e[0]),2)+pow((fV*cos(fTheta)*sin(fPhi)*e[1]),2)
282        +pow((fV*sin(fTheta)*cos(fPhi)*e[2]),2);
283    dz2=pow((cos(fTheta)*e[0]),2)+pow((fV*sin(fTheta)*e[1]),2);
284    fDx=sqrt(dx2);
285    fDy=sqrt(dy2);
286    fDz=sqrt(dz2);
287    break;
288
289   case 3: // Cylindrical coordinates
290    rho=fV*sin(fTheta);
291    dx2=pow((cos(fPhi)*e[0]),2)+pow((rho*sin(fPhi)*e[1]),2);
292    dy2=pow((sin(fPhi)*e[0]),2)+pow((rho*cos(fPhi)*e[1]),2);
293    fDx=sqrt(dx2);
294    fDy=sqrt(dy2);
295    fDz=fabs(e[2]);
296    break;
297
298   default: // Unsupported reference frame
299    cout << "*Ali3Vector::SetErrors* Unsupported frame : " << f.Data() << endl
300         << " Possible frames are 'car', 'sph' and 'cyl'." << endl; 
301    fDx=0;
302    fDy=0;
303    fDz=0;
304    break;
305  }
306 }
307 ///////////////////////////////////////////////////////////////////////////
308 void Ali3Vector::GetErrors(Double_t* e,TString f)
309 {
310 // Provide errors according to reference frame f
311  Int_t frame=0;
312  if (f == "car") frame=1;
313  if (f == "sph") frame=2;
314  if (f == "cyl") frame=3;
315
316  Double_t pi=acos(-1.);
317
318  Double_t dr2,dtheta2,dphi2,rho,drho2;
319  Double_t v[3]; 
320  Double_t rxy2; // Shorthand for (x*x+y*y)
321
322  switch (frame)
323  {
324   case 1: // Cartesian coordinates
325    e[0]=fDx;
326    e[1]=fDy;
327    e[2]=fDz;
328    break;
329
330   case 2: // Spherical coordinates
331    GetVector(v,"car");
332    rxy2=pow(v[0],2)+pow(v[1],2);
333    if (sqrt(rxy2)<(fV*1e-10)) rxy2=0;
334    if (fV) 
335    {
336     dr2=(pow((v[0]*fDx),2)+pow((v[1]*fDy),2)+pow((v[2]*fDz),2))/(fV*fV);
337    }
338    else
339    {
340     dr2=0;
341    }
342    if (fV)
343    {
344     dtheta2=rxy2*pow(fDz,2)/pow(fV,4);
345     if (v[2] && rxy2)
346     {
347      dtheta2+=rxy2*pow(v[2],2)*(pow((v[0]*fDx),2)+pow((v[1]*fDy),2)) /
348               pow(((pow(v[2],2)*rxy2)+pow(rxy2,2)),2);
349     }
350    }
351    else
352    {
353     dtheta2=0;
354    }
355    if (rxy2)
356    {
357     dphi2=(pow((v[1]*fDx),2)+pow((v[0]*fDy),2))/(pow(rxy2,2));
358    }
359    else
360    {
361     dphi2=0;
362    }
363    e[0]=sqrt(dr2);
364    e[1]=sqrt(dtheta2);
365    if (e[1]>pi) e[1]=pi;
366    e[2]=sqrt(dphi2);
367    if (e[2]>(2.*pi)) e[2]=2.*pi;
368    break;
369
370   case 3: // Cylindrical coordinates
371    GetVector(v,"car");
372    rho=fabs(fV*sin(fTheta));
373    if (rho<(fV*1e-10)) rho=0;
374    if (rho) 
375    {
376     drho2=(pow((v[0]*fDx),2)+pow((v[1]*fDy),2))/(rho*rho);
377    }
378    else
379    {
380     drho2=0;
381    }
382    if (rho)
383    {
384     dphi2=(pow((v[1]*fDx),2)+pow((v[0]*fDy),2))/(pow(rho,4));
385    }
386    else
387    {
388     dphi2=0;
389    }
390    e[0]=sqrt(drho2);
391    e[1]=sqrt(dphi2);
392    if (e[1]>(2.*pi)) e[1]=2.*pi;
393    e[2]=fDz;
394    break;
395
396   default: // Unsupported reference frame
397    cout << "*Ali3Vector::GetErrors* Unsupported frame : " << f.Data() << endl
398         << " Possible frames are 'car', 'sph' and 'cyl'." << endl; 
399    for (Int_t i=0; i<3; i++)
400    {
401     e[i]=0;
402    }
403    break;
404  }
405 }
406 ///////////////////////////////////////////////////////////////////////////
407 void Ali3Vector::SetErrors(Float_t* e,TString f)
408 {
409 // Store errors according to reference frame f
410 // The error on scalar results is reset to 0
411  Double_t vec[3];
412  for (Int_t i=0; i<3; i++)
413  {
414   vec[i]=e[i];
415  }
416  SetErrors(vec,f);
417 }
418 ///////////////////////////////////////////////////////////////////////////
419 void Ali3Vector::GetErrors(Float_t* e,TString f)
420 {
421 // Provide errors according to reference frame f
422  Double_t vec[3];
423  GetErrors(vec,f);
424  for (Int_t i=0; i<3; i++)
425  {
426   e[i]=vec[i];
427  }
428 }
429 ///////////////////////////////////////////////////////////////////////////
430 void Ali3Vector::Data(TString f)
431 {
432 // Print vector components according to reference frame f
433  if (f=="car" || f=="sph" || f=="cyl")
434  {
435   Double_t vec[3],err[3];
436   GetVector(vec,f);
437   GetErrors(err,f);
438   cout << " Vector in " << f.Data() << " coordinates : "
439        << vec[0] << " " << vec[1] << " " << vec[2] << endl; 
440   cout << "   Err. in " << f.Data() << " coordinates : "
441        << err[0] << " " << err[1] << " " << err[2] << endl; 
442  }
443  else
444  {
445   cout << " *Ali3Vector::Data* Unsupported frame : " << f.Data() << endl
446        << "  Possible frames are 'car', 'sph' and 'cyl'." << endl; 
447  }
448 }
449 ///////////////////////////////////////////////////////////////////////////
450 Double_t Ali3Vector::GetNorm()
451 {
452 // Provide the norm of the current vector
453 // The error on the scalar result (norm) is updated accordingly
454  Double_t e[3];
455  GetErrors(e,"sph");
456  fDresult=e[0]; 
457  return fV;
458 }
459 ///////////////////////////////////////////////////////////////////////////
460 Double_t Ali3Vector::GetPseudoRapidity()
461 {
462 // Provide the pseudo-rapidity w.r.t. the z-axis.
463 // In other words : eta=-log(tan(theta/2))
464 // The error on the scalar result (pseudo-rap.) is updated accordingly
465  Double_t pi=acos(-1.);
466  Double_t v[3];
467  GetVector(v,"sph");
468  Double_t thetahalf=v[1]/2.;
469  Double_t arg=0;
470  if (v[1]<pi) arg=tan(thetahalf);
471  Double_t eta=9999;
472  if (arg>0) eta=-log(arg);
473  Double_t e[3];
474  GetErrors(e,"sph");
475  Double_t prod=cos(thetahalf)*sin(thetahalf);
476  fDresult=0;
477  if (prod) fDresult=fabs(e[1]/2.*prod);
478  return eta;
479 }
480 ///////////////////////////////////////////////////////////////////////////
481 Double_t Ali3Vector::Dot(Ali3Vector& q)
482 {
483 // Provide the dot product of the current vector with vector q
484 // The error on the scalar result (dotproduct) is updated accordingly
485
486  Double_t dotpro=0;
487
488  if ((this) == &q) // Check for special case v.Dot(v)
489  {
490   Double_t norm=GetNorm();
491   Double_t dnorm=GetResultError();
492   dotpro=pow(norm,2);
493   fDresult=2.*norm*dnorm;
494  }
495  else
496  {
497   Double_t a[3],b[3];
498   Double_t ea[3],eb[3];
499   Double_t d2=0;
500
501   GetVector(a,"car");
502   GetErrors(ea,"car");
503   q.GetVector(b,"car");
504   q.GetErrors(eb,"car");
505   for (Int_t i=0; i<3; i++)
506   {
507    dotpro+=a[i]*b[i];
508    d2+=pow(b[i]*ea[i],2)+pow(a[i]*eb[i],2);
509   }
510   fDresult=sqrt(d2);
511  }
512
513  return dotpro;
514 }
515 ///////////////////////////////////////////////////////////////////////////
516 Double_t Ali3Vector::GetResultError()
517 {
518 // Provide the error on the result of an operation yielding a scalar
519 // E.g. GetNorm() or Dot()
520  return fDresult;
521 }
522 ///////////////////////////////////////////////////////////////////////////
523 Ali3Vector Ali3Vector::Cross(Ali3Vector& q)
524 {
525 // Provide the cross product of the current vector with vector q
526 // Error propagation is performed automatically
527  Double_t a[3],b[3],c[3];
528  Double_t ea[3],eb[3],ec[3],d2;
529
530  GetVector(a,"car");
531  GetErrors(ea,"car");
532  q.GetVector(b,"car");
533  q.GetErrors(eb,"car");
534
535  c[0]=a[1]*b[2]-a[2]*b[1];
536  c[1]=a[2]*b[0]-a[0]*b[2];
537  c[2]=a[0]*b[1]-a[1]*b[0];
538
539  d2=pow(b[2]*ea[1],2)+pow(a[1]*eb[2],2)
540    +pow(b[1]*ea[2],2)+pow(a[2]*eb[1],2);
541  ec[0]=sqrt(d2);
542
543  d2=pow(b[0]*ea[2],2)+pow(a[2]*eb[0],2)
544    +pow(b[2]*ea[0],2)+pow(a[0]*eb[2],2);
545  ec[1]=sqrt(d2);
546
547  d2=pow(b[1]*ea[0],2)+pow(a[0]*eb[1],2)
548    +pow(b[0]*ea[1],2)+pow(a[1]*eb[0],2);
549  ec[2]=sqrt(d2);
550
551  Ali3Vector v;
552  v.SetVector(c,"car");
553  v.SetErrors(ec,"car");
554   
555  return v;
556 }
557 ///////////////////////////////////////////////////////////////////////////
558 Ali3Vector Ali3Vector::operator+(Ali3Vector& q)
559 {
560 // Add vector q to the current vector
561 // Error propagation is performed automatically
562  Double_t a[3],b[3],ea[3],eb[3];
563
564  GetVector(a,"car");
565  GetErrors(ea,"car");
566  q.GetVector(b,"car");
567  q.GetErrors(eb,"car");
568
569  for (Int_t i=0; i<3; i++)
570  {
571   a[i]+=b[i];
572   ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
573  }
574
575  Ali3Vector v;
576  v.SetVector(a,"car");
577  v.SetErrors(ea,"car");
578   
579  return v;
580 }
581 ///////////////////////////////////////////////////////////////////////////
582 Ali3Vector Ali3Vector::operator-(Ali3Vector& q)
583 {
584 // Subtract vector q from the current vector
585 // Error propagation is performed automatically
586  Double_t a[3],b[3],ea[3],eb[3];
587
588  GetVector(a,"car");
589  GetErrors(ea,"car");
590  q.GetVector(b,"car");
591  q.GetErrors(eb,"car");
592
593  for (Int_t i=0; i<3; i++)
594  {
595   a[i]-=b[i];
596   ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
597  }
598
599  Ali3Vector v;
600  v.SetVector(a,"car");
601  v.SetErrors(ea,"car");
602   
603  return v;
604 }
605 ///////////////////////////////////////////////////////////////////////////
606 Ali3Vector Ali3Vector::operator*(Double_t s)
607 {
608 // Multiply the current vector with a scalar s.
609 // Error propagation is performed automatically.
610  Double_t a[3],ea[3];
611
612  GetVector(a,"car");
613  GetErrors(ea,"car");
614
615  for (Int_t i=0; i<3; i++)
616  {
617   a[i]*=s;
618   ea[i]*=s;
619  }
620
621  Ali3Vector v;
622  v.SetVector(a,"car");
623  v.SetErrors(ea,"car");
624   
625  return v;
626 }
627 ///////////////////////////////////////////////////////////////////////////
628 Ali3Vector Ali3Vector::operator/(Double_t s)
629 {
630 // Divide the current vector by a scalar s
631 // Error propagation is performed automatically
632
633  if (fabs(s)<1.e-20) // Protect against division by 0
634  {
635   cout << " *Ali3Vector::/* Division by 0 detected. No action taken." << endl;
636   return *this;
637  }
638  else
639  {
640   Double_t a[3],ea[3];
641
642   GetVector(a,"car");
643   GetErrors(ea,"car");
644
645   for (Int_t i=0; i<3; i++)
646   {
647    a[i]/=s;
648    ea[i]/=s;
649   }
650
651   Ali3Vector v;
652   v.SetVector(a,"car");
653   v.SetErrors(ea,"car");
654   
655   return v;
656  }
657 }
658 ///////////////////////////////////////////////////////////////////////////
659 Ali3Vector& Ali3Vector::operator+=(Ali3Vector& q)
660 {
661 // Add vector q to the current vector
662 // Error propagation is performed automatically
663  Double_t a[3],b[3],ea[3],eb[3];
664
665  GetVector(a,"car");
666  GetErrors(ea,"car");
667  q.GetVector(b,"car");
668  q.GetErrors(eb,"car");
669
670  for (Int_t i=0; i<3; i++)
671  {
672   a[i]+=b[i];
673   ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
674  }
675
676  SetVector(a,"car");
677  SetErrors(ea,"car");
678   
679  return *this;
680 }
681 ///////////////////////////////////////////////////////////////////////////
682 Ali3Vector& Ali3Vector::operator-=(Ali3Vector& q)
683 {
684 // Subtract vector q from the current vector
685 // Error propagation is performed automatically
686  Double_t a[3],b[3],ea[3],eb[3];
687
688  GetVector(a,"car");
689  GetErrors(ea,"car");
690  q.GetVector(b,"car");
691  q.GetErrors(eb,"car");
692
693  for (Int_t i=0; i<3; i++)
694  {
695   a[i]-=b[i];
696   ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
697  }
698
699  SetVector(a,"car");
700  SetErrors(ea,"car");
701   
702  return *this;
703 }
704 ///////////////////////////////////////////////////////////////////////////
705 Ali3Vector& Ali3Vector::operator*=(Double_t s)
706 {
707 // Multiply the current vector with a scalar s
708 // Error propagation is performed automatically
709  Double_t a[3],ea[3];
710
711  GetVector(a,"car");
712  GetErrors(ea,"car");
713
714  for (Int_t i=0; i<3; i++)
715  {
716   a[i]*=s;
717   ea[i]*=s;
718  }
719
720  SetVector(a,"car");
721  SetErrors(ea,"car");
722   
723  return *this;
724 }
725 ///////////////////////////////////////////////////////////////////////////
726 Ali3Vector& Ali3Vector::operator/=(Double_t s)
727 {
728 // Divide the current vector by a scalar s
729 // Error propagation is performed automatically
730
731  if (fabs(s)<1.e-20) // Protect against division by 0
732  {
733   cout << " *Ali3Vector::/=* Division by 0 detected. No action taken." << endl;
734   return *this;
735  }
736  else
737  {
738   Double_t a[3],ea[3];
739
740   GetVector(a,"car");
741   GetErrors(ea,"car");
742
743   for (Int_t i=0; i<3; i++)
744   {
745    a[i]/=s;
746    ea[i]/=s;
747   }
748
749   SetVector(a,"car");
750   SetErrors(ea,"car");
751   
752   return *this;
753  }
754 }
755 ///////////////////////////////////////////////////////////////////////////
756 Ali3Vector Ali3Vector::GetVecTrans()
757 {
758 // Provide the transverse vector w.r.t. z-axis.
759 // Error propagation is performed automatically
760  Double_t pi=acos(-1.);
761  Double_t a[3],ea[3];
762
763  GetVector(a,"sph");
764  GetErrors(ea,"sph");
765
766  Double_t vt,dvt2;
767  vt=a[0]*sin(a[1]);
768  dvt2=pow((sin(a[1])*ea[0]),2)+pow((a[0]*cos(a[1])*ea[1]),2);
769
770  a[0]=fabs(vt);
771  a[1]=pi/2.;
772
773  ea[0]=sqrt(dvt2);
774  ea[1]=0;
775
776  Ali3Vector v;
777  v.SetVector(a,"sph");
778  v.SetErrors(ea,"sph");
779   
780  return v;
781 }
782 ///////////////////////////////////////////////////////////////////////////
783 Ali3Vector Ali3Vector::GetVecLong()
784 {
785 // Provide the longitudinal vector w.r.t. z-axis.
786 // Error propagation is performed automatically
787  Double_t pi=acos(-1.);
788  Double_t a[3],ea[3];
789
790  GetVector(a,"sph");
791  GetErrors(ea,"sph");
792
793  Double_t vl,dvl2;
794  vl=a[0]*cos(a[1]);
795  dvl2=pow((cos(a[1])*ea[0]),2)+pow((a[0]*sin(a[1])*ea[1]),2);
796
797  a[0]=fabs(vl);
798  a[1]=0;
799  if (vl<0) a[1]=pi;
800  a[2]=0;
801
802  ea[0]=sqrt(dvl2);
803  ea[1]=0;
804  ea[2]=0;
805
806  Ali3Vector v;
807  v.SetVector(a,"sph");
808  v.SetErrors(ea,"sph");
809   
810  return v;
811 }
812 ///////////////////////////////////////////////////////////////////////////