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