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