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