RALICE/AliHelix.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 AliHelix
  20 // Representation and extrapolation of AliTracks in a magnetic field.
  21 //
  22 // This class is meant to provide a means to display and extrapolate
  23 // AliTrack objects in the presence of a constant homogeneous magnetic field.
  24 //
  25 // Examples :
  26 // ==========
  27 //
  28 // Display and extrapolation of individual tracks
  29 // ----------------------------------------------
  30 // Float_t vec[3];
  31 // AliPosition r1;
  32 // Ali3Vector p;
  33 // AliTrack t;
  34 //
  35 // vec[0]=0;
  36 // vec[1]=0;
  37 // vec[2]=0;
  38 // r1.SetVector(vec,"car");
  39 //
  40 // vec[0]=1;
  41 // vec[1]=0;
  42 // vec[2]=0.3;
  43 // p.SetVector(vec,"car");
  44 //
  45 // t.Set3Momentum(p);
  46 // t.SetBeginPoint(r1);
  47 // t.SetCharge(-1);
  48 // t.SetMass(0.139);
  49 //
  50 // // The magnetic field vector in Tesla
  51 // Ali3Vector b;
  52 // vec[0]=0;
  53 // vec[1]=0;
  54 // vec[2]=1;
  55 // b.SetVector(vec,"car");
  56 //
  57 // AliHelix* helix=new AliHelix();
  58 // helix->SetB(b);
  59 // helix->SetTofmax(1e-7);
  60 //
  61 // TCanvas* c1=new TCanvas("c1","c1");
  62 // TView* view=new TView(1);
  63 // view->SetRange(-1000,-1000,-1000,1000,1000,1000);
  64 // view->ShowAxis();
  65 //
  66 // // Track displays
  67 // Double_t range[2]={0,600};
  68 // helix->Display(&t,range,3);
  69 // t.SetCharge(-t.GetCharge());
  70 // helix->Display(&t);
  71 //
  72 // // Track extrapolation
  73 // Double_t pars[3]={550,0.001,3};
  74 // AliPosition* rext=helix->Extrapolate(&t,pars);
  75 // if (rext) rext->Data();
  76 // ======================================================================
  77 //
  78 // Online display of events generated via AliCollider
  79 // --------------------------------------------------
  80 // Int_t nevents=5;   // Number of events to be generated
  81 // Int_t jrun=1;      // The run number of this batch of generated events
  82 //
  83 // cout << " ***" << endl;
  84 // cout << " *** AliCollider run for " << nevents << " events." << endl;
  85 // cout << " ***" << endl;
  86 //
  87 // AliCollider* gen=new AliCollider();
  88 //
  89 // gen->OpenFortranFile(6,"dump.log");
  90 //
  91 // gen->SetVertexMode(2);
  92 // gen->SetResolution(1e-4);
  93 //
  94 // gen->SetRunNumber(jrun);
  95 // gen->SetPrintFreq(1);
  96 //
  97 // gen->SetSpectatorPmin(0.01);
  98 //
  99 // Int_t zp=1;
 100 // Int_t ap=1;
 101 // Int_t zt=2;
 102 // Int_t at=4;
 103 //
 104 // gen->Init("fixt",zp,ap,zt,at,158);
 105 //
 106 // AliHelix* helix=new AliHelix();
 107 // Float_t vec[3]={0,2,0};
 108 // Ali3Vector b;
 109 // b.SetVector(vec,"car");
 110 // helix->SetB(b);
 111 //
 112 // helix->Refresh(-1); // Refresh display after each event
 113 //
 114 // TCanvas* c1=new TCanvas("c1","c1");
 115 // TView* view=new TView(1);
 116 // view->SetRange(-200,-200,-200,200,200,200);
 117 // view->ShowAxis();
 118 //
 119 // // Prepare random number sequence for this run
 120 // // to obtain the number of participants for each event
 121 // AliRandom rndm(abs(jrun));
 122 // Float_t* rans=new Float_t[nevents];
 123 // rndm.Uniform(rans,nevents,2,ap+at);
 124 // Int_t npart=0;
 125 // Int_t ntk=0;
 126 // for (Int_t i=0; i<nevents; i++)
 127 // {
 128 //  npart=rans[i];
 129 //  gen->MakeEvent(npart);
 130 //  AliEvent* evt=gen->GetEvent();
 131 //  if (evt)
 132 //  {
 133 //   helix->Display(evt);
 134 //   c1->Update();
 135 //   gSystem->Sleep(5000); // Some delay to keep the display on screen
 136 //  }
 137 // }
 138 // ======================================================================
 139 //
 140 //--- Author: Nick van Eijndhoven 17-jun-2004 Utrecht University
 141 //- Modified: NvE $Date$ Utrecht University
 142 ///////////////////////////////////////////////////////////////////////////
 143
 144 #include "AliHelix.h"
 145 #include "Riostream.h"
 146
 147 ClassImp(AliHelix) // Class implementation to enable ROOT I/O
 148
 149 AliHelix::AliHelix() : THelix()
 150 {
 151 // Default constructor
 152  fRefresh=0;
 153  fCurves=0;
 154  fExt=0;
 155  fTofmax=1e-8;
 156 }
 157 ///////////////////////////////////////////////////////////////////////////
 158 AliHelix::~AliHelix()
 159 {
 160 // Destructor to delete dynamically allocated memory.
 161  if (fCurves)
 162  {
 163   delete fCurves;
 164   fCurves=0;
 165  }
 166  if (fExt)
 167  {
 168   delete fExt;
 169   fExt=0;
 170  }
 171 }
 172 ///////////////////////////////////////////////////////////////////////////
 173 AliHelix::AliHelix(const AliHelix& h) : THelix(h)
 174 {
 175 // Copy constructor
 176  fB=h.fB;
 177  fRefresh=h.fRefresh;
 178 }
 179 ///////////////////////////////////////////////////////////////////////////
 180 void AliHelix::SetB(Ali3Vector& b)
 181 {
 182 // Set the magnetic field vector in Tesla.
 183  fB=b;
 184
 185  if (fB.GetNorm()>0)
 186  {
 187   Double_t axis[3];
 188   fB.GetVector(axis,"car");
 189   SetAxis(axis);
 190  }
 191 }
 192 ///////////////////////////////////////////////////////////////////////////
 193 Ali3Vector& AliHelix::GetB()
 194 {
 195 // Provide the magnetic field vector in Tesla.
 196  return fB;
 197 }
 198 ///////////////////////////////////////////////////////////////////////////
 199 void AliHelix::SetTofmax(Float_t tof)
 200 {
 201 // Set the maximum time of flight for straight tracks in seconds.
 202 // This maximum tof will be used for drawing etc... in case no begin
 203 // and endpoints can be determined from the track info.
 204 // Notes :
 205 // -------
 206 // 1) In case the user specifies an explicit range, it will override
 207 //    the maximum tof limit.
 208 // 2) By default the tofmax is set to 10 ns in the AliHelix constructor.
 209  fTofmax=tof;
 210 }
 211 ///////////////////////////////////////////////////////////////////////////
 212 Float_t AliHelix::GetTofmax() const
 213 {
 214 // Provide the maximum time of flight for straight tracks in seconds.
 215  return fTofmax;
 216 }
 217 ///////////////////////////////////////////////////////////////////////////
 218 void AliHelix::MakeCurve(AliTrack* t,Double_t* range,Int_t iaxis,Double_t scale)
 219 {
 220 // Make the helix curve for the specified AliTrack.
 221 // Detailed information of all the helix points can be obtained via the
 222 // GetN() and GetP() memberfunctions of TPolyLine3D.
 223 // In case one wants to display or extrapolate an AliTrack it is preferable
 224 // to use the Display() or Extrapolate() memberfunctions.
 225 // It is assumed that the track charge is stored in elementary units
 226 // (i.e. charge=1 for a proton) and that the track energy is stored in GeV.
 227 // The input argument "scale" specifies the unit scale for the various
 228 // locations where scale=0.01 indicates unit scales in cm etc...
 229 // In case scale<=0, the unit scale for locations is determined from the
 230 // begin, reference or endpoint of the track. If neither of these
 231 // positions is present, all locations are assumed to be given in cm.
 232 // The lower and upper bounds for the range are specified by range[0] and
 233 // range[1] and the argument "iaxis" indicates along which axis this range
 234 // is specified.
 235 // The range can be specified either in the LAB frame or in the Helix frame.
 236 // The latter is the frame in which the Z axis points in the B direction.
 237 //
 238 // The conventions for the "iaxis" argument are the following :
 239 // iaxis = 1 ==> X axis in the LAB frame
 240 //         2 ==> Y axis in the LAB frame
 241 //         3 ==> Z axis in the LAB frame
 242 //        -1 ==> X axis in the Helix frame
 243 //        -2 ==> Y axis in the Helix frame
 244 //        -3 ==> Z axis in the Helix frame
 245 //
 246 // In case range=0 the begin/end/reference points of the AliTrack and the
 247 // maximum time of flight (see the SetTofmax() memberfunction) will be used
 248 // and an appropriate choice for the iaxis parameter will be made automatically
 249 // based on the track kinematics.
 250 // In case the reference point is not present, the begin or endpoint will be used
 251 // as reference point for the 3-momentum specification. If neither of these positions
 252 // is present, (0,0,0) will be taken as the reference point.
 253 //
 254 // The default values are range=0, iaxis=3 and scale=-1.
 255
 256  SetPolyLine(0); // Reset the polyline data points
 257
 258  if (!t || (range && !iaxis)) return;
 259
 260  Double_t energy=t->GetEnergy();
 261  Double_t betanorm=t->GetBeta();
 262
 263  if (energy<=0 || betanorm<=0) return;
 264
 265  AliPosition* rbeg=t->GetBeginPoint();
 266  AliPosition* rend=t->GetEndPoint();
 267  AliPosition* rref=t->GetReferencePoint();
 268
 269  // Magnetic field vector or default Z-direction
 270  Double_t bvec[3]={0,0,1};
 271  if (fB.GetNorm()>0) fB.GetVector(bvec,"car");
 272
 273  // The unit scale for locations if not specified by the user
 274  if (scale<=0)
 275  {
 276   scale=0.01; // Set default to cm
 277   if (rbeg)
 278   {
 279    scale=rbeg->GetUnitScale();
 280   }
 281   else if (rend)
 282   {
 283    scale=rend->GetUnitScale();
 284   }
 285   else if (rref)
 286   {
 287    scale=rref->GetUnitScale();
 288   }
 289  }
 290
 291  Double_t c=2.99792458e8/scale; // Lightspeed in the selected unit scale
 292
 293  // The helix angular frequency
 294  Double_t w=9e7*(t->GetCharge()*fB.GetNorm())/energy;
 295
 296  // The particle velocity in the LAB frame
 297  Ali3Vector beta=t->GetBetaVector();
 298  Ali3Vector v=beta*c;
 299  Double_t vel[3];
 300  v.GetVector(vel,"car");
 301
 302  // The particle velocity in the Helix frame
 303  Ali3Vector betaprim=beta.GetPrimed(fRotMat);
 304  v=v.GetPrimed(fRotMat);
 305  Double_t velprim[3];
 306  v.GetVector(velprim,"car");
 307
 308  // Check compatibility of velocity and range specification.
 309  if (range)
 310  {
 311   Double_t betavec[3];
 312   if (iaxis>0) beta.GetVector(betavec,"car");
 313   if (iaxis<0) betaprim.GetVector(betavec,"car");
 314   if (fabs(betavec[abs(iaxis)-1])/betanorm<1e-10) return;
 315  }
 316
 317  // The LAB location in which the velocity of the particle is defined
 318  Double_t loc[3]={0,0,0};
 319  Ali3Vector* rx=0;
 320  Double_t scalex=0;
 321  if (rref)
 322  {
 323   rx=(Ali3Vector*)rref;
 324   scalex=rref->GetUnitScale();
 325  }
 326  else if (rbeg)
 327  {
 328   rx=(Ali3Vector*)rbeg;
 329   scalex=rbeg->GetUnitScale();
 330  }
 331  else if (rend)
 332  {
 333   rx=(Ali3Vector*)rend;
 334   scalex=rend->GetUnitScale();
 335  }
 336
 337  if (rx)
 338  {
 339   if (scalex/scale>1.1 || scale/scalex>1.1) (*rx)*=scalex/scale;
 340   rx->GetVector(loc,"car");
 341  }
 342
 343  // Initialisation of Helix kinematics
 344  SetHelix(loc,vel,w,0,kUnchanged,bvec);
 345
 346  Int_t bend=0;
 347  if (fabs(w)>0 && fabs(fVt)>0) bend=1;
 348
 349  // Flight time boundaries.
 350  // The time origin t=0 is chosen to indicate the position in which
 351  // the particle velocity was defined.
 352  // The total flight time is initialised to the (user specified) tofmax.
 353  Double_t tmin=0,tmax=0;
 354  Double_t tof=fTofmax;
 355  Double_t dum=0;
 356
 357  // The trajectory begin and end points
 358  Double_t vec1[3]={0,0,0};
 359  Double_t vec2[3]={0,0,0};
 360  Ali3Vector r1;
 361  Ali3Vector r2;
 362  Double_t scale1=0.01;
 363  Double_t scale2=0.01;
 364
 365  if (!bend)
 366  {
 367   ////////////////////////////////////////
 368   // Treatment of straight trajectories //
 369   ////////////////////////////////////////
 370   Ali3Vector r;
 371   if (range) // Specified range allows for exact flight time boundaries
 372   {
 373    if (iaxis>0)
 374    {
 375     tmin=(range[0]-loc[iaxis-1])/vel[iaxis-1];
 376     tmax=(range[1]-loc[iaxis-1])/vel[iaxis-1];
 377    }
 378    else
 379    {
 380     loc[0]=fX0;
 381     loc[1]=fY0;
 382     loc[2]=fZ0;
 383     tmin=(range[0]-loc[abs(iaxis)-1])/velprim[abs(iaxis)-1];
 384     tmax=(range[1]-loc[abs(iaxis)-1])/velprim[abs(iaxis)-1];
 385    }
 386    if (tmax<tmin)
 387    {
 388     dum=tmin;
 389     tmin=tmax;
 390     tmax=dum;
 391    }
 392    // Make the 'curve' in the LAB frame and exit.
 393    // Use the parametrisation : r(t)=r0+t*v
 394    // using the range based flight time boundaries.
 395    // An additional point in the middle of the trajectory is
 396    // generated in view of accuracy in the case of extrapolations.
 397    tof=tmax-tmin;
 398    v=beta*c;
 399    if (rx) r1=(*rx);
 400    r=v*tmin;
 401    r1=r1+r;
 402    r1.GetVector(vec1,"car");
 403    SetNextPoint(float(vec1[0]),float(vec1[1]),float(vec1[2]));
 404    r=v*(tof/2.);
 405    r2=r1+r;
 406    r2.GetVector(vec2,"car");
 407    SetNextPoint(float(vec2[0]),float(vec2[1]),float(vec2[2]));
 408    r=v*tof;
 409    r2=r1+r;
 410    r2.GetVector(vec2,"car");
 411    SetNextPoint(float(vec2[0]),float(vec2[1]),float(vec2[2]));
 412   }
 413   else // Automatic range determination
 414   {
 415    // Initially the point with Z=0 in the Helix frame is taken as a starting point.
 416    // In case this point can't be reached, the point in which the particle velocity
 417    // was defined is taken as the starting point.
 418    // The endpoint is initially obtained by applying the tofmax from the start point.
 419    tmin=0;
 420    if (fabs(fVz)>0) tmin=-fZ0/fVz;
 421    v=beta*c;
 422    if (rx) r1=(*rx);
 423    r=v*tmin;
 424    r1=r1+r;
 425
 426    // Override the initial begin and endpoint settings by the track data
 427    if (rbeg)
 428    {
 429     r1=(Ali3Vector)(*rbeg);
 430     scale1=rbeg->GetUnitScale();
 431     // All coordinates in the selected unit scale
 432     if (scale1/scale>1.1 || scale/scale1>1.1) r1*=scale1/scale;
 433    }
 434
 435    r=v*fTofmax;
 436    r2=r1+r;
 437    if (rend)
 438    {
 439     r2=(Ali3Vector)(*rend);
 440     scale2=rend->GetUnitScale();
 441     // All coordinates in the selected unit scale
 442     if (scale2/scale>1.1 || scale/scale2>1.1) r2*=scale2/scale;
 443    }
 444
 445    r1.GetVector(vec1,"car");
 446    r2.GetVector(vec2,"car");
 447
 448    // Make the 'curve' in the LAB frame and exit.
 449    SetNextPoint(float(vec1[0]),float(vec1[1]),float(vec1[2]));
 450    SetNextPoint(float(vec2[0]),float(vec2[1]),float(vec2[2]));
 451   }
 452  }
 453  else
 454  {
 455   //////////////////////////////////////
 456   // Treatment of curved trajectories //
 457   //////////////////////////////////////
 458
 459   // Initialisation of the flight time boundaries.
 460   // Based on the constant motion of the particle along the Helix Z-axis,
 461   // the parametrisation z(t)=z0+fVz*t in the Helix frame is used.
 462   // If possible the point with Z=0 in the Helix frame is taken as a starting point.
 463   // In case this point can't be reached, the point in which the particle velocity
 464   // was defined is taken as the starting point.
 465   tmin=0;
 466   if (fabs(fVz)>0) tmin=-fZ0/fVz;
 467   tmax=tmin+fTofmax;
 468
 469   if (tmax<tmin)
 470   {
 471    dum=tmin;
 472    tmin=tmax;
 473    tmax=dum;
 474   }
 475
 476   // Determination of the range in the helix frame
 477
 478   if (!range) // Automatic range determination
 479   {
 480    scale1=0.01;
 481    scale2=0.01;
 482    if (rbeg)
 483    {
 484     r1=rbeg->GetPrimed(fRotMat);
 485     scale1=rbeg->GetUnitScale();
 486     // All coordinates in the selected unit scale
 487     if (scale1/scale>1.1 || scale/scale1>1.1) r1*=scale1/scale;
 488     // Re-calculate the tmin for this new starting point
 489     r1.GetVector(vec1,"car");
 490     if (fabs(fVz)>0) tmin=(vec1[2]-fZ0)/fVz;
 491     tmax=tmin+fTofmax;
 492    }
 493    if (rend)
 494    {
 495     r2=rend->GetPrimed(fRotMat);
 496     scale2=rend->GetUnitScale();
 497     // All coordinates in the selected unit scale
 498     if (scale2/scale>1.1 || scale/scale2>1.1) r2*=scale2/scale;
 499     r2.GetVector(vec2,"car");
 500     if (fabs(fVz)>0) tmax=(vec2[2]-fZ0)/fVz;
 501    }
 502    // Make the curve on basis of the flight time boundaries and exit
 503    if (tmax<tmin)
 504    {
 505     dum=tmin;
 506     tmin=tmax;
 507     tmax=dum;
 508    }
 509    SetRange(tmin,tmax,kHelixT);
 510   }
 511   else // User explicitly specified range
 512   {
 513    vec1[abs(iaxis)-1]=range[0];
 514    vec2[abs(iaxis)-1]=range[1];
 515    r1.SetVector(vec1,"car");
 516    r2.SetVector(vec2,"car");
 517    if (iaxis>0) // Range specified in LAB frame
 518    {
 519     r1=r1.GetPrimed(fRotMat);
 520     r1.GetVector(vec1,"car");
 521     r2=r2.GetPrimed(fRotMat);
 522     r2.GetVector(vec2,"car");
 523    }
 524    // Determination of the axis component with the
 525    // largest range difference
 526    Double_t dmax=0;
 527    Int_t imax=0;
 528    Double_t test=0;
 529    for (Int_t i=0; i<3; i++)
 530    {
 531     test=fabs(vec1[i]-vec2[i]);
 532     if (test>dmax)
 533     {
 534      dmax=test;
 535      imax=i;
 536     }
 537    }
 538
 539    Double_t rmin=vec1[imax];
 540    Double_t rmax=vec2[imax];
 541    if (rmax<rmin)
 542    {
 543     dum=rmin;
 544     rmin=rmax;
 545     rmax=dum;
 546    }
 547
 548    // The kinematic range boundaries in the helix frame
 549    Double_t xmin=fX0-fVt/fW;
 550    Double_t xmax=fX0+fVt/fW;
 551    Double_t ymin=fY0-fVt/fW;
 552    Double_t ymax=fY0+fVt/fW;
 553
 554    if (xmax<xmin)
 555    {
 556     dum=xmin;
 557     xmin=xmax;
 558     xmax=dum;
 559    }
 560    if (ymax<ymin)
 561    {
 562     dum=ymin;
 563     ymin=ymax;
 564     ymax=dum;
 565    }
 566
 567    // Set the range for the helix
 568    if (imax==2 && dmax>0) SetRange(rmin,rmax,kHelixZ);
 569    if (imax==1)
 570    {
 571     // Limit range to kinematic boundaries if needed
 572     if (rmin<=ymin) rmin=ymin+1e-6*dmax;
 573     if (rmax>=ymax) rmax=ymax-1e-6*dmax;
 574     if (rmin<rmax) SetRange(rmin,rmax,kHelixY);
 575    }
 576    if (imax==0)
 577    {
 578     // Limit range to kinematic boundaries if needed
 579     if (rmin<=xmin) rmin=xmin+1e-6*dmax;
 580     if (rmax>=xmax) rmax=xmax-1e-6*dmax;
 581     if (rmin<rmax) SetRange(rmin,rmax,kHelixX);
 582    }
 583   }
 584  }
 585  return;
 586 }
 587 ///////////////////////////////////////////////////////////////////////////
 588 void AliHelix::Display(AliTrack* t,Double_t* range,Int_t iaxis,Double_t scale)
 589 {
 590 // Display the helix curve of an AliTrack.
 591 // Various curves can be displayed together or individually; please refer to
 592 // the memberfunction Refresh() for further details.
 593 // It is assumed that the track charge is stored in elementary units
 594 // (i.e. charge=1 for a proton) and that the track energy is stored in GeV.
 595 // The input argument "scale" specifies the unit scale for the various
 596 // locations where scale=0.01 indicates unit scales in cm etc...
 597 // In case scale<=0, the unit scale for locations is determined from the
 598 // begin, reference or endpoint of the track. If neither of these
 599 // positions is present, all locations are assumed to be given in cm.
 600 // The lower and upper bounds for the range are specified by range[0] and
 601 // range[1] and the argument "iaxis" indicates along which axis this range
 602 // is specified.
 603 // The range can be specified either in the LAB frame or in the Helix frame.
 604 // The latter is the frame in which the Z axis points in the B direction.
 605 //
 606 // The conventions for the "iaxis" argument are the following :
 607 // iaxis = 1 ==> X axis in the LAB frame
 608 //         2 ==> Y axis in the LAB frame
 609 //         3 ==> Z axis in the LAB frame
 610 //        -1 ==> X axis in the Helix frame
 611 //        -2 ==> Y axis in the Helix frame
 612 //        -3 ==> Z axis in the Helix frame
 613 //
 614 // In case range=0 the begin/end/reference points of the AliTrack and the
 615 // maximum time of flight (see the SetTofmax() memberfunction) will be used
 616 // and an appropriate choice for the iaxis parameter will be made automatically
 617 // based on the track kinematics.
 618 // In case the reference point is not present, the begin or endpoint will be used
 619 // as reference point for the 3-momentum specification. If neither of these positions
 620 // is present, (0,0,0) will be taken as the reference point.
 621 //
 622 // The default values are range=0, iaxis=3 and scale=-1.
 623 //
 624 // Note :
 625 // ------
 626 // Before any display activity, a TCanvas and a TView have to be initiated
 627 // first by the user like for instance
 628 //
 629 // TCanvas* c1=new TCanvas("c1","c1");
 630 // TView* view=new TView(1);
 631 // view->SetRange(-1000,-1000,-1000,1000,1000,1000);
 632 // view->ShowAxis();
 633
 634  if (!t || (range && !iaxis)) return;
 635
 636  MakeCurve(t,range,iaxis,scale);
 637
 638  if (fRefresh>0) Refresh(fRefresh);
 639
 640  Int_t np=GetN();
 641  if (!np) return;
 642
 643  Float_t* points=GetP();
 644  TPolyLine3D* curve=new TPolyLine3D(np,points);
 645
 646  curve->SetLineWidth(2);
 647  Float_t q=t->GetCharge();
 648  curve->SetLineColor(kGreen);
 649  if (q>0) curve->SetLineColor(kRed);
 650  if (q<0) curve->SetLineColor(kBlue);
 651  curve->Draw();
 652
 653  if (!fCurves)
 654  {
 655   fCurves=new TObjArray();
 656   fCurves->SetOwner();
 657  }
 658  fCurves->Add(curve);
 659 }
 660 ///////////////////////////////////////////////////////////////////////////
 661 void AliHelix::Refresh(Int_t mode)
 662 {
 663 // Refresh the display screen before showing the next curve.
 664 //
 665 // mode = 0 : refreshing fully under user control.
 666 //        1 : the display screen will be refreshed automatically
 667 //            at each individual track display.
 668 //       -1 : the display screen will be refreshed automatically
 669 //            at each event display.
 670 //
 671 // The default is mode=0.
 672
 673  if (abs(mode)<2) fRefresh=mode;
 674  if (fCurves) fCurves->Delete();
 675 }
 676 ///////////////////////////////////////////////////////////////////////////
 677 void AliHelix::Display(AliEvent* evt,Double_t* range,Int_t iaxis,Double_t scale)
 678 {
 679 // Display the helix curves of all tracks of the specified event.
 680 // Various events can be displayed together or individually; please refer to
 681 // the memberfunction Refresh() for further details.
 682 // Please refer to the track display memberfunction for further details
 683 // on the input arguments.
 684 //
 685 // The default values are range=0, iaxis=3 and scale=-1.
 686 //
 687 // Note :
 688 // ------
 689 // Before any display activity, a TCanvas and a TView have to be initiated
 690 // first by the user like for instance
 691 //
 692 // TCanvas* c1=new TCanvas("c1","c1");
 693 // TView* view=new TView(1);
 694 // view->SetRange(-1000,-1000,-1000,1000,1000,1000);
 695 // view->ShowAxis();
 696
 697  if (!evt) return;
 698
 699  if (fRefresh<0) Refresh(fRefresh);
 700
 701  Int_t ntk=evt->GetNtracks();
 702  for (Int_t jtk=1; jtk<=ntk; jtk++)
 703  {
 704   AliTrack* tx=evt->GetTrack(jtk);
 705   if (tx) Display(tx,range,iaxis,scale);
 706  }
 707 }
 708 ///////////////////////////////////////////////////////////////////////////
 709 AliPosition* AliHelix::Extrapolate(AliTrack* t,Double_t* pars,Double_t scale)
 710 {
 711 // Extrapolate an AliTrack according to the corresponding helix curve
 712 // and provide a pointer to the impact position w.r.t. a specified plane.
 713 // In case the track can never reach the specified plane, the returned
 714 // position pointer is zero.
 715 // Detailed information of all the helix points used in the extrapolation
 716 // can be obtained via the GetN() and GetP() memberfunctions of TPolyLine3D.
 717 // It is assumed that the track charge is stored in elementary units
 718 // (i.e. charge=1 for a proton) and that the track energy is stored in GeV.
 719 // The input argument "scale" specifies the unit scale for the various
 720 // locations where scale=0.01 indicates unit scales in cm etc...
 721 // In case scale<=0, the unit scale for locations is determined from the
 722 // begin, reference or endpoint of the track. If neither of these
 723 // positions is present, all locations are assumed to be given in cm.
 724 // The extrapolation parameters for the impact plane and required accuracy
 725 // are specified by pars[0], pars[1] and pars[2], respectively.
 726 // pars[0] = coordinate value of the plane for the impact point
 727 // pars[1] = required accuracy on the specified impact plane coordinate
 728 // pars[2] = the axis along which the value of par[0] is specified
 729 //
 730 // The parameters can be specified either w.r.t. the LAB frame or the Helix frame.
 731 // The latter is the frame in which the Z axis points in the B direction.
 732 //
 733 // The conventions for the par[2] argument are the following :
 734 // par[2] = 1 ==> X axis in the LAB frame
 735 //          2 ==> Y axis in the LAB frame
 736 //          3 ==> Z axis in the LAB frame
 737 //         -1 ==> X axis in the Helix frame
 738 //         -2 ==> Y axis in the Helix frame
 739 //         -3 ==> Z axis in the Helix frame
 740 //
 741 // Example :
 742 // ---------
 743 // To obtain an extrapolation to the plane Z=0 in the LAB frame
 744 // with an accuracy of 0.001 cm the input arguments would be
 745 // pars[0]=0  pars[1]=0.001  pars[2]=3  scale=0.01
 746 //
 747 // Note : The default value for the scale is -1.
 748
 749  if (fExt)
 750  {
 751   delete fExt;
 752   fExt=0;
 753  }
 754
 755  if (!t || !pars) return fExt;
 756
 757  AliPosition* rbeg=t->GetBeginPoint();
 758  AliPosition* rend=t->GetEndPoint();
 759  AliPosition* rref=t->GetReferencePoint();
 760
 761  // The unit scale for locations if not specified by the user
 762  if (scale<=0)
 763  {
 764   scale=0.01; // Set default to cm
 765   if (rbeg)
 766   {
 767    scale=rbeg->GetUnitScale();
 768   }
 769   else if (rend)
 770   {
 771    scale=rend->GetUnitScale();
 772   }
 773   else if (rref)
 774   {
 775    scale=rref->GetUnitScale();
 776   }
 777  }
 778
 779  Double_t range[2];
 780  range[0]=pars[0]-fabs(pars[1])/2.;
 781  range[1]=pars[0]+fabs(pars[1])/2.;
 782
 783  Int_t iaxis=int(pars[2]);
 784
 785  MakeCurve(t,range,iaxis,scale);
 786
 787  Int_t np=GetN();
 788  if (!np) return fExt;
 789
 790  Float_t* points=GetP();
 791
 792  // First point of the curve around the impact
 793  Int_t ip=0;
 794  Float_t first[3]={points[3*ip],points[3*ip+1],points[3*ip+2]};
 795
 796  // Last point of the curve around the impact
 797  ip=np-1;
 798  Float_t last[3]={points[3*ip],points[3*ip+1],points[3*ip+2]};
 799
 800  // The accuracy on the impact point
 801  Float_t err[3];
 802  err[0]=fabs(first[0]-last[0]);
 803  err[1]=fabs(first[1]-last[1]);
 804  err[2]=fabs(first[2]-last[2]);
 805
 806  // Take the middle point as impact location
 807  ip=np/2;
 808  Float_t imp[3]={points[3*ip],points[3*ip+1],points[3*ip+2]};
 809
 810  fExt=new AliPosition();
 811  fExt->SetUnitScale(scale);
 812  fExt->SetPosition(imp,"car");
 813  fExt->SetPositionErrors(err,"car");
 814
 815  return fExt;
 816 }
 817 ///////////////////////////////////////////////////////////////////////////