09-jul-2001 NvE Support for impact points and user identifier introduced in AliTrack.
[u/mrichter/AliRoot.git] / RALICE / AliTrack.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 AliTrack
20 // Handling of the attributes of a reconstructed particle track.
21 //
22 // Coding example :
23 // ----------------
24 //
25 // Float_t a[4]={195.,1.2,-0.04,8.5};
26 // Ali4Vector pmu;
27 // pmu.SetVector(a,"car");
28 // AliTrack t1;
29 // t1.Set4Momentum(pmu);
30 //
31 // Float_t b[3]={1.2,-0.04,8.5};
32 // Ali3Vector p;
33 // p.SetVector(b,"car");
34 // AliTrack t2;
35 // t2.Set3Momentum(p);
36 // t2.SetCharge(0);
37 // t2.SetMass(1.115);
38 //
39 // t1.Info();
40 // t2.Info();
41 //
42 // Float_t pi=acos(-1.);
43 // Float_t thcms=0.2*pi; // decay theta angle in cms
44 // Float_t phicms=pi/4.; // decay theta angle in cms
45 // Float_t m1=0.938;
46 // Float_t m2=0.140;
47 // t2.Decay(m1,m2,thcms,phicms); // Track t2 decay : Lambda -> proton + pion
48 //
49 // t2.List();
50 //
51 // Int_t ndec=t2.GetNdecay();
52 // AliTrack* d1=t2.GetDecayTrack(1); // Access to decay track number 1
53 // AliTrack* d2=t2.GetDecayTrack(2); // Access to decay track number 2
54 //
55 // AliSignal s1,s2,s3,s4;
56 //
57 // .... // Code (e.g. detector readout) to fill AliSignal data
58 //
59 // AliTrack trec; // Track which will be reconstructed from signals
60 // trec.AddSignal(s1);
61 // trec.AddSignal(s3);
62 // trec.AddSignal(s4);
63 //
64 // Ali3Vector P;
65 // Float_t Q,M;
66 //
67 // ... // Code which accesses signals from trec and reconstructs
68 //        3-momentum P, charge Q, mass M etc...
69 //
70 // trec.Set3Momentum(P);
71 // trec.SetCharge(Q);
72 // trec.SetMass(M);
73 //
74 // Float_t r1[3]={1.6,-3.8,25.7};
75 // Float_t er1[3]={0.2,0.5,1.8};
76 // Float_t r2[3]={8.6,23.8,-6.7};
77 // Float_t er2[3]={0.93,1.78,0.8};
78 // AliPosition begin,end;
79 // begin.SetPosition(r1,"car");
80 // begin.SetPositionErrors(er1,"car");
81 // end.SetPosition(r2,"car");
82 // end.SetPositionErrors(er2,"car");
83 // trec.SetBeginPoint(begin);
84 // trec.SetEndPoint(end);
85 // 
86 // Note : All quantities are in GeV, GeV/c or GeV/c**2
87 //
88 //--- Author: Nick van Eijndhoven 10-jul-1997 UU-SAP Utrecht
89 //- Modified: NvE $Date$ UU-SAP Utrecht
90 ///////////////////////////////////////////////////////////////////////////
91
92 #include "AliTrack.h"
93  
94 ClassImp(AliTrack) // Class implementation to enable ROOT I/O
95  
96 AliTrack::AliTrack()
97 {
98 // Default constructor
99 // All variables initialised to 0
100  fDecays=0;
101  fSignals=0;
102  fMasses=0;
103  fDmasses=0;
104  fPmasses=0;
105  Reset();
106 }
107 ///////////////////////////////////////////////////////////////////////////
108 AliTrack::~AliTrack()
109 {
110 // Destructor to delete memory allocated for decay tracks array
111  if (fDecays)
112  {
113   fDecays->Delete();
114   delete fDecays;
115   fDecays=0;
116  }
117  if (fSignals)
118  {
119   fSignals->Clear();
120   delete fSignals;
121   fSignals=0;
122  }
123 }
124 ///////////////////////////////////////////////////////////////////////////
125 void AliTrack::Reset()
126 {
127 // Reset all variables to 0 and delete all auto-generated decay tracks.
128  fQ=0;
129  fUserId=0;
130  fNdec=0;
131  fNsig=0;
132  fNmasses=0;
133  Double_t a[4]={0,0,0,0};
134  SetVector(a,"sph");
135  if (fDecays)
136  {
137   fDecays->Delete();
138   delete fDecays;
139   fDecays=0;
140  }
141  if (fSignals)
142  {
143   fSignals->Clear();
144   delete fSignals;
145   fSignals=0;
146  }
147  Double_t b[3]={0,0,0};
148  fBegin.SetPosition(b,"sph");
149  fEnd.SetPosition(b,"sph");
150  fImpactXY.SetPosition(b,"sph");
151  fImpactXZ.SetPosition(b,"sph");
152  fImpactYZ.SetPosition(b,"sph");
153  fClosest.SetPosition(b,"sph");
154  if (fMasses)
155  {
156   delete fMasses;
157   fMasses=0;
158  }
159  if (fDmasses)
160  {
161   delete fDmasses;
162   fDmasses=0;
163  }
164  if (fPmasses)
165  {
166   delete fPmasses;
167   fPmasses=0;
168  }
169 }
170 ///////////////////////////////////////////////////////////////////////////
171 void AliTrack::Set3Momentum(Ali3Vector& p)
172 {
173 // Set the track parameters according to the 3-momentum p
174  Set3Vector(p);
175 }
176 ///////////////////////////////////////////////////////////////////////////
177 void AliTrack::Set4Momentum(Ali4Vector& p)
178 {
179 // Set the track parameters according to the 4-momentum p
180  Double_t E=p.GetScalar();
181  Double_t dE=p.GetResultError();
182  Ali3Vector pv=p.Get3Vector();
183  SetVector(E,pv);
184  SetScalarError(dE);
185 }
186 ///////////////////////////////////////////////////////////////////////////
187 void AliTrack::SetMass(Double_t m,Double_t dm)
188 {
189 // Set the particle mass
190 // The default value for the error dm is 0.
191  Double_t inv=pow(m,2);
192  Double_t dinv=fabs(2.*m*dm);
193  SetInvariant(inv,dinv);
194 }
195 ///////////////////////////////////////////////////////////////////////////
196 void AliTrack::SetCharge(Float_t q)
197 {
198 // Set the particle charge
199  fQ=q;
200 }
201 ///////////////////////////////////////////////////////////////////////////
202 void AliTrack::Info(TString f)
203 {
204 // Provide track information within the coordinate frame f
205  Double_t m=GetMass();
206  Double_t dm=GetResultError();
207  cout << " *AliTrack::Info* Id : " << fUserId << " Mass : " << m
208       << " error : " << dm << " Charge : " << fQ
209       << " Momentum : " << GetMomentum() << " Nmass hyp. : " << fNmasses
210       << " Ntracks : " << fNdec << " Nsignals : " << fNsig << endl;
211  for (Int_t i=0; i<fNmasses; i++)
212  {
213   cout << " Mass hypothesis " << (i+1) << " Mass : " << fMasses->At(i)
214        << " error : " << fDmasses->At(i) << " prob. : " << fPmasses->At(i)
215        << endl;
216  }
217  Ali4Vector::Info(f); 
218
219 ///////////////////////////////////////////////////////////////////////////
220 void AliTrack::List(TString f)
221 {
222 // Provide current track and decay level 1 information within coordinate frame f
223
224  Info(f); // Information of the current track
225
226  // Decay products of this track
227  AliTrack* td; 
228  for (Int_t id=1; id<=fNdec; id++)
229  {
230   td=GetDecayTrack(id);
231   if (td)
232   {
233    cout << "  ---Level 1 sec. track no. " << id << endl;
234    td->Info(f); 
235   }
236   else
237   {
238    cout << " *AliTrack::List* Error : No decay track present." << endl; 
239   }
240  }
241
242 ///////////////////////////////////////////////////////////////////////////
243 void AliTrack::ListAll(TString f)
244 {
245 // Provide complete track and decay information within the coordinate frame f
246
247  Info(f); // Information of the current track
248  cout << " Begin-point :"; fBegin.Info(f);
249  cout << " End-point   :"; fEnd.Info(f);
250  for (Int_t is=1; is<=GetNsignals(); is++)
251  {
252   ((AliSignal*)GetSignal(is))->Info(f);
253  }
254
255  AliTrack* t=this;
256  Dump(t,1,f); // Information of all decay products
257 }
258 //////////////////////////////////////////////////////////////////////////
259 void AliTrack::Dump(AliTrack* t,Int_t n,TString f)
260 {
261 // Recursively provide the info of all decay levels of this track
262  AliTrack* td; 
263  for (Int_t id=1; id<=t->GetNdecay(); id++)
264  {
265   td=t->GetDecayTrack(id);
266   if (td)
267   {
268    cout << "  ---Level " << n << " sec. track no. " << id << endl;
269    td->Info(f); 
270    for (Int_t is=1; is<=td->GetNsignals(); is++)
271    {
272     ((AliSignal*)td->GetSignal(is))->Info(f);
273    }
274
275    // Go for next decay level of this decay track recursively
276    Dump(td,n+1,f);
277   }
278   else
279   {
280    cout << " *AliTrack::Dump* Error : No decay track present." << endl; 
281   }
282  }
283
284 //////////////////////////////////////////////////////////////////////////
285 Double_t AliTrack::GetMomentum()
286 {
287 // Provide the value of the track 3-momentum.
288 // The error can be obtained by invoking GetResultError() after
289 // invokation of GetMomentum().
290  Double_t norm=fV.GetNorm();
291  fDresult=fV.GetResultError();
292  return norm;
293 }
294 ///////////////////////////////////////////////////////////////////////////
295 Ali3Vector AliTrack::Get3Momentum()
296 {
297 // Provide the track 3-momentum
298  return (Ali3Vector)Get3Vector();
299 }
300 ///////////////////////////////////////////////////////////////////////////
301 Double_t AliTrack::GetMass()
302 {
303 // Provide the particle mass.
304 // The error can be obtained by invoking GetResultError() after
305 // invokation of GetMass().
306  Double_t inv=GetInvariant();
307  Double_t dinv=GetResultError();
308  Double_t dm=0;
309  if (inv >= 0)
310  {
311  Double_t m=sqrt(inv);
312  if (m) dm=dinv/(2.*m);
313  fDresult=dm;
314  return m;
315  }
316  else
317  {
318   cout << "*AliTrack::GetMass* Unphysical situation m**2 = " << inv << endl;
319   cout << " Value 0 will be returned." << endl;
320   fDresult=dm;
321   return 0;
322  }
323 }
324 ///////////////////////////////////////////////////////////////////////////
325 Float_t AliTrack::GetCharge()
326 {
327 // Provide the particle charge
328  return fQ;
329 }
330 ///////////////////////////////////////////////////////////////////////////
331 Double_t AliTrack::GetEnergy()
332 {
333 // Provide the particle's energy.
334 // The error can be obtained by invoking GetResultError() after
335 // invokation of GetEnergy().
336  Double_t E=GetScalar();
337  if (E>0)
338  {
339   return E;
340  }
341  else
342  {
343   cout << "*AliTrack::GetEnergy* Unphysical situation E = " << E << endl;
344   cout << " Value 0 will be returned." << endl;
345   return 0;
346  }
347 }
348 ///////////////////////////////////////////////////////////////////////////
349 void AliTrack::Decay(Double_t m1,Double_t m2,Double_t thcms,Double_t phicms)
350 {
351 // Perform 2-body decay of current track
352 // m1     : mass of decay product 1
353 // m2     : mass of decay product 2
354 // thcms  : cms theta decay angle (in rad.) of m1
355 // phicms : cms phi decay angle (in rad.) of m1
356  
357  fNdec=2; // it's a 2-body decay
358
359  Double_t M=GetMass();
360  
361 // Compute the 4-momenta of the decay products in the cms
362 // Note : p2=p1=pnorm for a 2-body decay
363  Double_t e1=0;
364  if (M) e1=((M*M)+(m1*m1)-(m2*m2))/(2.*M);
365  Double_t e2=0;
366  if (M) e2=((M*M)+(m2*m2)-(m1*m1))/(2.*M);
367  Double_t pnorm=(e1*e1)-(m1*m1);
368  if (pnorm>0.)
369  {
370   pnorm=sqrt(pnorm);
371  }
372  else
373  {
374   pnorm=0;
375  }
376  
377  Double_t a[3];
378  a[0]=pnorm;
379  a[1]=thcms;
380  a[2]=phicms;
381  Ali3Vector p;
382  p.SetVector(a,"sph");
383
384  Ali4Vector pprim1;
385  pprim1.SetVector(e1,p);
386  pprim1.SetInvariant(m1*m1);
387
388  Ali4Vector pprim2;
389  p*=-1;
390  pprim2.SetVector(e2,p);
391  pprim2.SetInvariant(m2*m2);
392
393  // Determine boost parameters from the parent particle
394  Double_t E=GetEnergy();
395  p=Get3Vector();
396  Ali4Vector pmu;
397  pmu.SetVector(E,p);
398
399  AliBoost q;
400  q.Set4Momentum(pmu);
401  
402  Ali4Vector p1=q.Inverse(pprim1); // Boost decay product 1
403  Ali4Vector p2=q.Inverse(pprim2); // Boost decay product 2
404  
405  // Enter the boosted data into the decay tracks array
406  if (fDecays)
407  {
408   fDecays->Delete();
409   delete fDecays;
410  }
411  fDecays=new TObjArray();
412
413  fDecays->Add(new AliTrack);
414  ((AliTrack*)fDecays->At(0))->Set4Momentum(p1);
415  ((AliTrack*)fDecays->At(0))->SetMass(m1);
416  fDecays->Add(new AliTrack);
417  ((AliTrack*)fDecays->At(1))->Set4Momentum(p2);
418  ((AliTrack*)fDecays->At(1))->SetMass(m2);
419 }
420 ///////////////////////////////////////////////////////////////////////////
421 Int_t AliTrack::GetNdecay()
422 {
423 // Provide the number of decay produced tracks
424  return fNdec;
425 }
426 ///////////////////////////////////////////////////////////////////////////
427 AliTrack* AliTrack::GetDecayTrack(Int_t j)
428 {
429 // Provide decay produced track number j
430 // Note : j=1 denotes the first decay track
431  if ((j >= 1) && (j <= fNdec))
432  {
433   return (AliTrack*)fDecays->At(j-1);
434  }
435  else
436  {
437   cout << " *AliTrack* decay track number : " << j << " out of range." << endl;
438   cout << " -- Decay track number 1 (if any) returned." << endl;
439   return (AliTrack*)fDecays->At(0);
440  }
441 }
442 ///////////////////////////////////////////////////////////////////////////
443 void AliTrack::AddSignal(AliSignal& s)
444 {
445 // Relate an AliSignal object to this track.
446  if (!fSignals) fSignals=new TObjArray();
447  fNsig++;
448  fSignals->Add(&s);
449 }
450 ///////////////////////////////////////////////////////////////////////////
451 void AliTrack::RemoveSignal(AliSignal& s)
452 {
453 // Remove related AliSignal object to this track.
454  if (fSignals)
455  {
456   AliSignal* test=(AliSignal*)fSignals->Remove(&s);
457   if (test)
458   {
459    fNsig--;
460    fSignals->Compress();
461   }
462  }
463 }
464 ///////////////////////////////////////////////////////////////////////////
465 Int_t AliTrack::GetNsignals()
466 {
467 // Provide the number of related AliSignals.
468  return fNsig;
469 }
470 ///////////////////////////////////////////////////////////////////////////
471 AliSignal* AliTrack::GetSignal(Int_t j)
472 {
473 // Provide the related AliSignal number j.
474 // Note : j=1 denotes the first signal.
475  if ((j >= 1) && (j <= fNsig))
476  {
477   return (AliSignal*)fSignals->At(j-1);
478  }
479  else
480  {
481   cout << " *AliTrack* signal number : " << j << " out of range." << endl;
482   cout << " -- Signal number 1 (if any) returned." << endl;
483   return (AliSignal*)fDecays->At(0);
484  }
485 }
486 ///////////////////////////////////////////////////////////////////////////
487 void AliTrack::SetBeginPoint(AliPosition p)
488 {
489 // Store the position of the track begin-point.
490  fBegin=p;
491 }
492 ///////////////////////////////////////////////////////////////////////////
493 AliPosition AliTrack::GetBeginPoint()
494 {
495 // Provide the position of the track begin-point.
496  return fBegin;
497 }
498 ///////////////////////////////////////////////////////////////////////////
499 void AliTrack::SetEndPoint(AliPosition p)
500 {
501 // Store the position of the track end-point.
502  fEnd=p;
503 }
504 ///////////////////////////////////////////////////////////////////////////
505 AliPosition AliTrack::GetEndPoint()
506 {
507 // Provide the position of the track end-point.
508  return fEnd;
509 }
510 ///////////////////////////////////////////////////////////////////////////
511 void AliTrack::AddMassHypothesis(Double_t prob,Double_t m,Double_t dm)
512 {
513 // Add a mass hypothesis for this current track.
514 // prob=probalility  m=mass value  dm=error on the mass value.
515 // The default value for the mass error dm is 0.
516  if (!fMasses) fMasses=new TArrayD();
517  if (!fDmasses) fDmasses=new TArrayD();
518  if (!fPmasses) fPmasses=new TArrayD();
519
520  fNmasses++;
521  fMasses->Set(fNmasses);
522  fDmasses->Set(fNmasses);
523  fPmasses->Set(fNmasses);
524
525  fMasses->AddAt(m,fNmasses-1);
526  fDmasses->AddAt(dm,fNmasses-1);
527  fPmasses->AddAt(prob,fNmasses-1);
528 }
529 ///////////////////////////////////////////////////////////////////////////
530 Int_t AliTrack::GetNMassHypotheses()
531 {
532 // Provide the number of mass hypotheses for this track.
533  return fNmasses;
534 }
535 ///////////////////////////////////////////////////////////////////////////
536 Double_t AliTrack::GetMassHypothesis(Int_t j)
537 {
538 // Provide the mass of the jth hypothesis for this track.
539 // Note : the first hypothesis is indicated by j=1.
540 // Default : j=0 ==> Hypothesis with highest probability.
541 // The error on the mass can be obtained by invoking GetResultError()
542 // after invokation of GetMassHypothesis(j).
543
544  Double_t m=0,dm=0,prob=0;
545
546  // Check validity of index j
547  if (j<0 || j>fNmasses)
548  {
549   cout << " *AliTrack::GetMassHypothesis* Invalid index j : " << j
550        << " Number of mass hypotheses : " << fNmasses << endl;
551   fDresult=0;
552   return 0;
553  }
554
555  // Select mass hypothesis with highest probability
556  if (j==0) 
557  {
558   if (fNmasses) 
559   {
560    m=fMasses->At(0);
561    dm=fDmasses->At(0);
562    prob=fPmasses->At(0);
563    for (Int_t i=1; i<fNmasses; i++)
564    {
565     if (fPmasses->At(i)>prob)
566     {
567      m=fMasses->At(i);
568      dm=fDmasses->At(i);
569     }
570    }
571   }
572   fDresult=dm;
573   return m;  
574  }
575
576  // Provide data of requested mass hypothesis
577  m=fMasses->At(j-1);
578  fDresult=fDmasses->At(j-1);
579  return m;
580 }
581 ///////////////////////////////////////////////////////////////////////////
582 Double_t AliTrack::GetMassHypothesisProb(Int_t j)
583 {
584 // Provide the probability of the jth hypothesis for this track.
585 // Note : the first hypothesis is indicated by j=1.
586 // Default : j=0 ==> Hypothesis with highest probability.
587
588  Double_t prob=0;
589
590  // Check validity of index j
591  if (j<0 || j>fNmasses)
592  {
593   cout << " *AliTrack::GetMassHypothesisProb* Invalid index j : " << j
594        << " Number of mass hypotheses : " << fNmasses << endl;
595   return 0;
596  }
597
598  // Select mass hypothesis with highest probability
599  if (j==0) 
600  {
601   if (fNmasses) 
602   {
603    prob=fPmasses->At(0);
604    for (Int_t i=1; i<fNmasses; i++)
605    {
606     if (fPmasses->At(i)>prob) prob=fPmasses->At(i);
607    }
608   }
609   return prob;  
610  }
611
612  // Provide probability of requested mass hypothesis
613  prob=fPmasses->At(j-1);
614  return prob;
615 }
616 ///////////////////////////////////////////////////////////////////////////
617 void AliTrack::SetMass()
618 {
619 // Set the mass and error to the value of the hypothesis with highest prob.
620
621  Double_t m=0,dm=0,prob=0;
622
623  // Select mass hypothesis with highest probability
624  if (fNmasses) 
625  {
626   m=fMasses->At(0);
627   dm=fDmasses->At(0);
628   prob=fPmasses->At(0);
629   for (Int_t i=1; i<fNmasses; i++)
630   {
631    if (fPmasses->At(i)>prob)
632    {
633     m=fMasses->At(i);
634     dm=fDmasses->At(i);
635    }
636   }
637   SetMass(m,dm);
638  }
639  else
640  {
641   cout << " *AliTrack::SetMass()* No hypothesis present => No action." << endl;
642  }
643 }
644 ///////////////////////////////////////////////////////////////////////////
645 void AliTrack::RemoveMassHypothesis(Int_t j)
646 {
647 // Remove the jth mass hypothesis for this track.
648 // Note : the first hypothesis is indicated by j=1.
649
650  if (j<=0 || j>fNmasses) // Check validity of index j
651  {
652   cout << " *AliTrack::RemoveMassHypothesis* Invalid index j : " << j
653        << " Number of mass hypotheses : " << fNmasses << endl;
654  }
655  else
656  {
657   if (j != fNmasses)
658   {
659    fMasses->AddAt(fMasses->At(fNmasses-1),j-1);
660    fDmasses->AddAt(fDmasses->At(fNmasses-1),j-1);
661    fPmasses->AddAt(fPmasses->At(fNmasses-1),j-1);
662   }
663   fMasses->AddAt(0,fNmasses-1);
664   fDmasses->AddAt(0,fNmasses-1);
665   fPmasses->AddAt(0,fNmasses-1);
666   fNmasses--;
667   fMasses->Set(fNmasses);
668   fDmasses->Set(fNmasses);
669   fPmasses->Set(fNmasses);
670  }
671 }
672 ///////////////////////////////////////////////////////////////////////////
673 Double_t AliTrack::GetPt()
674 {
675 // Provide trans. momentum value w.r.t. z-axis.
676 // The error on the value can be obtained by GetResultError()
677 // after invokation of GetPt().
678  Ali3Vector v;
679  v=GetVecTrans();
680  Double_t norm=v.GetNorm();
681  fDresult=v.GetResultError();
682
683  return norm;
684 }
685 ///////////////////////////////////////////////////////////////////////////
686 Double_t AliTrack::GetPl()
687 {
688 // Provide long. momentum value w.r.t. z-axis.
689 // Note : the returned value can also be negative.
690 // The error on the value can be obtained by GetResultError()
691 // after invokation of GetPl().
692  Ali3Vector v;
693  v=GetVecLong();
694
695  Double_t pl=v.GetNorm();
696  fDresult=v.GetResultError();
697
698  Double_t a[3];
699  v.GetVector(a,"sph");
700  if (cos(a[1])<0) pl=-pl;
701
702  return pl;
703 }
704 ///////////////////////////////////////////////////////////////////////////
705 Double_t AliTrack::GetEt()
706 {
707 // Provide trans. energy value w.r.t. z-axis.
708 // The error on the value can be obtained by GetResultError()
709 // after invokation of GetEt().
710  Double_t et=GetScaTrans();
711
712  return et;
713 }
714 ///////////////////////////////////////////////////////////////////////////
715 Double_t AliTrack::GetEl()
716 {
717 // Provide long. energy value w.r.t. z-axis.
718 // Note : the returned value can also be negative.
719 // The error on the value can be obtained by GetResultError()
720 // after invokation of GetEl().
721  Double_t el=GetScaLong();
722
723  return el;
724 }
725 ///////////////////////////////////////////////////////////////////////////
726 Double_t AliTrack::GetMt()
727 {
728 // Provide transverse mass value w.r.t. z-axis.
729 // The error on the value can be obtained by GetResultError()
730 // after invokation of GetMt().
731  Double_t pt=GetPt();
732  Double_t dpt=GetResultError();
733  Double_t m=GetMass();
734  Double_t dm=GetResultError();
735
736  Double_t mt=sqrt(pt*pt+m*m);
737  Double_t dmt2=0;
738  if (mt) dmt2=(pow((pt*dpt),2)+pow((m*dm),2))/(mt*mt);
739
740  fDresult=sqrt(dmt2);
741  return mt;
742 }
743 ///////////////////////////////////////////////////////////////////////////
744 Double_t AliTrack::GetMt(Int_t j)
745 {
746 // Provide transverse mass value w.r.t. z-axis and jth mass hypothesis.
747 // Note : the first hypothesis is indicated by j=1.
748 //        j=0 ==> Hypothesis with highest probability.
749 // The error on the value can be obtained by GetResultError()
750 // after invokation of GetMt(j).
751  Double_t pt=GetPt();
752  Double_t dpt=GetResultError();
753  Double_t m=GetMassHypothesis(j);
754  Double_t dm=GetResultError();
755
756  Double_t mt=sqrt(pt*pt+m*m);
757  Double_t dmt2=0;
758  if (mt) dmt2=(pow((pt*dpt),2)+pow((m*dm),2))/(mt*mt);
759
760  fDresult=sqrt(dmt2);
761  return mt;
762 }
763 ///////////////////////////////////////////////////////////////////////////
764 Double_t AliTrack::GetRapidity()
765 {
766 // Provide rapidity value w.r.t. z-axis.
767 // The error on the value can be obtained by GetResultError()
768 // after invokation of GetRapidity().
769 // Note : Also GetPseudoRapidity() is available since this class is
770 //        derived from Ali4Vector.
771  Double_t e=GetEnergy();
772  Double_t de=GetResultError();
773  Double_t pl=GetPl();
774  Double_t dpl=GetResultError();
775  Double_t sum=e+pl;
776  Double_t dif=e-pl;
777
778  Double_t y=9999,dy2=0;
779  if (sum && dif) y=0.5*log(sum/dif);
780
781  if (sum*dif) dy2=(1./(sum*dif))*(pow((pl*de),2)+pow((e*dpl),2));
782
783  fDresult=sqrt(dy2);
784  return y;
785 }
786 ///////////////////////////////////////////////////////////////////////////
787 void AliTrack::SetImpactPoint(AliPosition p,TString q)
788 {
789 // Store the position of the impact-point in the plane "q=0".
790 // Here q denotes one of the axes X, Y or Z.
791 // Note : The character to denote the axis may be entered in lower or
792 //        in uppercase.
793  Int_t axis=0;
794  if (q=="x" || q=="X") axis=1;
795  if (q=="y" || q=="Y") axis=2;
796  if (q=="z" || q=="Z") axis=3;
797
798  switch (axis)
799  {
800   case 1: // Impact-point in the plane X=0
801    fImpactYZ=p;
802    break;
803
804   case 2: // Impact-point in the plane Y=0
805    fImpactXZ=p;
806    break;
807
808   case 3: // Impact-point in the plane Z=0
809    fImpactXY=p;
810    break;
811
812   default: // Unsupported axis
813    cout << "*AliTrack::SetImpactPoint* Unsupported axis : " << q << endl
814         << " Possible axes are 'X', 'Y' and 'Z'." << endl; 
815    break;
816  }
817 }
818 ///////////////////////////////////////////////////////////////////////////
819 AliPosition AliTrack::GetImpactPoint(TString q)
820 {
821 // Provide the position of the impact-point in the plane "q=0".
822 // Here q denotes one of the axes X, Y or Z.
823 // Note : The character to denote the axis may be entered in lower or
824 //        in uppercase.
825  AliPosition dummy;
826  Int_t axis=0;
827  if (q=="x" || q=="X") axis=1;
828  if (q=="y" || q=="Y") axis=2;
829  if (q=="z" || q=="Z") axis=3;
830
831  switch (axis)
832  {
833   case 1: // Impact-point in the plane X=0
834    return fImpactYZ;
835
836   case 2: // Impact-point in the plane Y=0
837    return fImpactXZ;
838
839   case 3: // Impact-point in the plane Z=0
840    return fImpactXY;
841
842   default: // Unsupported axis
843    cout << "*AliTrack::GetImpactPoint* Unsupported axis : " << q << endl
844         << " Possible axes are 'X', 'Y' and 'Z'." << endl; 
845    return dummy;
846  }
847 }
848 ///////////////////////////////////////////////////////////////////////////
849 void AliTrack::SetId(Int_t id)
850 {
851 // Set a user defined identifier for this track.
852  fUserId=id;
853 }
854 ///////////////////////////////////////////////////////////////////////////
855 Int_t AliTrack::GetId()
856 {
857 // Provide the user defined identifier of this track.
858  return fUserId;
859 }
860 ///////////////////////////////////////////////////////////////////////////
861 void AliTrack::SetClosestPoint(AliPosition p)
862 {
863 // Set position p as the point of closest approach w.r.t. some reference
864  fClosest=p;
865 }
866 ///////////////////////////////////////////////////////////////////////////
867 AliPosition AliTrack::GetClosestPoint()
868 {
869 // Provide the point of closest approach w.r.t. some reference
870  return fClosest;
871 }
872 ///////////////////////////////////////////////////////////////////////////