TPC/AliTPCtrack.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 //           Implementation of the TPC track class
  20 //        This class is used by the AliTPCtracker class
  21 //      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
  22 //-----------------------------------------------------------------
  23
  24 #include <Riostream.h>
  25
  26 #include "AliTPCtrack.h"
  27 #include "AliCluster.h"
  28 #include "AliTracker.h"
  29 #include "AliESDtrack.h"
  30
  31 ClassImp(AliTPCtrack)
  32
  33 //_________________________________________________________________________
  34 AliTPCtrack::AliTPCtrack():
  35   AliKalmanTrack(),
  36   fdEdx(0),
  37   fSdEdx(1e10),
  38   fNFoundable(0),
  39   fBConstrain(kFALSE),
  40   fLastPoint(-1),
  41   fFirstPoint(-1),
  42   fRemoval(0),
  43   fTrackType(0),
  44   fLab2(-1),
  45   fNShared(0),
  46   fReference()
  47 {
  48   //-------------------------------------------------
  49   // default constructor
  50   //-------------------------------------------------
  51   for (Int_t i=0; i<kMaxRow;i++) fIndex[i]=-2;
  52   for (Int_t i=0; i<4;i++) fPoints[i]=0.;
  53   for (Int_t i=0; i<12;i++) fKinkPoint[i]=0.;
  54   for (Int_t i=0; i<3;i++) fKinkIndexes[i]=0;
  55   for (Int_t i=0; i<3;i++) fV0Indexes[i]=0;
  56 }
  57
  58 //_________________________________________________________________________
  59
  60
  61
  62 AliTPCtrack::AliTPCtrack(Double_t x, Double_t alpha, const Double_t p[5],
  63                          const Double_t cov[15], Int_t index) :
  64   AliKalmanTrack(),
  65   fdEdx(0),
  66   fSdEdx(1e10),
  67   fNFoundable(0),
  68   fBConstrain(kFALSE),
  69   fLastPoint(0),
  70   fFirstPoint(0),
  71   fRemoval(0),
  72   fTrackType(0),
  73   fLab2(0),
  74   fNShared(0),
  75   fReference()
  76 {
  77   //-----------------------------------------------------------------
  78   // This is the main track constructor.
  79   //-----------------------------------------------------------------
  80   Double_t cnv=1./(AliTracker::GetBz()*kB2C);
  81
  82   Double_t pp[5]={
  83     p[0],
  84     p[1],
  85     x*p[4] - p[2],
  86     p[3],
  87     p[4]*cnv
  88   };
  89
  90   Double_t c22 = x*x*cov[14] - 2*x*cov[12] + cov[5];
  91   Double_t c32 = x*cov[13] - cov[8];
  92   Double_t c20 = x*cov[10] - cov[3],
  93            c21 = x*cov[11] - cov[4], c42 = x*cov[14] - cov[12];
  94
  95   Double_t cc[15]={
  96     cov[0 ],
  97     cov[1 ],     cov[2 ],
  98     c20,         c21,         c22,
  99     cov[6 ],     cov[7 ],     c32,     cov[9 ],
 100     cov[10]*cnv, cov[11]*cnv, c42*cnv, cov[13]*cnv, cov[14]*cnv*cnv
 101   };
 102
 103   Double_t mostProbablePt=AliExternalTrackParam::GetMostProbablePt();
 104   Double_t p0=TMath::Sign(1/mostProbablePt,pp[4]);
 105   Double_t w0=cc[14]/(cc[14] + p0*p0), w1=p0*p0/(cc[14] + p0*p0);
 106   pp[4] = w0*p0 + w1*pp[4];
 107   cc[10]*=w1; cc[11]*=w1; cc[12]*=w1; cc[13]*=w1; cc[14]*=w1;
 108
 109   Set(x,alpha,pp,cc);
 110
 111   SetNumberOfClusters(1);
 112
 113   fIndex[0]=index;
 114   for (Int_t i=1; i<kMaxRow;i++) fIndex[i]=-2;
 115   for (Int_t i=0; i<4;i++) fPoints[i]=0.;
 116   for (Int_t i=0; i<12;i++) fKinkPoint[i]=0.;
 117   for (Int_t i=0; i<3;i++) fKinkIndexes[i]=0;
 118   for (Int_t i=0; i<3;i++) fV0Indexes[i]=0;
 119 }
 120
 121 //_____________________________________________________________________________
 122 AliTPCtrack::AliTPCtrack(const AliESDtrack& t) :
 123   AliKalmanTrack(),
 124   fdEdx(t.GetTPCsignal()),
 125   fSdEdx(1e10),
 126   fNFoundable(0),
 127   fBConstrain(kFALSE),
 128   fLastPoint(0),
 129   fFirstPoint(0),
 130   fRemoval(0),
 131   fTrackType(0),
 132   fLab2(0),
 133   fNShared(0),
 134   fReference()
 135 {
 136   //-----------------------------------------------------------------
 137   // Conversion AliESDtrack -> AliTPCtrack.
 138   //-----------------------------------------------------------------
 139   SetNumberOfClusters(t.GetTPCclusters(fIndex));
 140   SetLabel(t.GetLabel());
 141   SetMass(t.GetMass());
 142   for (Int_t i=0; i<4;i++) fPoints[i]=0.;
 143   for (Int_t i=0; i<12;i++) fKinkPoint[i]=0.;
 144   for (Int_t i=0; i<3;i++) fKinkIndexes[i]=0;
 145   for (Int_t i=0; i<3;i++) fV0Indexes[i]=0;
 146
 147   Set(t.GetX(),t.GetAlpha(),t.GetParameter(),t.GetCovariance());
 148
 149   if ((t.GetStatus()&AliESDtrack::kTIME) == 0) return;
 150   StartTimeIntegral();
 151   Double_t times[10]; t.GetIntegratedTimes(times); SetIntegratedTimes(times);
 152   SetIntegratedLength(t.GetIntegratedLength());
 153 }
 154
 155 //_____________________________________________________________________________
 156 AliTPCtrack::AliTPCtrack(const AliTPCtrack& t) :
 157   AliKalmanTrack(t),
 158   fdEdx(t.fdEdx),
 159   fSdEdx(t.fSdEdx),
 160   fNFoundable(t.fNFoundable),
 161   fBConstrain(t.fBConstrain),
 162   fLastPoint(t.fLastPoint),
 163   fFirstPoint(t.fFirstPoint),
 164   fRemoval(t.fRemoval),
 165   fTrackType(t.fTrackType),
 166   fLab2(t.fLab2),
 167   fNShared(t.fNShared),
 168   fReference(t.fReference)
 169
 170 {
 171   //-----------------------------------------------------------------
 172   // This is a track copy constructor.
 173   //-----------------------------------------------------------------
 174   Set(t.GetX(),t.GetAlpha(),t.GetParameter(),t.GetCovariance());
 175
 176   for (Int_t i=0; i<kMaxRow; i++) fIndex[i]=t.fIndex[i];
 177   for (Int_t i=0; i<4;i++) fPoints[i]=t.fPoints[i];
 178   for (Int_t i=0; i<12;i++) fKinkPoint[i]=t.fKinkPoint[i];
 179   for (Int_t i=0; i<3;i++) fKinkIndexes[i]=t.fKinkIndexes[i];
 180   for (Int_t i=0; i<3;i++) fV0Indexes[i]=t.fV0Indexes[i];
 181 }
 182
 183 AliTPCtrack& AliTPCtrack::operator=(const AliTPCtrack& o){
 184   if(this!=&o){
 185     AliKalmanTrack::operator=(o);
 186     fdEdx = o.fdEdx;
 187     for(Int_t i = 0;i<kMaxRow;++i)fIndex[i] = o.fIndex[i];
 188     for(Int_t i = 0;i<4;++i)fPoints[i] = o.fPoints[i];
 189     fSdEdx = o.fSdEdx;
 190     fNFoundable = o.fNFoundable;
 191     fBConstrain = o.fBConstrain;
 192     fLastPoint  = o.fLastPoint;
 193     fFirstPoint = o.fFirstPoint;
 194     fTrackType  = o.fTrackType;
 195     fLab2       = o.fLab2;
 196     fNShared    = o.fNShared;
 197     fReference  = o.fReference;
 198     for(Int_t i = 0;i<12;++i) fKinkPoint[i] = o.fKinkPoint[i];
 199
 200     for(Int_t i = 0;i<3;++i){
 201       fKinkIndexes[i] = o.fKinkIndexes[i];
 202       fV0Indexes[i] = o.fV0Indexes[i];
 203     }
 204   }
 205   return *this;
 206
 207 }
 208
 209
 210 //_____________________________________________________________________________
 211 Int_t AliTPCtrack::Compare(const TObject *o) const {
 212   //-----------------------------------------------------------------
 213   // This function compares tracks according to the their curvature
 214   //-----------------------------------------------------------------
 215   AliTPCtrack *t=(AliTPCtrack*)o;
 216   //Double_t co=t->OneOverPt();
 217   //Double_t c = OneOverPt();
 218   Double_t co=t->GetSigmaY2()*t->GetSigmaZ2();
 219   Double_t c =GetSigmaY2()*GetSigmaZ2();
 220   if (c>co) return 1;
 221   else if (c<co) return -1;
 222   return 0;
 223 }
 224
 225 Double_t AliTPCtrack::GetPredictedChi2(const AliCluster *c) const {
 226   //-----------------------------------------------------------------
 227   // This function calculates a predicted chi2 increment.
 228   //-----------------------------------------------------------------
 229   Double_t p[2]={c->GetY(), c->GetZ()};
 230   Double_t cov[3]={c->GetSigmaY2(), 0., c->GetSigmaZ2()};
 231   return AliExternalTrackParam::GetPredictedChi2(p,cov);
 232 }
 233
 234 //_____________________________________________________________________________
 235 Bool_t AliTPCtrack::PropagateTo(Double_t xk,Double_t rho,Double_t x0) {
 236   //-----------------------------------------------------------------
 237   //  This function propagates a track to a reference plane x=xk.
 238   //  rho - density of the crossed matrial (g/cm^3)
 239   //  x0  - radiation length of the crossed material (g/cm^2)
 240   //-----------------------------------------------------------------
 241   Double_t oldX=GetX(), oldY=GetY(), oldZ=GetZ();
 242
 243   Double_t bz=GetBz();
 244   if (!AliExternalTrackParam::PropagateTo(xk,bz)) return kFALSE;
 245
 246   Double_t d = TMath::Sqrt((GetX()-oldX)*(GetX()-oldX) +
 247                            (GetY()-oldY)*(GetY()-oldY) +
 248                            (GetZ()-oldZ)*(GetZ()-oldZ));
 249   if (IsStartedTimeIntegral() && GetX()>oldX) AddTimeStep(d);
 250
 251   if (oldX < xk) d = -d;
 252   if (!AliExternalTrackParam::CorrectForMaterial(d*rho/x0,x0,GetMass()))
 253      return kFALSE;
 254
 255   return kTRUE;
 256 }
 257
 258 //_____________________________________________________________________________
 259 Bool_t
 260 AliTPCtrack::PropagateToVertex(const AliESDVertex *v,Double_t d,Double_t x0)
 261 {
 262   //-----------------------------------------------------------------
 263   // This function propagates tracks to the vertex.
 264   //-----------------------------------------------------------------
 265   Double_t bz=GetBz();
 266   if (PropagateToDCA(v,bz,kVeryBig))
 267    if (AliExternalTrackParam::CorrectForMaterial(d,x0,GetMass())) return kTRUE;
 268   return kFALSE;
 269 }
 270
 271 //_____________________________________________________________________________
 272 Bool_t AliTPCtrack::Update(const AliCluster *c, Double_t chisq, Int_t index) {
 273   //-----------------------------------------------------------------
 274   // This function associates a cluster with this track.
 275   //-----------------------------------------------------------------
 276   Double_t p[2]={c->GetY(), c->GetZ()};
 277   Double_t cov[3]={c->GetSigmaY2(), 0., c->GetSigmaZ2()};
 278
 279   if (!AliExternalTrackParam::Update(p,cov)) return kFALSE;
 280
 281   Int_t n=GetNumberOfClusters();
 282   fIndex[n]=index;
 283   SetNumberOfClusters(n+1);
 284   SetChi2(GetChi2()+chisq);
 285
 286   return kTRUE;
 287 }
 288
 289 ////////////////////////////////////////////////////////////////////////
 290 // MI ADDITION
 291
 292 Float_t AliTPCtrack::Density(Int_t row0, Int_t row1)
 293 {
 294   //
 295   // calculate cluster density
 296   Int_t good  = 0;
 297   Int_t found = 0;
 298   //if (row0<fFirstPoint) row0 = fFirstPoint;
 299   if (row1>fLastPoint) row1 = fLastPoint;
 300
 301
 302   for (Int_t i=row0;i<=row1;i++){
 303     //    Int_t index = fClusterIndex[i];
 304     Int_t index = fIndex[i];
 305     if (index!=-1)  good++;
 306     if (index>0)    found++;
 307   }
 308   Float_t density=0;
 309   if (good>0) density = Float_t(found)/Float_t(good);
 310   return density;
 311 }
 312
 313
 314 Float_t AliTPCtrack::Density2(Int_t row0, Int_t row1)
 315 {
 316   //
 317   // calculate cluster density
 318   Int_t good  = 0;
 319   Int_t found = 0;
 320   //
 321   for (Int_t i=row0;i<=row1;i++){
 322     Int_t index = fIndex[i];
 323     if (index!=-1)  good++;
 324     if (index>0)    found++;
 325   }
 326   Float_t density=0;
 327   if (good>0) density = Float_t(found)/Float_t(good);
 328   return density;
 329 }
 330
 331 void  AliTPCtrack::UpdatePoints()
 332 {
 333   //--------------------------------------------------
 334   //calculates first ,amx dens and last points
 335   //--------------------------------------------------
 336   Float_t density[160];
 337   for (Int_t i=0;i<160;i++) density[i]=-1.;
 338   fPoints[0]= 160;
 339   fPoints[1] = -1;
 340   //
 341   Int_t ngood=0;
 342   Int_t undeff=0;
 343   Int_t nall =0;
 344   Int_t range=20;
 345   for (Int_t i=0;i<160;i++){
 346     Int_t last = i-range;
 347     if (nall<range) nall++;
 348     if (last>=0){
 349       if (fIndex[last]>0&& (fIndex[last]&0x8000)==0) ngood--;
 350       if (fIndex[last]==-1) undeff--;
 351     }
 352     if (fIndex[i]>0&& (fIndex[i]&0x8000)==0)   ngood++;
 353     if (fIndex[i]==-1) undeff++;
 354     if (nall==range &&undeff<range/2) density[i-range/2] = Float_t(ngood)/Float_t(nall-undeff);
 355   }
 356   Float_t maxdens=0;
 357   Int_t indexmax =0;
 358   for (Int_t i=0;i<160;i++){
 359     if (density[i]<0) continue;
 360     if (density[i]>maxdens){
 361       maxdens=density[i];
 362       indexmax=i;
 363     }
 364   }
 365   //
 366   //max dens point
 367   fPoints[3] = maxdens;
 368   fPoints[1] = indexmax;
 369   //
 370   // last point
 371   for (Int_t i=indexmax;i<160;i++){
 372     if (density[i]<0) continue;
 373     if (density[i]<maxdens/2.) {
 374       break;
 375     }
 376     fPoints[2]=i;
 377   }
 378   //
 379   // first point
 380   for (Int_t i=indexmax;i>0;i--){
 381     if (density[i]<0) continue;
 382     if (density[i]<maxdens/2.) {
 383       break;
 384     }
 385     fPoints[0]=i;
 386   }
 387   //
 388 }
 389
 390 Double_t AliTPCtrack::GetBz() const {
 391   //
 392   // returns Bz component of the magnetic field (kG)
 393   //
 394   if (AliTracker::UniformField()) return AliTracker::GetBz();
 395   Double_t r[3]; GetXYZ(r);
 396   return AliTracker::GetBz(r);
 397 }
 398