TOF/AliTOFtracker.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 //--------------------------------------------------------------------//
  17 //                                                                    //
  18 // AliTOFtracker Class                                                //
  19 // Task: Perform association of the ESD tracks to TOF Clusters        //
  20 // and Update ESD track with associated TOF Cluster parameters        //
  21 //                                                                    //
  22 // -- Authors : S. Arcelli, C. Zampolli (Bologna University and INFN) //
  23 // -- Contacts: Annalisa.De.Caro@cern.ch                              //
  24 // --         : Chiara.Zampolli@bo.infn.it                            //
  25 // --         : Silvia.Arcelli@bo.infn.it                             //
  26 //                                                                    //
  27 //--------------------------------------------------------------------//
  28
  29 #include "Rtypes.h"
  30
  31 #include "TClonesArray.h"
  32 #include "TGeoManager.h"
  33 #include "TTree.h"
  34
  35 #include "AliAlignObj.h"
  36 #include "AliESDtrack.h"
  37 #include "AliESD.h"
  38 #include "AliLog.h"
  39 #include "AliTrackPointArray.h"
  40
  41 #include "AliTOFcalib.h"
  42 #include "AliTOFcluster.h"
  43 #include "AliTOFGeometry.h"
  44 #include "AliTOFtracker.h"
  45 #include "AliTOFtrack.h"
  46
  47 extern TGeoManager *gGeoManager;
  48
  49 ClassImp(AliTOFtracker)
  50
  51 //_____________________________________________________________________________
  52 AliTOFtracker::AliTOFtracker(AliTOFGeometry * geom, Double_t parPID[2]):
  53   fGeom(geom),
  54   fTOFpid(new AliTOFpidESD(parPID)),
  55   fHoles(kFALSE),
  56   fN(0),
  57   fNseeds(0),
  58   fNseedsTOF(0),
  59   fngoodmatch(0),
  60   fnbadmatch(0),
  61   fnunmatch(0),
  62   fnmatch(0),
  63   fR(378.),
  64   fTOFHeigth(15.3),
  65   fdCut(3.),
  66   fDx(1.5),
  67   fDy(0),
  68   fDz(0),
  69   fDzMax(35.),
  70   fDyMax(50.),
  71   fTracks(0x0),
  72   fSeeds(0x0)
  73  {
  74   //AliTOFtracker main Ctor
  75
  76   //fHoles=true;
  77   fDy=AliTOFGeometry::XPad();
  78   fDz=AliTOFGeometry::ZPad();
  79   fHoles = fGeom->GetHoles();
  80 }
  81 //_____________________________________________________________________________
  82 AliTOFtracker::AliTOFtracker(const AliTOFtracker &t):
  83   AliTracker(),
  84   fGeom(0x0),
  85   fTOFpid(0x0),
  86   fHoles(kFALSE),
  87   fN(0),
  88   fNseeds(0),
  89   fNseedsTOF(0),
  90   fngoodmatch(0),
  91   fnbadmatch(0),
  92   fnunmatch(0),
  93   fnmatch(0),
  94   fR(378.),
  95   fTOFHeigth(15.3),
  96   fdCut(3.),
  97   fDx(1.5),
  98   fDy(0),
  99   fDz(0),
 100   fDzMax(35.),
 101   fDyMax(50.),
 102   fTracks(0x0),
 103   fSeeds(0x0)
 104  {
 105   //AliTOFtracker copy Ctor
 106
 107   fHoles=t.fHoles;
 108   fNseeds=t.fNseeds;
 109   fNseedsTOF=t.fNseedsTOF;
 110   fngoodmatch=t.fngoodmatch;
 111   fnbadmatch=t.fnbadmatch;
 112   fnunmatch=t.fnunmatch;
 113   fnmatch=t.fnmatch;
 114   fGeom = t.fGeom;
 115   fTOFpid = t.fTOFpid;
 116   fR=t.fR;
 117   fTOFHeigth=t.fTOFHeigth;
 118   fdCut=t.fdCut;
 119   fDy=t.fDy;
 120   fDz=t.fDz;
 121   fDx=t.fDx;
 122   fDzMax=t.fDzMax;
 123   fDyMax=t.fDyMax;
 124   fSeeds=t.fSeeds;
 125   fTracks=t.fTracks;
 126   fN=t.fN;
 127 }
 128
 129 //_____________________________________________________________________________
 130 AliTOFtracker& AliTOFtracker::operator=(const AliTOFtracker &t)
 131 {
 132   //AliTOFtracker assignment operator
 133
 134   this->fHoles=t.fHoles;
 135   this->fNseeds=t.fNseeds;
 136   this->fNseedsTOF=t.fNseedsTOF;
 137   this->fngoodmatch=t.fngoodmatch;
 138   this->fnbadmatch=t.fnbadmatch;
 139   this->fnunmatch=t.fnunmatch;
 140   this->fnmatch=t.fnmatch;
 141   this->fGeom = t.fGeom;
 142   this->fTOFpid = t.fTOFpid;
 143   this->fR=t.fR;
 144   this->fTOFHeigth=t.fTOFHeigth;
 145   this->fdCut=t.fdCut;
 146   this->fDy=t.fDy;
 147   this->fDz=t.fDz;
 148   this->fDx=t.fDx;
 149   this->fDzMax=t.fDzMax;
 150   this->fDyMax=t.fDyMax;
 151   this->fSeeds=t.fSeeds;
 152   this->fTracks=t.fTracks;
 153   this->fN=t.fN;
 154   return *this;
 155
 156 }
 157
 158 //_____________________________________________________________________________
 159 Int_t AliTOFtracker::PropagateBack(AliESD* event) {
 160   //
 161   // Gets seeds from ESD event and Match with TOF Clusters
 162   //
 163
 164
 165   //Initialise some counters
 166
 167   fNseeds=0;
 168   fNseedsTOF=0;
 169   fngoodmatch=0;
 170   fnbadmatch=0;
 171   fnunmatch=0;
 172   fnmatch=0;
 173
 174   Int_t ntrk=event->GetNumberOfTracks();
 175   fNseeds = ntrk;
 176   fSeeds= new TClonesArray("AliESDtrack",ntrk);
 177   TClonesArray &aESDTrack = *fSeeds;
 178
 179
 180   //Load ESD tracks into a local Array of ESD Seeds
 181
 182   for (Int_t i=0; i<fNseeds; i++) {
 183     AliESDtrack *t=event->GetTrack(i);
 184     new(aESDTrack[i]) AliESDtrack(*t);
 185   }
 186
 187   //Prepare ESD tracks candidates for TOF Matching
 188   CollectESD();
 189
 190   //First Step with Strict Matching Criterion
 191   MatchTracks(kFALSE);
 192   /*
 193   for (Int_t ijk=0; ijk<fN; ijk++) {
 194     AliInfo(Form("%4i %4i  %f %f %f  %f %f   %2i %1i %2i %1i %2i",ijk, fClusters[ijk]->GetIndex(),fClusters[ijk]->GetZ(),fClusters[ijk]->GetR(),fClusters[ijk]->GetPhi(), fClusters[ijk]->GetTDC(),fClusters[ijk]->GetADC(),fClusters[ijk]->GetDetInd(0),fClusters[ijk]->GetDetInd(1),fClusters[ijk]->GetDetInd(2),fClusters[ijk]->GetDetInd(3),fClusters[ijk]->GetDetInd(4)));
 195   }
 196   */
 197
 198   //Second Step with Looser Matching Criterion
 199   MatchTracks(kTRUE);
 200
 201   AliInfo(Form("Number of matched tracks: %d",fnmatch));
 202   AliInfo(Form("Number of good matched tracks: %d",fngoodmatch));
 203   AliInfo(Form("Number of bad  matched tracks: %d",fnbadmatch));
 204
 205   //Update the matched ESD tracks
 206
 207   for (Int_t i=0; i<ntrk; i++) {
 208     AliESDtrack *t=event->GetTrack(i);
 209     AliESDtrack *seed =(AliESDtrack*)fSeeds->UncheckedAt(i);
 210     if(seed->GetTOFsignal()>0){
 211       t->SetTOFsignal(seed->GetTOFsignal());
 212       t->SetTOFcluster(seed->GetTOFcluster());
 213       t->SetTOFsignalToT(seed->GetTOFsignalToT());
 214       t->SetTOFCalChannel(seed->GetTOFCalChannel());
 215       Int_t tlab[3]; seed->GetTOFLabel(tlab);
 216       t->SetTOFLabel(tlab);
 217       AliTOFtrack *track = new AliTOFtrack(*seed);
 218       t->UpdateTrackParams(track,AliESDtrack::kTOFout);
 219       delete track;
 220     }
 221   }
 222
 223
 224   //Make TOF PID
 225   fTOFpid->MakePID(event);
 226
 227   if (fSeeds) {
 228     fSeeds->Delete();
 229     delete fSeeds;
 230     fSeeds = 0x0;
 231   }
 232   if (fTracks) {
 233     fTracks->Delete();
 234     delete fTracks;
 235     fTracks = 0x0;
 236   }
 237   return 0;
 238
 239 }
 240 //_________________________________________________________________________
 241 void AliTOFtracker::CollectESD() {
 242    //prepare the set of ESD tracks to be matched to clusters in TOF
 243
 244   fTracks= new TClonesArray("AliTOFtrack");
 245   TClonesArray &aTOFTrack = *fTracks;
 246   for (Int_t i=0; i<fNseeds; i++) {
 247
 248     AliESDtrack *t =(AliESDtrack*)fSeeds->UncheckedAt(i);
 249     if ((t->GetStatus()&AliESDtrack::kTPCout)==0)continue;
 250
 251     // TRD good tracks, already propagated at 371 cm
 252
 253     AliTOFtrack *track = new AliTOFtrack(*t); // New
 254     Double_t x = track->GetX(); //New
 255
 256     if (((t->GetStatus()&AliESDtrack::kTRDout)!=0 ) &&
 257          ( x >= fGeom->RinTOF()) ){
 258       track->SetSeedIndex(i);
 259       t->UpdateTrackParams(track,AliESDtrack::kTOFout);
 260       new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
 261       fNseedsTOF++;
 262       delete track;
 263     }
 264
 265     // Propagate the rest of TPCbp
 266
 267     else {
 268       if(track->PropagateToInnerTOF(fHoles)){ // temporary solution
 269         //      if(track->PropagateToInnerTOF(fGeom->GetHoles())){
 270         track->SetSeedIndex(i);
 271         t->UpdateTrackParams(track,AliESDtrack::kTOFout);
 272         new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
 273         fNseedsTOF++;
 274       }
 275       delete track;
 276     }
 277   }
 278
 279   AliInfo(Form("Number of TOF seedds %i",fNseedsTOF));
 280
 281   // Sort according uncertainties on track position
 282   fTracks->Sort();
 283
 284 }
 285 //_________________________________________________________________________
 286 void AliTOFtracker::MatchTracks( Bool_t mLastStep){
 287
 288   //Match ESD tracks to clusters in TOF
 289
 290
 291   Int_t nSteps=(Int_t)(fTOFHeigth/0.1);
 292
 293   AliTOFcalib *calib = new AliTOFcalib(fGeom);
 294   //PH Arrays (moved outside of the loop)
 295   Float_t * trackPos[4];
 296   for (Int_t ii=0; ii<4; ii++) trackPos[ii] = new Float_t[nSteps];
 297   Int_t * clind[6];
 298   for (Int_t ii=0;ii<6;ii++) clind[ii] = new Int_t[fN];
 299
 300   for (Int_t iseed=0; iseed<fNseedsTOF; iseed++) {
 301
 302     AliTOFtrack *track =(AliTOFtrack*)fTracks->UncheckedAt(iseed);
 303     AliESDtrack *t =(AliESDtrack*)fSeeds->UncheckedAt(track->GetSeedIndex());
 304     if(t->GetTOFsignal()>0. ) continue;
 305     AliTOFtrack *trackTOFin =new AliTOFtrack(*track);
 306
 307     // Some init
 308
 309     Int_t         index[10000];
 310     Float_t        dist[10000];
 311     Float_t       cxpos[10000];
 312     Float_t       crecL[10000];
 313     TGeoHMatrix   global[1000];
 314
 315     // Determine a window around the track
 316
 317     Double_t x,par[5];
 318     trackTOFin->GetExternalParameters(x,par);
 319     Double_t cov[15];
 320     trackTOFin->GetExternalCovariance(cov);
 321     Float_t scalefact=3.;
 322     Double_t dphi=
 323       scalefact*
 324       ((5*TMath::Sqrt(cov[0]) + 0.5*fDy + 2.5*TMath::Abs(par[2]))/fR);
 325     Double_t dz=
 326       scalefact*
 327       (5*TMath::Sqrt(cov[2]) + 0.5*fDz + 2.5*TMath::Abs(par[3]));
 328
 329     Double_t phi=TMath::ATan2(par[0],x) + trackTOFin->GetAlpha();
 330     if (phi<-TMath::Pi())phi+=2*TMath::Pi();
 331     if (phi>=TMath::Pi())phi-=2*TMath::Pi();
 332     Double_t z=par[1];
 333
 334     //upper limit on window's size.
 335
 336     if(dz> fDzMax) dz=fDzMax;
 337     if(dphi*fR>fDyMax) dphi=fDyMax/fR;
 338
 339
 340     Int_t nc=0;
 341
 342     // find the clusters in the window of the track
 343
 344     for (Int_t k=FindClusterIndex(z-dz); k<fN; k++) {
 345
 346       AliTOFcluster *c=fClusters[k];
 347       if (c->GetZ() > z+dz) break;
 348       if (c->IsUsed()) continue;
 349       if (!c->GetStatus()) continue; // skip bad channels as declared in OCDB
 350
 351       //AliInfo(Form(" fClusters[k]->GetZ() (%f) z-dz (%f)   %4i ", fClusters[k]->GetZ(), z-dz, k));
 352
 353       Double_t dph=TMath::Abs(c->GetPhi()-phi);
 354       if (dph>TMath::Pi()) dph-=2.*TMath::Pi();
 355       if (TMath::Abs(dph)>dphi) continue;
 356
 357       clind[0][nc] = c->GetDetInd(0);
 358       clind[1][nc] = c->GetDetInd(1);
 359       clind[2][nc] = c->GetDetInd(2);
 360       clind[3][nc] = c->GetDetInd(3);
 361       clind[4][nc] = c->GetDetInd(4);
 362       clind[5][nc] = k;
 363       Char_t path[100];
 364       Int_t ind[5];
 365       ind[0]=clind[0][nc];
 366       ind[1]=clind[1][nc];
 367       ind[2]=clind[2][nc];
 368       ind[3]=clind[3][nc];
 369       ind[4]=clind[4][nc];
 370       fGeom->GetVolumePath(ind,path);
 371       gGeoManager->cd(path);
 372       global[nc] = *gGeoManager->GetCurrentMatrix();
 373       nc++;
 374     }
 375
 376     //if (nc) AliInfo(Form("seed for TOF %4i and number of clusters in the track window %4i (cluster index %4i)     %4i",i,nc, clind[5][0], fN));
 377
 378     //start fine propagation
 379
 380     Int_t nStepsDone = 0;
 381     for( Int_t istep=0; istep<nSteps; istep++){
 382
 383       Float_t xs=fGeom->RinTOF()+istep*0.1;
 384       Double_t ymax=xs*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
 385
 386       Bool_t skip=kFALSE;
 387       Double_t ysect=trackTOFin->GetYat(xs,skip);
 388       if(skip)break;
 389       if (ysect > ymax) {
 390         if (!trackTOFin->Rotate(AliTOFGeometry::GetAlpha())) {
 391           break;
 392         }
 393       } else if (ysect <-ymax) {
 394         if (!trackTOFin->Rotate(-AliTOFGeometry::GetAlpha())) {
 395           break;
 396         }
 397       }
 398
 399       if(!trackTOFin->PropagateTo(xs)) {
 400         break;
 401       }
 402
 403       nStepsDone++;
 404
 405       // store the running point (Globalrf) - fine propagation
 406
 407       Double_t x,y,z;
 408       trackTOFin->GetGlobalXYZ(x,y,z);
 409       trackPos[0][istep]= (Float_t) x;
 410       trackPos[1][istep]= (Float_t) y;
 411       trackPos[2][istep]= (Float_t) z;
 412       trackPos[3][istep]= trackTOFin->GetIntegratedLength();
 413     }
 414
 415
 416     Int_t nfound = 0;
 417     for (Int_t istep=0; istep<nStepsDone; istep++) {
 418
 419       Bool_t isInside =kFALSE;
 420       Float_t ctrackPos[3];
 421
 422       ctrackPos[0]= trackPos[0][istep];
 423       ctrackPos[1]= trackPos[1][istep];
 424       ctrackPos[2]= trackPos[2][istep];
 425
 426       //now see whether the track matches any of the TOF clusters
 427
 428       for (Int_t i=0; i<nc; i++){
 429         Int_t cind[5];
 430         cind[0]= clind[0][i];
 431         cind[1]= clind[1][i];
 432         cind[2]= clind[2][i];
 433         cind[3]= clind[3][i];
 434         cind[4]= clind[4][i];
 435         Bool_t accept = kFALSE;
 436         if( mLastStep)accept = (fGeom->DistanceToPad(cind,global[i],ctrackPos)<fdCut);
 437         if(!mLastStep)accept = (fGeom->IsInsideThePad(cind,global[i],ctrackPos));
 438         if(accept){
 439           if(!mLastStep)isInside=kTRUE;
 440           dist[nfound]=fGeom->DistanceToPad(cind,global[i],ctrackPos);
 441           crecL[nfound]=trackPos[3][istep];
 442           index[nfound]=clind[5][i]; // store cluster id
 443           cxpos[nfound]=fGeom->RinTOF()+istep*0.1; //store prop.radius
 444           nfound++;
 445           if(isInside)break;
 446         }//end if accept
 447       } //end for on the clusters
 448
 449
 450       if(isInside)break;
 451     } //end for on the steps
 452
 453
 454
 455     if (nfound == 0 ) {
 456       fnunmatch++;
 457       delete trackTOFin;
 458       continue;
 459     }
 460
 461     fnmatch++;
 462
 463     // now choose the cluster to be matched with the track.
 464
 465     Int_t idclus=0;
 466     Float_t  recL = 0.;
 467     Float_t  xpos=0.;
 468     Float_t  mindist=1000.;
 469     for (Int_t iclus= 0; iclus<nfound;iclus++){
 470       if (dist[iclus]< mindist){
 471         mindist = dist[iclus];
 472         xpos = cxpos[iclus];
 473         idclus =index[iclus];
 474         recL=crecL[iclus]+fDx*0.5;
 475       }
 476     }
 477
 478     AliTOFcluster *c=fClusters[idclus];
 479     c->Use(); //AliInfo(Form("I am using the cluster"));
 480
 481     // Track length correction for matching Step 2
 482
 483     if(mLastStep){
 484       Float_t rc=TMath::Sqrt(c->GetR()*c->GetR() + c->GetZ()*c->GetZ());
 485       Float_t rt=TMath::Sqrt(trackPos[0][70]*trackPos[0][70]
 486                              +trackPos[1][70]*trackPos[1][70]
 487                              +trackPos[2][70]*trackPos[2][70]);
 488       Float_t dlt=rc-rt;
 489       recL=trackPos[3][70]+dlt;
 490     }
 491
 492     if (
 493         (c->GetLabel(0)==TMath::Abs(trackTOFin->GetLabel()))
 494         ||
 495         (c->GetLabel(1)==TMath::Abs(trackTOFin->GetLabel()))
 496         ||
 497         (c->GetLabel(2)==TMath::Abs(trackTOFin->GetLabel()))
 498         ) {
 499       fngoodmatch++;
 500
 501       //AliInfo(Form(" track label good %5i",trackTOFin->GetLabel()));
 502
 503     }
 504     else{
 505       fnbadmatch++;
 506
 507       //AliInfo(Form(" track label  bad %5i",trackTOFin->GetLabel()));
 508
 509     }
 510
 511     delete trackTOFin;
 512
 513     //  Store quantities to be used in the TOF Calibration
 514     Float_t tToT=c->GetToT(); // in ps
 515     t->SetTOFsignalToT(tToT);
 516     Int_t ind[5];
 517     ind[0]=c->GetDetInd(0);
 518     ind[1]=c->GetDetInd(1);
 519     ind[2]=c->GetDetInd(2);
 520     ind[3]=c->GetDetInd(3);
 521     ind[4]=c->GetDetInd(4);
 522     Int_t calindex = calib->GetIndex(ind);
 523     t->SetTOFCalChannel(calindex);
 524
 525     // keep track of the track labels in the matched cluster
 526     Int_t tlab[3];
 527     tlab[0]=c->GetLabel(0);
 528     tlab[1]=c->GetLabel(1);
 529     tlab[2]=c->GetLabel(2);
 530
 531     Double_t tof=AliTOFGeometry::TdcBinWidth()*c->GetTDC()+32; // in ps
 532     t->SetTOFsignal(tof);
 533     //t->SetTOFcluster(c->GetIndex()); // pointing to the digits tree
 534     t->SetTOFcluster(idclus); // pointing to the recPoints tree
 535     Double_t time[10]; t->GetIntegratedTimes(time);
 536     Double_t mom=t->GetP();
 537     for(Int_t j=0;j<=AliPID::kSPECIES;j++){
 538       Double_t mass=AliPID::ParticleMass(j);
 539       time[j]+=(recL-trackPos[3][0])/3e-2*TMath::Sqrt(mom*mom+mass*mass)/mom;
 540     }
 541
 542     AliTOFtrack *trackTOFout = new AliTOFtrack(*t);
 543     trackTOFout->PropagateTo(xpos);
 544     t->UpdateTrackParams(trackTOFout,AliESDtrack::kTOFout);
 545     t->SetIntegratedLength(recL);
 546     t->SetIntegratedTimes(time);
 547     t->SetTOFLabel(tlab);
 548
 549     delete trackTOFout;
 550   }
 551   for (Int_t ii=0; ii<4; ii++) delete [] trackPos[ii];
 552   for (Int_t ii=0;ii<6;ii++) delete [] clind[ii];
 553   delete calib;
 554 }
 555 //_________________________________________________________________________
 556 Int_t AliTOFtracker::LoadClusters(TTree *cTree) {
 557   //--------------------------------------------------------------------
 558   //This function loads the TOF clusters
 559   //--------------------------------------------------------------------
 560
 561   TBranch *branch=cTree->GetBranch("TOF");
 562   if (!branch) {
 563     AliError("can't get the branch with the TOF clusters !");
 564     return 1;
 565   }
 566
 567   TClonesArray dummy("AliTOFcluster",10000), *clusters=&dummy;
 568   branch->SetAddress(&clusters);
 569
 570   cTree->GetEvent(0);
 571   Int_t nc=clusters->GetEntriesFast();
 572   AliInfo(Form("Number of clusters: %d",nc));
 573
 574   for (Int_t i=0; i<nc; i++) {
 575     AliTOFcluster *c=(AliTOFcluster*)clusters->UncheckedAt(i);
 576     fClusters[i]=new AliTOFcluster(*c); fN++;
 577     //AliInfo(Form("%4i %4i  %f %f %f  %f %f   %2i %1i %2i %1i %2i",i, fClusters[i]->GetIndex(),fClusters[i]->GetZ(),fClusters[i]->GetR(),fClusters[i]->GetPhi(), fClusters[i]->GetTDC(),fClusters[i]->GetADC(),fClusters[i]->GetDetInd(0),fClusters[i]->GetDetInd(1),fClusters[i]->GetDetInd(2),fClusters[i]->GetDetInd(3),fClusters[i]->GetDetInd(4)));
 578     //AliInfo(Form("%i %f",i, fClusters[i]->GetZ()));
 579   }
 580
 581   //AliInfo(Form("Number of clusters: %d",fN));
 582
 583   return 0;
 584 }
 585 //_________________________________________________________________________
 586 void AliTOFtracker::UnloadClusters() {
 587   //--------------------------------------------------------------------
 588   //This function unloads TOF clusters
 589   //--------------------------------------------------------------------
 590   for (Int_t i=0; i<fN; i++) {
 591     delete fClusters[i];
 592     fClusters[i] = 0x0;
 593   }
 594   fN=0;
 595 }
 596
 597 //_________________________________________________________________________
 598 Int_t AliTOFtracker::FindClusterIndex(Double_t z) const {
 599   //--------------------------------------------------------------------
 600   // This function returns the index of the nearest cluster
 601   //--------------------------------------------------------------------
 602   if (fN==0) return 0;
 603   if (z <= fClusters[0]->GetZ()) return 0;
 604   if (z > fClusters[fN-1]->GetZ()) return fN;
 605   Int_t b=0, e=fN-1, m=(b+e)/2;
 606   for (; b<e; m=(b+e)/2) {
 607     if (z > fClusters[m]->GetZ()) b=m+1;
 608     else e=m;
 609   }
 610   return m;
 611 }
 612
 613 //_________________________________________________________________________
 614 Bool_t AliTOFtracker::GetTrackPoint(Int_t index, AliTrackPoint& p) const
 615 {
 616   // Get track space point with index i
 617   // Coordinates are in the global system
 618   AliTOFcluster *cl = fClusters[index];
 619   Float_t xyz[3];
 620   xyz[0] = cl->GetR()*TMath::Cos(cl->GetPhi());
 621   xyz[1] = cl->GetR()*TMath::Sin(cl->GetPhi());
 622   xyz[2] = cl->GetZ();
 623   Float_t phiangle = (Int_t(cl->GetPhi()*TMath::RadToDeg()/20.)+0.5)*20.*TMath::DegToRad();
 624   Float_t sinphi = TMath::Sin(phiangle), cosphi = TMath::Cos(phiangle);
 625   Float_t tiltangle = fGeom->GetAngles(cl->GetDetInd(1),cl->GetDetInd(2))*TMath::DegToRad();
 626   Float_t sinth = TMath::Sin(tiltangle), costh = TMath::Cos(tiltangle);
 627   Float_t sigmay2 = fGeom->XPad()*fGeom->XPad()/12.;
 628   Float_t sigmaz2 = fGeom->ZPad()*fGeom->ZPad()/12.;
 629   Float_t cov[6];
 630   cov[0] = sinphi*sinphi*sigmay2 + cosphi*cosphi*sinth*sinth*sigmaz2;
 631   cov[1] = -sinphi*cosphi*sigmay2 + sinphi*cosphi*sinth*sinth*sigmaz2;
 632   cov[2] = -cosphi*sinth*costh*sigmaz2;
 633   cov[3] = cosphi*cosphi*sigmay2 + sinphi*sinphi*sinth*sinth*sigmaz2;
 634   cov[4] = -sinphi*sinth*costh*sigmaz2;
 635   cov[5] = costh*costh*sigmaz2;
 636   p.SetXYZ(xyz[0],xyz[1],xyz[2],cov);
 637
 638   // Detector numbering scheme
 639   Int_t nSector = fGeom->NSectors();
 640   Int_t nPlate  = fGeom->NPlates();
 641   Int_t nStripA = fGeom->NStripA();
 642   Int_t nStripB = fGeom->NStripB();
 643   Int_t nStripC = fGeom->NStripC();
 644
 645   Int_t isector = cl->GetDetInd(0);
 646   if (isector >= nSector)
 647     AliError(Form("Wrong sector number in TOF (%d) !",isector));
 648   Int_t iplate = cl->GetDetInd(1);
 649   if (iplate >= nPlate)
 650     AliError(Form("Wrong plate number in TOF (%d) !",iplate));
 651   Int_t istrip = cl->GetDetInd(2);
 652
 653   Int_t stripOffset = 0;
 654   switch (iplate) {
 655   case 0:
 656     stripOffset = 0;
 657     break;
 658   case 1:
 659     stripOffset = nStripC;
 660     break;
 661   case 2:
 662     stripOffset = nStripC+nStripB;
 663     break;
 664   case 3:
 665     stripOffset = nStripC+nStripB+nStripA;
 666     break;
 667   case 4:
 668     stripOffset = nStripC+nStripB+nStripA+nStripB;
 669     break;
 670   default:
 671     AliError(Form("Wrong plate number in TOF (%d) !",iplate));
 672     break;
 673   };
 674
 675   Int_t idet = (2*(nStripC+nStripB)+nStripA)*isector +
 676                stripOffset +
 677                istrip;
 678   UShort_t volid = AliAlignObj::LayerToVolUID(AliAlignObj::kTOF,idet);
 679   p.SetVolumeID((UShort_t)volid);
 680   return kTRUE;
 681 }