21-jun-2005 NvE Install scripts for gcc corrected to also include the rdmc stuff
[u/mrichter/AliRoot.git] / RALICE / AliHelix.cxx
CommitLineData
c5555bc0 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
147ClassImp(AliHelix) // Class implementation to enable ROOT I/O
148
149AliHelix::AliHelix() : THelix()
150{
151// Default constructor
152 fRefresh=0;
153 fCurves=0;
154 fExt=0;
155 fTofmax=1e-8;
156}
157///////////////////////////////////////////////////////////////////////////
158AliHelix::~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///////////////////////////////////////////////////////////////////////////
173AliHelix::AliHelix(const AliHelix& h) : THelix(h)
174{
175// Copy constructor
176 fB=h.fB;
177 fRefresh=h.fRefresh;
178}
179///////////////////////////////////////////////////////////////////////////
180void 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///////////////////////////////////////////////////////////////////////////
193Ali3Vector& AliHelix::GetB()
194{
195// Provide the magnetic field vector in Tesla.
196 return fB;
197}
198///////////////////////////////////////////////////////////////////////////
199void 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///////////////////////////////////////////////////////////////////////////
212Float_t AliHelix::GetTofmax() const
213{
214// Provide the maximum time of flight for straight tracks in seconds.
215 return fTofmax;
216}
217///////////////////////////////////////////////////////////////////////////
218void 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");
7a086578 314 if (fabs(betavec[abs(iaxis)-1])/betanorm<1e-10) return;
c5555bc0 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;
7a086578 347 if (fabs(w)>0 && fabs(fVt)>0) bend=1;
c5555bc0 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;
7a086578 383 tmin=(range[0]-loc[abs(iaxis)-1])/velprim[abs(iaxis)-1];
384 tmax=(range[1]-loc[abs(iaxis)-1])/velprim[abs(iaxis)-1];
c5555bc0 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;
7a086578 420 if (fabs(fVz)>0) tmin=-fZ0/fVz;
c5555bc0 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;
7a086578 466 if (fabs(fVz)>0) tmin=-fZ0/fVz;
c5555bc0 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");
7a086578 490 if (fabs(fVz)>0) tmin=(vec1[2]-fZ0)/fVz;
c5555bc0 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");
7a086578 500 if (fabs(fVz)>0) tmax=(vec2[2]-fZ0)/fVz;
c5555bc0 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 {
7a086578 513 vec1[abs(iaxis)-1]=range[0];
514 vec2[abs(iaxis)-1]=range[1];
c5555bc0 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 {
7a086578 531 test=fabs(vec1[i]-vec2[i]);
c5555bc0 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///////////////////////////////////////////////////////////////////////////
588void 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///////////////////////////////////////////////////////////////////////////
661void 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
7a086578 673 if (abs(mode)<2) fRefresh=mode;
c5555bc0 674 if (fCurves) fCurves->Delete();
675}
676///////////////////////////////////////////////////////////////////////////
677void 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///////////////////////////////////////////////////////////////////////////
709AliPosition* 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];
7a086578 780 range[0]=pars[0]-fabs(pars[1])/2.;
781 range[1]=pars[0]+fabs(pars[1])/2.;
c5555bc0 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];
7a086578 802 err[0]=fabs(first[0]-last[0]);
803 err[1]=fabs(first[1]-last[1]);
804 err[2]=fabs(first[2]-last[2]);
c5555bc0 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///////////////////////////////////////////////////////////////////////////