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.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
  76 //- Modified: NvE $Date$ UU-SAP Utrecht
  77 ///////////////////////////////////////////////////////////////////////////
  78
  79 #include "Ali3Vector.h"
  80
  81 ClassImp(Ali3Vector) // Class implementation to enable ROOT I/O
  82
  83 Ali3Vector::Ali3Vector()
  84 {
  85 // Creation of an Ali3Vector object and initialisation of parameters
  86 // All attributes initialised to 0
  87  fV=0;
  88  fTheta=0;
  89  fPhi=0;
  90  fDx=0;
  91  fDy=0;
  92  fDz=0;
  93  fDresult=0;
  94 }
  95 ///////////////////////////////////////////////////////////////////////////
  96 Ali3Vector::~Ali3Vector()
  97 {
  98 // Destructor to delete dynamically allocated memory
  99 }
 100 ///////////////////////////////////////////////////////////////////////////
 101 void Ali3Vector::SetVector(Double_t* v,TString f)
 102 {
 103 // Store vector according to reference frame f
 104 // All errors will be reset to 0
 105  fDx=0;
 106  fDy=0;
 107  fDz=0;
 108  fDresult=0;
 109
 110  Double_t pi=acos(-1.);
 111
 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 ///////////////////////////////////////////////////////////////////////////
 176 void 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 ///////////////////////////////////////////////////////////////////////////
 215 void Ali3Vector::SetVector(Float_t* v,TString f)
 216 {
 217 // Store vector according to reference frame f
 218 // All errors will be reset to 0
 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 ///////////////////////////////////////////////////////////////////////////
 227 void 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 ///////////////////////////////////////////////////////////////////////////
 238 void 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 ///////////////////////////////////////////////////////////////////////////
 289 void 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 pi=acos(-1.);
 298
 299  Double_t dr2,dtheta2,dphi2,rho,drho2;
 300  Double_t v[3];
 301  Double_t rxy2; // Shorthand for (x*x+y*y)
 302
 303  switch (frame)
 304  {
 305   case 1: // Cartesian coordinates
 306    e[0]=fDx;
 307    e[1]=fDy;
 308    e[2]=fDz;
 309    break;
 310
 311   case 2: // Spherical coordinates
 312    GetVector(v,"car");
 313    rxy2=pow(v[0],2)+pow(v[1],2);
 314    if (sqrt(rxy2)<(fV*1e-10)) rxy2=0;
 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 (fV)
 324    {
 325     dtheta2=rxy2*pow(fDz,2)/pow(fV,4);
 326     if (v[2] && rxy2)
 327     {
 328      dtheta2+=rxy2*pow(v[2],2)*(pow((v[0]*fDx),2)+pow((v[1]*fDy),2)) /
 329               pow(((pow(v[3],2)*rxy2)+pow(rxy2,2)),2);
 330     }
 331    }
 332    else
 333    {
 334     dtheta2=0;
 335    }
 336    if (rxy2)
 337    {
 338     dphi2=(pow((v[1]*fDx),2)+pow((v[0]*fDy),2))/(pow(rxy2,2));
 339    }
 340    else
 341    {
 342     dphi2=0;
 343    }
 344    e[0]=sqrt(dr2);
 345    e[1]=sqrt(dtheta2);
 346    if (e[1]>pi) e[1]=pi;
 347    e[2]=sqrt(dphi2);
 348    if (e[2]>(2.*pi)) e[2]=2.*pi;
 349    break;
 350
 351   case 3: // Cylindrical coordinates
 352    GetVector(v,"car");
 353    rho=fabs(fV*sin(fTheta));
 354    if (rho<(fV*1e-10)) rho=0;
 355    if (rho)
 356    {
 357     drho2=(pow((v[0]*fDx),2)+pow((v[1]*fDy),2))/(rho*rho);
 358    }
 359    else
 360    {
 361     drho2=0;
 362    }
 363    if (rho)
 364    {
 365     dphi2=(pow((v[1]*fDx),2)+pow((v[0]*fDy),2))/(pow(rho,4));
 366    }
 367    else
 368    {
 369     dphi2=0;
 370    }
 371    e[0]=sqrt(drho2);
 372    e[1]=sqrt(dphi2);
 373    if (e[1]>(2.*pi)) e[1]=2.*pi;
 374    e[2]=fDz;
 375    break;
 376
 377   default: // Unsupported reference frame
 378    cout << "*Ali3Vector::GetErrors* Unsupported frame : " << f << endl
 379         << " Possible frames are 'car', 'sph' and 'cyl'." << endl;
 380    for (Int_t i=0; i<3; i++)
 381    {
 382     e[i]=0;
 383    }
 384    break;
 385  }
 386 }
 387 ///////////////////////////////////////////////////////////////////////////
 388 void Ali3Vector::SetErrors(Float_t* e,TString f)
 389 {
 390 // Store errors according to reference frame f
 391 // The error on scalar results is reset to 0
 392  Double_t vec[3];
 393  for (Int_t i=0; i<3; i++)
 394  {
 395   vec[i]=e[i];
 396  }
 397  SetErrors(vec,f);
 398 }
 399 ///////////////////////////////////////////////////////////////////////////
 400 void Ali3Vector::GetErrors(Float_t* e,TString f)
 401 {
 402 // Provide errors according to reference frame f
 403  Double_t vec[3];
 404  GetErrors(vec,f);
 405  for (Int_t i=0; i<3; i++)
 406  {
 407   e[i]=vec[i];
 408  }
 409 }
 410 ///////////////////////////////////////////////////////////////////////////
 411 void Ali3Vector::Info(TString f)
 412 {
 413 // Print vector components according to reference frame f
 414  if (f=="car" || f=="sph" || f=="cyl")
 415  {
 416   Double_t vec[3],err[3];
 417   GetVector(vec,f);
 418   GetErrors(err,f);
 419   cout << " Vector in " << f << " coordinates : "
 420        << vec[0] << " " << vec[1] << " " << vec[2] << endl;
 421   cout << "   Err. in " << f << " coordinates : "
 422        << err[0] << " " << err[1] << " " << err[2] << endl;
 423  }
 424  else
 425  {
 426   cout << " *Ali3Vector::Info* Unsupported frame : " << f << endl
 427        << "  Possible frames are 'car', 'sph' and 'cyl'." << endl;
 428  }
 429 }
 430 ///////////////////////////////////////////////////////////////////////////
 431 Double_t Ali3Vector::GetNorm()
 432 {
 433 // Provide the norm of the current vector
 434 // The error on the scalar result (norm) is updated accordingly
 435  Double_t e[3];
 436  GetErrors(e,"sph");
 437  fDresult=e[0];
 438  return fV;
 439 }
 440 ///////////////////////////////////////////////////////////////////////////
 441 Double_t Ali3Vector::GetPseudoRapidity()
 442 {
 443 // Provide the pseudo-rapidity w.r.t. the z-axis.
 444 // In other words : eta=-log(tan(theta/2))
 445 // The error on the scalar result (pseudo-rap.) is updated accordingly
 446  Double_t v[3];
 447  GetVector(v,"sph");
 448  Double_t thetahalf=v[1]/2.;
 449  Double_t arg=tan(thetahalf);
 450  Double_t eta=0;
 451  if (arg>0) eta=-log(arg);
 452  Double_t e[3];
 453  GetErrors(e,"sph");
 454  Double_t prod=cos(thetahalf)*sin(thetahalf);
 455  fDresult=0;
 456  if (prod) fDresult=fabs(e[1]/2.*prod);
 457  return eta;
 458 }
 459 ///////////////////////////////////////////////////////////////////////////
 460 Double_t Ali3Vector::Dot(Ali3Vector& q)
 461 {
 462 // Provide the dot product of the current vector with vector q
 463 // The error on the scalar result (dotproduct) is updated accordingly
 464
 465  Double_t dotpro=0;
 466
 467  if ((this) == &q) // Check for special case v.Dot(v)
 468  {
 469   Double_t norm=GetNorm();
 470   Double_t dnorm=GetResultError();
 471   dotpro=pow(norm,2);
 472   fDresult=2.*norm*dnorm;
 473  }
 474  else
 475  {
 476   Double_t a[3],b[3];
 477   Double_t ea[3],eb[3];
 478   Double_t d2=0;
 479
 480   GetVector(a,"car");
 481   GetErrors(ea,"car");
 482   q.GetVector(b,"car");
 483   q.GetErrors(eb,"car");
 484   for (Int_t i=0; i<3; i++)
 485   {
 486    dotpro+=a[i]*b[i];
 487    d2+=pow(b[i]*ea[i],2)+pow(a[i]*eb[i],2);
 488   }
 489   fDresult=sqrt(d2);
 490  }
 491
 492  return dotpro;
 493 }
 494 ///////////////////////////////////////////////////////////////////////////
 495 Double_t Ali3Vector::GetResultError()
 496 {
 497 // Provide the error on the result of an operation yielding a scalar
 498 // E.g. GetNorm() or Dot()
 499  return fDresult;
 500 }
 501 ///////////////////////////////////////////////////////////////////////////
 502 Ali3Vector Ali3Vector::Cross(Ali3Vector& q)
 503 {
 504 // Provide the cross product of the current vector with vector q
 505 // Error propagation is performed automatically
 506  Double_t a[3],b[3],c[3];
 507  Double_t ea[3],eb[3],ec[3],d2;
 508
 509  GetVector(a,"car");
 510  GetErrors(ea,"car");
 511  q.GetVector(b,"car");
 512  q.GetErrors(eb,"car");
 513
 514  c[0]=a[1]*b[2]-a[2]*b[1];
 515  c[1]=a[2]*b[0]-a[0]*b[2];
 516  c[2]=a[0]*b[1]-a[1]*b[0];
 517
 518  d2=pow(b[2]*ea[1],2)+pow(a[1]*eb[2],2)
 519    +pow(b[1]*ea[2],2)+pow(a[2]*eb[1],2);
 520  ec[0]=sqrt(d2);
 521
 522  d2=pow(b[0]*ea[2],2)+pow(a[2]*eb[0],2)
 523    +pow(b[2]*ea[0],2)+pow(a[0]*eb[2],2);
 524  ec[1]=sqrt(d2);
 525
 526  d2=pow(b[1]*ea[0],2)+pow(a[0]*eb[1],2)
 527    +pow(b[0]*ea[1],2)+pow(a[1]*eb[0],2);
 528  ec[2]=sqrt(d2);
 529
 530  Ali3Vector v;
 531  v.SetVector(c,"car");
 532  v.SetErrors(ec,"car");
 533
 534  return v;
 535 }
 536 ///////////////////////////////////////////////////////////////////////////
 537 Ali3Vector Ali3Vector::operator+(Ali3Vector& q)
 538 {
 539 // Add vector q to the current vector
 540 // Error propagation is performed automatically
 541  Double_t a[3],b[3],ea[3],eb[3];
 542
 543  GetVector(a,"car");
 544  GetErrors(ea,"car");
 545  q.GetVector(b,"car");
 546  q.GetErrors(eb,"car");
 547
 548  for (Int_t i=0; i<3; i++)
 549  {
 550   a[i]+=b[i];
 551   ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
 552  }
 553
 554  Ali3Vector v;
 555  v.SetVector(a,"car");
 556  v.SetErrors(ea,"car");
 557
 558  return v;
 559 }
 560 ///////////////////////////////////////////////////////////////////////////
 561 Ali3Vector Ali3Vector::operator-(Ali3Vector& q)
 562 {
 563 // Subtract vector q from the current vector
 564 // Error propagation is performed automatically
 565  Double_t a[3],b[3],ea[3],eb[3];
 566
 567  GetVector(a,"car");
 568  GetErrors(ea,"car");
 569  q.GetVector(b,"car");
 570  q.GetErrors(eb,"car");
 571
 572  for (Int_t i=0; i<3; i++)
 573  {
 574   a[i]-=b[i];
 575   ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
 576  }
 577
 578  Ali3Vector v;
 579  v.SetVector(a,"car");
 580  v.SetErrors(ea,"car");
 581
 582  return v;
 583 }
 584 ///////////////////////////////////////////////////////////////////////////
 585 Ali3Vector Ali3Vector::operator*(Double_t s)
 586 {
 587 // Multiply the current vector with a scalar s.
 588 // Error propagation is performed automatically.
 589  Double_t a[3],ea[3];
 590
 591  GetVector(a,"car");
 592  GetErrors(ea,"car");
 593
 594  for (Int_t i=0; i<3; i++)
 595  {
 596   a[i]*=s;
 597   ea[i]*=s;
 598  }
 599
 600  Ali3Vector v;
 601  v.SetVector(a,"car");
 602  v.SetErrors(ea,"car");
 603
 604  return v;
 605 }
 606 ///////////////////////////////////////////////////////////////////////////
 607 Ali3Vector Ali3Vector::operator/(Double_t s)
 608 {
 609 // Divide the current vector by a scalar s
 610 // Error propagation is performed automatically
 611
 612  if (fabs(s)<1.e-20) // Protect against division by 0
 613  {
 614   cout << " *Ali3Vector::/* Division by 0 detected. No action taken." << endl;
 615   return *this;
 616  }
 617  else
 618  {
 619   Double_t a[3],ea[3];
 620
 621   GetVector(a,"car");
 622   GetErrors(ea,"car");
 623
 624   for (Int_t i=0; i<3; i++)
 625   {
 626    a[i]/=s;
 627    ea[i]/=s;
 628   }
 629
 630   Ali3Vector v;
 631   v.SetVector(a,"car");
 632   v.SetErrors(ea,"car");
 633
 634   return v;
 635  }
 636 }
 637 ///////////////////////////////////////////////////////////////////////////
 638 Ali3Vector& Ali3Vector::operator+=(Ali3Vector& q)
 639 {
 640 // Add vector q to the current vector
 641 // Error propagation is performed automatically
 642  Double_t a[3],b[3],ea[3],eb[3];
 643
 644  GetVector(a,"car");
 645  GetErrors(ea,"car");
 646  q.GetVector(b,"car");
 647  q.GetErrors(eb,"car");
 648
 649  for (Int_t i=0; i<3; i++)
 650  {
 651   a[i]+=b[i];
 652   ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
 653  }
 654
 655  SetVector(a,"car");
 656  SetErrors(ea,"car");
 657
 658  return *this;
 659 }
 660 ///////////////////////////////////////////////////////////////////////////
 661 Ali3Vector& Ali3Vector::operator-=(Ali3Vector& q)
 662 {
 663 // Subtract vector q from the current vector
 664 // Error propagation is performed automatically
 665  Double_t a[3],b[3],ea[3],eb[3];
 666
 667  GetVector(a,"car");
 668  GetErrors(ea,"car");
 669  q.GetVector(b,"car");
 670  q.GetErrors(eb,"car");
 671
 672  for (Int_t i=0; i<3; i++)
 673  {
 674   a[i]-=b[i];
 675   ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
 676  }
 677
 678  SetVector(a,"car");
 679  SetErrors(ea,"car");
 680
 681  return *this;
 682 }
 683 ///////////////////////////////////////////////////////////////////////////
 684 Ali3Vector& Ali3Vector::operator*=(Double_t s)
 685 {
 686 // Multiply the current vector with a scalar s
 687 // Error propagation is performed automatically
 688  Double_t a[3],ea[3];
 689
 690  GetVector(a,"car");
 691  GetErrors(ea,"car");
 692
 693  for (Int_t i=0; i<3; i++)
 694  {
 695   a[i]*=s;
 696   ea[i]*=s;
 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 // Divide the current vector by a scalar s
 708 // Error propagation is performed automatically
 709
 710  if (fabs(s)<1.e-20) // Protect against division by 0
 711  {
 712   cout << " *Ali3Vector::/=* Division by 0 detected. No action taken." << endl;
 713   return *this;
 714  }
 715  else
 716  {
 717   Double_t a[3],ea[3];
 718
 719   GetVector(a,"car");
 720   GetErrors(ea,"car");
 721
 722   for (Int_t i=0; i<3; i++)
 723   {
 724    a[i]/=s;
 725    ea[i]/=s;
 726   }
 727
 728   SetVector(a,"car");
 729   SetErrors(ea,"car");
 730
 731   return *this;
 732  }
 733 }
 734 ///////////////////////////////////////////////////////////////////////////
 735 Ali3Vector Ali3Vector::GetVecTrans()
 736 {
 737 // Provide the transverse vector w.r.t. z-axis.
 738 // Error propagation is performed automatically
 739  Double_t pi=acos(-1.);
 740  Double_t a[3],ea[3];
 741
 742  GetVector(a,"sph");
 743  GetErrors(ea,"sph");
 744
 745  Double_t vt,dvt2;
 746  vt=a[0]*sin(a[1]);
 747  dvt2=pow((sin(a[1])*ea[0]),2)+pow((a[0]*cos(a[1])*ea[1]),2);
 748
 749  a[0]=fabs(vt);
 750  a[1]=pi/2.;
 751
 752  ea[0]=sqrt(dvt2);
 753  ea[1]=0;
 754
 755  Ali3Vector v;
 756  v.SetVector(a,"sph");
 757  v.SetErrors(ea,"sph");
 758
 759  return v;
 760 }
 761 ///////////////////////////////////////////////////////////////////////////
 762 Ali3Vector Ali3Vector::GetVecLong()
 763 {
 764 // Provide the longitudinal vector w.r.t. z-axis.
 765 // Error propagation is performed automatically
 766  Double_t pi=acos(-1.);
 767  Double_t a[3],ea[3];
 768
 769  GetVector(a,"sph");
 770  GetErrors(ea,"sph");
 771
 772  Double_t vl,dvl2;
 773  vl=a[0]*cos(a[1]);
 774  dvl2=pow((cos(a[1])*ea[0]),2)+pow((a[0]*sin(a[1])*ea[1]),2);
 775
 776  a[0]=fabs(vl);
 777  a[1]=0;
 778  if (vl<0) a[1]=pi;
 779  a[2]=0;
 780
 781  ea[0]=sqrt(dvl2);
 782  ea[1]=0;
 783  ea[2]=0;
 784
 785  Ali3Vector v;
 786  v.SetVector(a,"sph");
 787  v.SetErrors(ea,"sph");
 788
 789  return v;
 790 }
 791 ///////////////////////////////////////////////////////////////////////////